@s8fy/pptx-parser 1.0.0

package/dist/pdf-worker.js

@@ -0,0 +1,1692 @@
+//#region src/latin1.ts
+/**
+* Convert raw bytes to a Latin-1 string where each char code maps 1:1 to a byte.
+* NOTE: Do not use TextDecoder('latin1') for binary transport; browsers alias it
+* to Windows-1252 and remap bytes 0x80-0x9F to different code points.
+*/
+function uint8ArrayToLatin1(bytes) {
+	const len = bytes.length;
+	if (len === 0) return "";
+	const chunks = [];
+	const CHUNK = 8192;
+	for (let i = 0; i < len; i += CHUNK) chunks.push(String.fromCharCode.apply(null, bytes.subarray(i, i + CHUNK)));
+	return chunks.join("");
+}
+function arrayBufferToLatin1(buffer) {
+	return uint8ArrayToLatin1(new Uint8Array(buffer));
+}
+function latin1ToUint8Array(latin1) {
+	const len = latin1.length;
+	const bytes = new Uint8Array(len);
+	for (let i = 0; i < len; i++) bytes[i] = latin1.charCodeAt(i) & 255;
+	return bytes;
+}
+//#endregion
+//#region src/wasm-loader.ts
+function fileUrl(url) {
+	try {
+		const parsed = url instanceof URL ? url : new URL(url);
+		return parsed.protocol === "file:" ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function isUnsupportedNodeFileFetch(error) {
+	const cause = error?.cause;
+	const detail = cause instanceof Error ? cause.message : "";
+	return error instanceof TypeError && error.message === "fetch failed" && detail.includes("not implemented");
+}
+async function readNodeFile(url) {
+	const fs = globalThis.process?.getBuiltinModule?.("node:fs")?.promises;
+	if (!fs) throw new Error(`Node.js file loading is unavailable for ${url.href}`);
+	const bytes = await fs.readFile(url);
+	return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+function assertWasmBytes(bytes, url, label, contentType) {
+	const magic = new Uint8Array(bytes, 0, Math.min(bytes.byteLength, 4));
+	if (!(magic.length === 4 && magic[0] === 0 && magic[1] === 97 && magic[2] === 115 && magic[3] === 109)) throw new Error(`[${label}] Invalid WASM response from ${String(url)}: content-type=${contentType}, bytes=${bytes.byteLength}. Check that the WASM asset exists and is served by the app.`);
+}
+async function fetchWasmBytes(url, label) {
+	let response;
+	try {
+		response = await fetch(url);
+	} catch (error) {
+		const localFile = fileUrl(url);
+		if (!localFile || !isUnsupportedNodeFileFetch(error)) throw error;
+		const bytes = await readNodeFile(localFile);
+		assertWasmBytes(bytes, url, label, "application/wasm");
+		return bytes;
+	}
+	if (!response.ok) throw new Error(`[${label}] Failed to load WASM ${String(url)}: ${response.status} ${response.statusText}`);
+	const bytes = await response.arrayBuffer();
+	assertWasmBytes(bytes, url, label, response.headers.get("content-type") || "unknown");
+	return bytes;
+}
+//#endregion
+//#region src/runtime-module-url.ts
+const classicScriptUrl = (() => {
+	if (typeof document === "undefined" || typeof HTMLScriptElement === "undefined") return void 0;
+	return document.currentScript instanceof HTMLScriptElement && document.currentScript.src ? document.currentScript.src : void 0;
+})();
+/** @internal Convert a Node CJS filename to a URL without losing a UNC authority. */
+function fileNameUrl(fileName) {
+	const normalized = fileName.replaceAll("\\", "/");
+	if (normalized.startsWith("//")) {
+		const shareSeparator = normalized.indexOf("/", 2);
+		if (shareSeparator > 2) {
+			const url = new URL("file://localhost/");
+			url.hostname = normalized.slice(2, shareSeparator);
+			url.pathname = normalized.slice(shareSeparator);
+			return url.href;
+		}
+	}
+	const url = new URL("file:///");
+	url.pathname = normalized.startsWith("/") ? normalized : `/${normalized}`;
+	return url.href;
+}
+/** Resolve the current bundle URL in ESM, Node CJS, or a classic UMD script. */
+function runtimeModuleUrl(importMetaUrl) {
+	if (typeof importMetaUrl === "string" && importMetaUrl) return importMetaUrl;
+	if (typeof __filename === "string" && __filename) return fileNameUrl(__filename);
+	return classicScriptUrl;
+}
+/** Resolve a package-relative runtime asset in ESM, Node CJS, or a classic UMD script. */
+function runtimeAssetUrl(asset, importMetaUrl) {
+	const moduleUrl = runtimeModuleUrl(importMetaUrl);
+	if (!moduleUrl) throw new Error(`Unable to resolve runtime asset URL: ${asset}`);
+	return new URL(asset, moduleUrl);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/fflate@0.8.3/node_modules/fflate/esm/browser.js
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var fleb = new u8([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	2,
+	2,
+	2,
+	2,
+	3,
+	3,
+	3,
+	3,
+	4,
+	4,
+	4,
+	4,
+	5,
+	5,
+	5,
+	5,
+	0,
+	0,
+	0,
+	0
+]);
+var fdeb = new u8([
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	2,
+	2,
+	3,
+	3,
+	4,
+	4,
+	5,
+	5,
+	6,
+	6,
+	7,
+	7,
+	8,
+	8,
+	9,
+	9,
+	10,
+	10,
+	11,
+	11,
+	12,
+	12,
+	13,
+	13,
+	0,
+	0
+]);
+var clim = new u8([
+	16,
+	17,
+	18,
+	0,
+	8,
+	7,
+	9,
+	6,
+	10,
+	5,
+	11,
+	4,
+	12,
+	3,
+	13,
+	2,
+	14,
+	1,
+	15
+]);
+var freb = function(eb, start) {
+	var b = new u16(31);
+	for (var i = 0; i < 31; ++i) b[i] = start += 1 << eb[i - 1];
+	var r = new i32(b[30]);
+	for (var i = 1; i < 30; ++i) for (var j = b[i]; j < b[i + 1]; ++j) r[j] = j - b[i] << 5 | i;
+	return {
+		b,
+		r
+	};
+};
+var _a = freb(fleb, 2);
+var fl = _a.b;
+var revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0);
+var fd = _b.b;
+_b.r;
+var rev = new u16(32768);
+for (var i = 0; i < 32768; ++i) {
+	var x = (i & 43690) >> 1 | (i & 21845) << 1;
+	x = (x & 52428) >> 2 | (x & 13107) << 2;
+	x = (x & 61680) >> 4 | (x & 3855) << 4;
+	rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var hMap = (function(cd, mb, r) {
+	var s = cd.length;
+	var i = 0;
+	var l = new u16(mb);
+	for (; i < s; ++i) if (cd[i]) ++l[cd[i] - 1];
+	var le = new u16(mb);
+	for (i = 1; i < mb; ++i) le[i] = le[i - 1] + l[i - 1] << 1;
+	var co;
+	if (r) {
+		co = new u16(1 << mb);
+		var rvb = 15 - mb;
+		for (i = 0; i < s; ++i) if (cd[i]) {
+			var sv = i << 4 | cd[i];
+			var r_1 = mb - cd[i];
+			var v = le[cd[i] - 1]++ << r_1;
+			for (var m = v | (1 << r_1) - 1; v <= m; ++v) co[rev[v] >> rvb] = sv;
+		}
+	} else {
+		co = new u16(s);
+		for (i = 0; i < s; ++i) if (cd[i]) co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
+	}
+	return co;
+});
+var flt = new u8(288);
+for (var i = 0; i < 144; ++i) flt[i] = 8;
+for (var i = 144; i < 256; ++i) flt[i] = 9;
+for (var i = 256; i < 280; ++i) flt[i] = 7;
+for (var i = 280; i < 288; ++i) flt[i] = 8;
+var fdt = new u8(32);
+for (var i = 0; i < 32; ++i) fdt[i] = 5;
+var flrm = /*#__PURE__*/ hMap(flt, 9, 1);
+var fdrm = /*#__PURE__*/ hMap(fdt, 5, 1);
+var max = function(a) {
+	var m = a[0];
+	for (var i = 1; i < a.length; ++i) if (a[i] > m) m = a[i];
+	return m;
+};
+var bits = function(d, p, m) {
+	var o = p / 8 | 0;
+	return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+};
+var bits16 = function(d, p) {
+	var o = p / 8 | 0;
+	return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+};
+var shft = function(p) {
+	return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+	if (s == null || s < 0) s = 0;
+	if (e == null || e > v.length) e = v.length;
+	return new u8(v.subarray(s, e));
+};
+var ec = [
+	"unexpected EOF",
+	"invalid block type",
+	"invalid length/literal",
+	"invalid distance",
+	"stream finished",
+	"no stream handler",
+	,
+	"no callback",
+	"invalid UTF-8 data",
+	"extra field too long",
+	"date not in range 1980-2099",
+	"filename too long",
+	"stream finishing",
+	"invalid zip data"
+];
+var err = function(ind, msg, nt) {
+	var e = new Error(msg || ec[ind]);
+	e.code = ind;
+	if (Error.captureStackTrace) Error.captureStackTrace(e, err);
+	if (!nt) throw e;
+	return e;
+};
+var inflt = function(dat, st, buf, dict) {
+	var sl = dat.length, dl = dict ? dict.length : 0;
+	if (!sl || st.f && !st.l) return buf || new u8(0);
+	var noBuf = !buf;
+	var resize = noBuf || st.i != 2;
+	var noSt = st.i;
+	if (noBuf) buf = new u8(sl * 3);
+	var cbuf = function(l) {
+		var bl = buf.length;
+		if (l > bl) {
+			var nbuf = new u8(Math.max(bl * 2, l));
+			nbuf.set(buf);
+			buf = nbuf;
+		}
+	};
+	var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+	var tbts = sl * 8;
+	do {
+		if (!lm) {
+			final = bits(dat, pos, 1);
+			var type = bits(dat, pos + 1, 3);
+			pos += 3;
+			if (!type) {
+				var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+				if (t > sl) {
+					if (noSt) err(0);
+					break;
+				}
+				if (resize) cbuf(bt + l);
+				buf.set(dat.subarray(s, t), bt);
+				st.b = bt += l, st.p = pos = t * 8, st.f = final;
+				continue;
+			} else if (type == 1) lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+			else if (type == 2) {
+				var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+				var tl = hLit + bits(dat, pos + 5, 31) + 1;
+				pos += 14;
+				var ldt = new u8(tl);
+				var clt = new u8(19);
+				for (var i = 0; i < hcLen; ++i) clt[clim[i]] = bits(dat, pos + i * 3, 7);
+				pos += hcLen * 3;
+				var clb = max(clt), clbmsk = (1 << clb) - 1;
+				var clm = hMap(clt, clb, 1);
+				for (var i = 0; i < tl;) {
+					var r = clm[bits(dat, pos, clbmsk)];
+					pos += r & 15;
+					var s = r >> 4;
+					if (s < 16) ldt[i++] = s;
+					else {
+						var c = 0, n = 0;
+						if (s == 16) n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+						else if (s == 17) n = 3 + bits(dat, pos, 7), pos += 3;
+						else if (s == 18) n = 11 + bits(dat, pos, 127), pos += 7;
+						while (n--) ldt[i++] = c;
+					}
+				}
+				var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+				lbt = max(lt);
+				dbt = max(dt);
+				lm = hMap(lt, lbt, 1);
+				dm = hMap(dt, dbt, 1);
+			} else err(1);
+			if (pos > tbts) {
+				if (noSt) err(0);
+				break;
+			}
+		}
+		if (resize) cbuf(bt + 131072);
+		var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+		var lpos = pos;
+		for (;; lpos = pos) {
+			var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+			pos += c & 15;
+			if (pos > tbts) {
+				if (noSt) err(0);
+				break;
+			}
+			if (!c) err(2);
+			if (sym < 256) buf[bt++] = sym;
+			else if (sym == 256) {
+				lpos = pos, lm = null;
+				break;
+			} else {
+				var add = sym - 254;
+				if (sym > 264) {
+					var i = sym - 257, b = fleb[i];
+					add = bits(dat, pos, (1 << b) - 1) + fl[i];
+					pos += b;
+				}
+				var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+				if (!d) err(3);
+				pos += d & 15;
+				var dt = fd[dsym];
+				if (dsym > 3) {
+					var b = fdeb[dsym];
+					dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+				}
+				if (pos > tbts) {
+					if (noSt) err(0);
+					break;
+				}
+				if (resize) cbuf(bt + 131072);
+				var end = bt + add;
+				if (bt < dt) {
+					var shift = dl - dt, dend = Math.min(dt, end);
+					if (shift + bt < 0) err(3);
+					for (; bt < dend; ++bt) buf[bt] = dict[shift + bt];
+				}
+				for (; bt < end; ++bt) buf[bt] = buf[bt - dt];
+			}
+		}
+		st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+		if (lm) final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+	} while (!final);
+	return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+var et = /*#__PURE__*/ new u8(0);
+var b2 = function(d, b) {
+	return d[b] | d[b + 1] << 8;
+};
+var b4 = function(d, b) {
+	return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+};
+var b8 = function(d, b) {
+	return b4(d, b) + b4(d, b + 4) * 4294967296;
+};
+function inflateSync(data, opts) {
+	return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
+}
+var td = typeof TextDecoder != "undefined" && /*#__PURE__*/ new TextDecoder();
+try {
+	td.decode(et, { stream: true });
+} catch (e) {}
+var dutf8 = function(d) {
+	for (var r = "", i = 0;;) {
+		var c = d[i++];
+		var eb = (c > 127) + (c > 223) + (c > 239);
+		if (i + eb > d.length) return {
+			s: r,
+			r: slc(d, i - 1)
+		};
+		if (!eb) r += String.fromCharCode(c);
+		else if (eb == 3) c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | d[i++] & 63) - 65536, r += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
+		else if (eb & 1) r += String.fromCharCode((c & 31) << 6 | d[i++] & 63);
+		else r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | d[i++] & 63);
+	}
+};
+/**
+* Converts a Uint8Array to a string
+* @param dat The data to decode to string
+* @param latin1 Whether or not to interpret the data as Latin-1. This should
+*               not need to be true unless encoding to binary string.
+* @returns The original UTF-8/Latin-1 string
+*/
+function strFromU8(dat, latin1) {
+	if (latin1) {
+		var r = "";
+		for (var i = 0; i < dat.length; i += 16384) r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));
+		return r;
+	} else if (td) return td.decode(dat);
+	else {
+		var _a = dutf8(dat), s = _a.s, r = _a.r;
+		if (r.length) err(8);
+		return s;
+	}
+}
+var slzh = function(d, b) {
+	return b + 30 + b2(d, b + 26) + b2(d, b + 28);
+};
+var zh = function(d, b, z) {
+	var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl;
+	var _a = z64hs(d, es, efl, z, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a[0], su = _a[1], off = _a[2];
+	return [
+		b2(d, b + 10),
+		sc,
+		su,
+		fn,
+		es + efl + b2(d, b + 32),
+		off
+	];
+};
+var z64hs = function(d, b, l, z, sc, su, off) {
+	var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
+	var nf = nsc + nsu + noff;
+	if (z && nf) {
+		for (; b + 4 < e; b += 4 + b2(d, b + 2)) if (b2(d, b) == 1) return [
+			nsc ? b8(d, b + 4 + 8 * nsu) : sc,
+			nsu ? b8(d, b + 4) : su,
+			noff ? b8(d, b + 4 + 8 * (nsu + nsc)) : off,
+			1
+		];
+		if (z < 2) err(13);
+	}
+	return [
+		sc,
+		su,
+		off,
+		0
+	];
+};
+/**
+* Synchronously decompresses a ZIP archive. Prefer using `unzip` for better
+* performance with more than one file.
+* @param data The raw compressed ZIP file
+* @param opts The ZIP extraction options
+* @returns The decompressed files
+*/
+function unzipSync(data, opts) {
+	var files = {};
+	var e = data.length - 22;
+	for (; b4(data, e) != 101010256; --e) if (!e || data.length - e > 65558) err(13);
+	var c = b2(data, e + 8);
+	if (!c) return {};
+	var o = b4(data, e + 16);
+	var z = b4(data, e - 20) == 117853008;
+	if (z) {
+		var ze = b4(data, e - 12);
+		z = b4(data, ze) == 101075792;
+		if (z) {
+			c = b4(data, ze + 32);
+			o = b4(data, ze + 48);
+		}
+	}
+	var fltr = opts && opts.filter;
+	for (var i = 0; i < c; ++i) {
+		var _a = zh(data, o, z), c_2 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off);
+		o = no;
+		if (!fltr || fltr({
+			name: fn,
+			size: sc,
+			originalSize: su,
+			compression: c_2
+		})) {
+			if (!c_2) files[fn] = slc(data, b, b + sc);
+			else if (c_2 == 8) files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
+			else err(14, "unknown compression type " + c_2);
+		}
+	}
+	return files;
+}
+//#endregion
+//#region src/resource-policy.generated.ts
+const RESOURCE_POLICY_CONTRACT = {
+	schemaVersion: "xdoc-resource-policy-registry/v1",
+	policyVersion: "2026.08",
+	profiles: [{
+		id: "native-api",
+		inputBytes: 314572800,
+		zipEntries: 5e4,
+		zipExpansionBytes: 1073741824,
+		zipEntryBytes: 268435456,
+		zipRatioThresholdBytes: 67108864,
+		zipRatioMax: 200,
+		xmlDepth: 256,
+		xmlNodes: 1e7,
+		textNodeBytes: 16777216,
+		imagePixels: 2e8,
+		outputBytes: 1073741824,
+		wallClockMs: 9e5,
+		tempDiskBytes: 4294967296
+	}, {
+		id: "browser-viewer",
+		inputBytes: 104857600,
+		zipEntries: 1e4,
+		zipExpansionBytes: 536870912,
+		zipEntryBytes: 134217728,
+		zipRatioThresholdBytes: 67108864,
+		zipRatioMax: 200,
+		xmlDepth: 256,
+		xmlNodes: 2e6,
+		textNodeBytes: 8388608,
+		imagePixels: 1e8,
+		outputBytes: 536870912,
+		wallClockMs: 6e4,
+		tempDiskBytes: null
+	}],
+	stableReasons: [
+		"resource_input_too_large",
+		"resource_zip_entries_exceeded",
+		"resource_zip_entry_too_large",
+		"resource_zip_expansion_exceeded",
+		"resource_zip_ratio_exceeded",
+		"resource_xml_depth_exceeded",
+		"resource_xml_nodes_exceeded",
+		"resource_text_node_too_large",
+		"resource_image_pixels_exceeded",
+		"resource_timeout",
+		"resource_temp_disk_exceeded",
+		"resource_output_too_large"
+	],
+	configurationBoundary: "compiled profiles; runtime configuration may only tighten; licenses and requests cannot change limits",
+	hostEnforcementResponsibilities: [
+		"process-memory",
+		"cpu-quota",
+		"process-count"
+	],
+	precedence: [
+		"raw-input",
+		"zip-entry-count",
+		"zip-entry-size",
+		"zip-expansion",
+		"zip-ratio",
+		"xml-structure",
+		"image-pixels",
+		"task-budgets",
+		"output"
+	]
+};
+const BROWSER_RESOURCE_LIMITS = {
+	id: "browser-viewer",
+	inputBytes: 104857600,
+	zipEntries: 1e4,
+	zipExpansionBytes: 536870912,
+	zipEntryBytes: 134217728,
+	zipRatioThresholdBytes: 67108864,
+	zipRatioMax: 200,
+	xmlDepth: 256,
+	xmlNodes: 2e6,
+	textNodeBytes: 8388608,
+	imagePixels: 1e8,
+	outputBytes: 536870912,
+	wallClockMs: 6e4,
+	tempDiskBytes: null
+};
+//#endregion
+//#region src/resource-policy.ts
+var ResourcePolicyError = class extends Error {
+	constructor(details) {
+		super(`${details.reason}: ${details.subject} observed ${details.observed} ${details.unit}; policy limit is ${details.limit} ${details.unit}. This is an engineering safety limit, not a plan entitlement; reduce or split the input.`);
+		this.name = "ResourcePolicyError";
+		this.details = details;
+	}
+};
+function fail(reason, stage, subject, limit, observed, unit) {
+	throw new ResourcePolicyError({
+		reason,
+		stage,
+		subject,
+		limit,
+		observed,
+		unit,
+		policyVersion: RESOURCE_POLICY_CONTRACT.policyVersion,
+		commercialUpgradeApplicable: false
+	});
+}
+function checkBrowserInput(bytes, subject = "PPTX input") {
+	if (bytes > BROWSER_RESOURCE_LIMITS.inputBytes) fail("resource_input_too_large", "input", subject, BROWSER_RESOURCE_LIMITS.inputBytes, bytes, "bytes");
+}
+function checkBrowserOutput(bytes, subject = "output") {
+	if (bytes > BROWSER_RESOURCE_LIMITS.outputBytes) fail("resource_output_too_large", "output", subject, BROWSER_RESOURCE_LIMITS.outputBytes, bytes, "bytes");
+}
+function checkBrowserElapsed(startedAt, subject = "parse wall clock") {
+	checkBrowserElapsedMs(Math.max(0, Math.ceil(performance.now() - startedAt)), subject);
+}
+function checkBrowserElapsedMs(elapsed, subject = "parse wall clock") {
+	if (elapsed > BROWSER_RESOURCE_LIMITS.wallClockMs) fail("resource_timeout", "runtime", subject, BROWSER_RESOURCE_LIMITS.wallClockMs, elapsed, "milliseconds");
+}
+function isResourcePolicyError(error) {
+	return error instanceof ResourcePolicyError;
+}
+function resourcePolicyErrorFromDetails(value) {
+	if (!value || typeof value !== "object") return null;
+	const details = value;
+	if (typeof details.reason !== "string" || !RESOURCE_POLICY_CONTRACT.stableReasons.includes(details.reason) || typeof details.stage !== "string" || typeof details.subject !== "string" || !Number.isSafeInteger(details.limit) || (details.limit ?? -1) < 0 || !Number.isSafeInteger(details.observed) || (details.observed ?? -1) < 0 || typeof details.unit !== "string" || details.policyVersion !== RESOURCE_POLICY_CONTRACT.policyVersion || details.commercialUpgradeApplicable !== false) return null;
+	return new ResourcePolicyError({
+		reason: details.reason,
+		stage: details.stage,
+		subject: details.subject,
+		limit: details.limit,
+		observed: details.observed,
+		unit: details.unit,
+		policyVersion: details.policyVersion,
+		commercialUpgradeApplicable: false
+	});
+}
+function checkBrowserZipEntries(entries) {
+	if (entries.length > BROWSER_RESOURCE_LIMITS.zipEntries) fail("resource_zip_entries_exceeded", "zip", "ZIP entry count", BROWSER_RESOURCE_LIMITS.zipEntries, entries.length, "entries");
+	let expandedTotal = 0;
+	for (const entry of entries) {
+		const expanded = Math.max(0, entry.originalSize);
+		const compressed = Math.max(0, entry.size);
+		if (expanded > BROWSER_RESOURCE_LIMITS.zipEntryBytes) fail("resource_zip_entry_too_large", "zip", entry.name, BROWSER_RESOURCE_LIMITS.zipEntryBytes, expanded, "bytes");
+		expandedTotal = Math.min(Number.MAX_SAFE_INTEGER, expandedTotal + expanded);
+		if (expandedTotal > BROWSER_RESOURCE_LIMITS.zipExpansionBytes) fail("resource_zip_expansion_exceeded", "zip", `cumulative ZIP expansion at ${entry.name}`, BROWSER_RESOURCE_LIMITS.zipExpansionBytes, expandedTotal, "bytes");
+		if (expanded > BROWSER_RESOURCE_LIMITS.zipRatioThresholdBytes && (compressed <= 0 || expanded / compressed > BROWSER_RESOURCE_LIMITS.zipRatioMax)) fail("resource_zip_ratio_exceeded", "zip", entry.name, BROWSER_RESOURCE_LIMITS.zipRatioMax, compressed <= 0 ? expanded : Math.ceil(expanded / compressed), "ratio");
+	}
+}
+/**
+* Decompress a browser PPTX only after fflate exposes each central-directory
+* record to the policy filter. XML and image checks run before any parser or
+* renderer consumes the expanded payloads.
+*/
+function unzipBrowserPptx(data) {
+	const input = data instanceof Uint8Array ? data : new Uint8Array(data);
+	checkBrowserInput(input.byteLength);
+	const entries = [];
+	unzipSync(input, { filter(info) {
+		entries.push(info);
+		return false;
+	} });
+	checkBrowserZipEntries(entries);
+	const files = unzipSync(input);
+	checkBrowserXmlParts(Object.entries(files));
+	for (const [name, bytes] of Object.entries(files)) checkBrowserImagePayload(bytes, name);
+	return files;
+}
+var XmlBudget = class {
+	constructor() {
+		this.nodes = 0;
+	}
+	observeNode(depth, subject) {
+		if (depth > BROWSER_RESOURCE_LIMITS.xmlDepth) fail("resource_xml_depth_exceeded", "xml", subject, BROWSER_RESOURCE_LIMITS.xmlDepth, depth, "levels");
+		this.nodes += 1;
+		if (this.nodes > BROWSER_RESOURCE_LIMITS.xmlNodes) fail("resource_xml_nodes_exceeded", "xml", subject, BROWSER_RESOURCE_LIMITS.xmlNodes, this.nodes, "nodes");
+	}
+	observeText(depth, bytes, subject) {
+		this.observeNode(depth, subject);
+		if (bytes > BROWSER_RESOURCE_LIMITS.textNodeBytes) fail("resource_text_node_too_large", "xml", subject, BROWSER_RESOURCE_LIMITS.textNodeBytes, bytes, "bytes");
+	}
+};
+function isXmlPart(name) {
+	const normalized = name.toLowerCase();
+	return normalized.endsWith(".xml") || normalized.endsWith(".rels") || normalized.endsWith(".svg") || normalized.endsWith(".vml");
+}
+function looksLikeXmlPayload(input) {
+	let position = input.length >= 3 && input[0] === 239 && input[1] === 187 && input[2] === 191 ? 3 : 0;
+	while (position < input.length && isSpace(input[position])) position += 1;
+	if (position + 1 >= input.length || input[position] !== 60) return false;
+	const next = input[position + 1];
+	return next === 63 || next === 33 || next === 95 || next === 58 || next >= 65 && next <= 90 || next >= 97 && next <= 122 || next >= 128;
+}
+function checkBrowserXmlParts(parts) {
+	const budget = new XmlBudget();
+	for (const [name, bytes] of parts) if (isXmlPart(name) || looksLikeXmlPayload(bytes)) scanXml(bytes, budget, name);
+}
+const ascii = (value) => new TextEncoder().encode(value);
+const COMMENT = ascii("<!--");
+const COMMENT_END = ascii("-->");
+const CDATA = ascii("<![CDATA[");
+const CDATA_END = ascii("]]>");
+const PROCESSING = ascii("<?");
+const PROCESSING_END = ascii("?>");
+const DOCTYPE_UPPER = ascii("<!DOCTYPE");
+const DOCTYPE_LOWER = ascii("<!doctype");
+function matchesAt(input, start, expected) {
+	if (start < 0 || start + expected.length > input.length) return false;
+	for (let index = 0; index < expected.length; index += 1) if (input[start + index] !== expected[index]) return false;
+	return true;
+}
+function findTerminator(input, start, expected) {
+	const last = input.length - expected.length;
+	for (let index = start; index <= last; index += 1) if (matchesAt(input, index, expected)) return index;
+	return input.length;
+}
+function findTagEnd(input, start) {
+	let quote = 0;
+	for (let index = start; index < input.length; index += 1) {
+		const value = input[index];
+		if (quote !== 0) {
+			if (value === quote) quote = 0;
+		} else if (value === 34 || value === 39) quote = value;
+		else if (value === 62) return index + 1;
+	}
+	return input.length;
+}
+function skipDoctype(input, start) {
+	let quote = 0;
+	let subsetDepth = 0;
+	for (let index = start; index < input.length; index += 1) {
+		const value = input[index];
+		if (quote !== 0) {
+			if (value === quote) quote = 0;
+		} else if (value === 34 || value === 39) quote = value;
+		else if (value === 91) subsetDepth += 1;
+		else if (value === 93 && subsetDepth > 0) subsetDepth -= 1;
+		else if (value === 62 && subsetDepth === 0) return index + 1;
+	}
+	return input.length;
+}
+function isSpace(value) {
+	return value === 32 || value === 9 || value === 10 || value === 13;
+}
+function scanXml(input, budget, subject) {
+	let position = 0;
+	let depth = 0;
+	while (position < input.length) {
+		if (input[position] !== 60) {
+			const start = position;
+			while (position < input.length && input[position] !== 60) position += 1;
+			if (position > start) budget.observeText(depth, position - start, `${subject} text`);
+			continue;
+		}
+		if (matchesAt(input, position, COMMENT)) {
+			budget.observeNode(depth, `${subject} comment`);
+			const end = findTerminator(input, position + COMMENT.length, COMMENT_END);
+			position = end === input.length ? end : end + COMMENT_END.length;
+			continue;
+		}
+		if (matchesAt(input, position, CDATA)) {
+			const start = position + CDATA.length;
+			const end = findTerminator(input, start, CDATA_END);
+			budget.observeText(depth, end - start, `${subject} CDATA`);
+			position = end === input.length ? end : end + CDATA_END.length;
+			continue;
+		}
+		if (matchesAt(input, position, PROCESSING)) {
+			budget.observeNode(depth, `${subject} processing instruction`);
+			const end = findTerminator(input, position + PROCESSING.length, PROCESSING_END);
+			position = end === input.length ? end : end + PROCESSING_END.length;
+			continue;
+		}
+		if (matchesAt(input, position, DOCTYPE_UPPER) || matchesAt(input, position, DOCTYPE_LOWER)) {
+			position = skipDoctype(input, position + 2);
+			continue;
+		}
+		if (position + 1 < input.length && input[position + 1] === 47) {
+			position = findTagEnd(input, position + 2);
+			if (depth > 0) depth -= 1;
+			continue;
+		}
+		if (position + 1 < input.length && input[position + 1] === 33) {
+			position = findTagEnd(input, position + 2);
+			continue;
+		}
+		const end = findTagEnd(input, position + 1);
+		let tail = end - 2;
+		while (tail > position && isSpace(input[tail])) tail -= 1;
+		const selfClosing = tail > position && input[tail] === 47;
+		depth += 1;
+		budget.observeNode(depth, subject);
+		if (selfClosing) depth -= 1;
+		position = end;
+	}
+}
+function readU16BE(data, offset) {
+	return data[offset] * 256 + data[offset + 1];
+}
+function readU16LE(data, offset) {
+	return data[offset] + data[offset + 1] * 256;
+}
+function readU24LE(data, offset) {
+	return data[offset] + data[offset + 1] * 256 + data[offset + 2] * 65536;
+}
+function readU32BE(data, offset) {
+	return data[offset] * 16777216 + data[offset + 1] * 65536 + data[offset + 2] * 256 + data[offset + 3];
+}
+function readU32LE(data, offset) {
+	return data[offset] + data[offset + 1] * 256 + data[offset + 2] * 65536 + data[offset + 3] * 16777216;
+}
+function bytesEqual(data, offset, expected) {
+	if (offset < 0 || offset + expected.length > data.length) return false;
+	return expected.every((value, index) => data[offset + index] === value);
+}
+function probeImageDimensions(data) {
+	if (data.length >= 24 && bytesEqual(data, 0, [
+		137,
+		80,
+		78,
+		71,
+		13,
+		10,
+		26,
+		10
+	]) && bytesEqual(data, 12, [
+		73,
+		72,
+		68,
+		82
+	])) return {
+		width: readU32BE(data, 16),
+		height: readU32BE(data, 20)
+	};
+	if (data.length >= 10 && (bytesEqual(data, 0, [
+		71,
+		73,
+		70,
+		56,
+		55,
+		97
+	]) || bytesEqual(data, 0, [
+		71,
+		73,
+		70,
+		56,
+		57,
+		97
+	]))) return {
+		width: readU16LE(data, 6),
+		height: readU16LE(data, 8)
+	};
+	if (data.length >= 26 && bytesEqual(data, 0, [66, 77])) {
+		const dib = readU32LE(data, 14);
+		if (dib === 12) return {
+			width: readU16LE(data, 18),
+			height: readU16LE(data, 20)
+		};
+		if (dib >= 40) {
+			const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+			return {
+				width: Math.abs(view.getInt32(18, true)),
+				height: Math.abs(view.getInt32(22, true))
+			};
+		}
+	}
+	if (data.length >= 30 && bytesEqual(data, 0, [
+		82,
+		73,
+		70,
+		70
+	]) && bytesEqual(data, 8, [
+		87,
+		69,
+		66,
+		80
+	])) {
+		if (bytesEqual(data, 12, [
+			86,
+			80,
+			56,
+			88
+		])) return {
+			width: 1 + readU24LE(data, 24),
+			height: 1 + readU24LE(data, 27)
+		};
+		if (bytesEqual(data, 12, [
+			86,
+			80,
+			56,
+			76
+		]) && data[20] === 47) return {
+			width: 1 + (data[21] | (data[22] & 63) << 8),
+			height: 1 + (data[22] >> 6 | data[23] << 2 | (data[24] & 15) << 10)
+		};
+		if (bytesEqual(data, 12, [
+			86,
+			80,
+			56,
+			32
+		]) && bytesEqual(data, 23, [
+			157,
+			1,
+			42
+		])) return {
+			width: (data[26] | data[27] << 8) & 16383,
+			height: (data[28] | data[29] << 8) & 16383
+		};
+	}
+	if (data.length >= 4 && data[0] === 255 && data[1] === 216) {
+		let position = 2;
+		while (position + 3 < data.length) {
+			while (position < data.length && data[position] !== 255) position += 1;
+			while (position < data.length && data[position] === 255) position += 1;
+			if (position >= data.length) break;
+			const marker = data[position];
+			position += 1;
+			if (marker === 1 || marker === 216 || marker === 217 || marker >= 208 && marker <= 215) continue;
+			if (position + 1 >= data.length) break;
+			const length = readU16BE(data, position);
+			if (length < 2 || position + length > data.length) break;
+			if ((marker >= 192 && marker <= 195 || marker >= 197 && marker <= 199 || marker >= 201 && marker <= 203 || marker >= 205 && marker <= 207) && length >= 7) return {
+				width: readU16BE(data, position + 5),
+				height: readU16BE(data, position + 3)
+			};
+			position += length;
+		}
+	}
+	return probeTiff(data);
+}
+function checkBrowserImagePayload(data, subject = "image") {
+	const dimensions = probeImageDimensions(data);
+	if (dimensions) checkImageDimensions(dimensions.width, dimensions.height, subject);
+}
+function probeTiff(data) {
+	if (data.length < 8) return null;
+	const little = bytesEqual(data, 0, [
+		73,
+		73,
+		42,
+		0
+	]);
+	if (!little && !bytesEqual(data, 0, [
+		77,
+		77,
+		0,
+		42
+	])) return null;
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const offset = view.getUint32(4, little);
+	if (offset + 2 > data.length) return null;
+	const count = view.getUint16(offset, little);
+	let width = null;
+	let height = null;
+	for (let index = 0; index < count; index += 1) {
+		const entry = offset + 2 + index * 12;
+		if (entry + 12 > data.length) return null;
+		const tag = view.getUint16(entry, little);
+		if ((tag === 256 || tag === 257) && view.getUint32(entry + 4, little) === 1) {
+			const type = view.getUint16(entry + 2, little);
+			const value = type === 3 ? view.getUint16(entry + 8, little) : type === 4 ? view.getUint32(entry + 8, little) : 0;
+			if (tag === 256) width = value;
+			else height = value;
+		}
+	}
+	return width && height ? {
+		width,
+		height
+	} : null;
+}
+function checkImageDimensions(width, height, subject) {
+	if (width <= 0 || height <= 0) return;
+	const observed = width * height;
+	if (!Number.isSafeInteger(observed) || observed > BROWSER_RESOURCE_LIMITS.imagePixels) fail("resource_image_pixels_exceeded", "image", subject, BROWSER_RESOURCE_LIMITS.imagePixels, Number.isSafeInteger(observed) ? observed : Number.MAX_SAFE_INTEGER, "pixels");
+}
+//#endregion
+//#region src/worker-error.ts
+function property(value, key) {
+	try {
+		return value && typeof value === "object" ? value[key] : void 0;
+	} catch {
+		return;
+	}
+}
+function cloneFact(value) {
+	try {
+		return structuredClone(value);
+	} catch {
+		return;
+	}
+}
+function serializeWorkerError(error, seen = /* @__PURE__ */ new Map()) {
+	const previous = seen.get(error);
+	if (previous) return previous;
+	const name = property(error, "name");
+	const message = property(error, "message");
+	let fallback = "Worker operation failed";
+	if (typeof message !== "string") try {
+		fallback = String(error);
+	} catch {}
+	const result = {
+		name: typeof name === "string" ? name : "Error",
+		message: typeof message === "string" ? message : fallback
+	};
+	seen.set(error, result);
+	const code = property(error, "code");
+	if (typeof code === "string" || typeof code === "number") result.code = code;
+	const details = cloneFact(property(error, "details"));
+	if (details !== void 0) result.details = details;
+	const cause = property(error, "cause");
+	if (cause !== void 0) {
+		if (cause instanceof Error || typeof property(cause, "message") === "string") result.cause = {
+			kind: "error",
+			error: serializeWorkerError(cause, seen)
+		};
+		else {
+			const value = cloneFact(cause);
+			if (value !== void 0) result.cause = {
+				kind: "value",
+				value
+			};
+		}
+	}
+	return result;
+}
+//#endregion
+//#region src/pdf-converter.ts
+const officeFontFallbacksBridgeTypeface = "__xdoc_office_font_fallbacks__";
+const PDF_EMOJI_FALLBACK_TYPEFACE = "__pdf_emoji_fallback__";
+const PDF_BRIDGE_WORD_BYTES = 4;
+let pdfWasmSource = null;
+let pdfWasmInstance = null;
+let pdfWasmLoadSource = null;
+let pdfWasmLoadPromise = null;
+const conversionTailsByInstance = /* @__PURE__ */ new WeakMap();
+let unicodeFallbackFontCacheKey = null;
+let unicodeFallbackFontPromise = null;
+let emojiFallbackFontCacheKey = null;
+let emojiFallbackFontPromise = null;
+function createPdfWasmImports() {
+	return {
+		__moonbit_time_unstable: { now: () => BigInt(Date.now()) },
+		console: { log: (...args) => {
+			console.log(...args);
+		} }
+	};
+}
+function bytesToArrayBuffer(bytes) {
+	return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+function hasBufferedPdfBridge(mod) {
+	return typeof mod.reset_pdf_bridge_input === "function" && typeof mod.push_pdf_bridge_input_word === "function" && typeof mod.register_pdf_font_buffered === "function" && typeof mod.register_pdf_emoji_bitmap_buffered === "function" && typeof mod.register_pdf_math_fallback_buffered === "function" && typeof mod.set_pdf_office_font_fallbacks === "function" && typeof mod.run_pdf_conversion_buffered === "function" && typeof mod.pdf_bridge_output_len === "function" && typeof mod.pdf_bridge_output_word === "function" && typeof mod.clear_pdf_bridge_output === "function";
+}
+function assertPdfWasmApi(mod) {
+	if (!hasBufferedPdfBridge(mod) && typeof mod.convert_pptx_to_pdf_from_string !== "function") throw new Error("PDF converter WASM does not expose a supported host bridge");
+}
+function utf8Bytes(value) {
+	return new TextEncoder().encode(value);
+}
+function writePdfBridgeInput(mod, chunks) {
+	mod.reset_pdf_bridge_input();
+	let written = 0;
+	for (const chunk of chunks) for (let offset = 0; offset < chunk.byteLength; offset += PDF_BRIDGE_WORD_BYTES) {
+		const byteCount = Math.min(PDF_BRIDGE_WORD_BYTES, chunk.byteLength - offset);
+		let word = 0;
+		for (let index = 0; index < byteCount; index += 1) word |= (chunk[offset + index] ?? 0) << index * 8;
+		written += byteCount;
+		if (mod.push_pdf_bridge_input_word(word, byteCount) !== written) throw new Error("PDF converter WASM rejected buffered input");
+	}
+}
+function readPdfBridgeOutput(mod, reportedLength) {
+	try {
+		const length = mod.pdf_bridge_output_len();
+		if (!Number.isSafeInteger(length) || length !== reportedLength || length < 0) throw new Error("PDF converter WASM returned an invalid buffered output length");
+		checkBrowserOutput(length, "PDF output");
+		const output = new Uint8Array(length);
+		for (let offset = 0; offset < length; offset += PDF_BRIDGE_WORD_BYTES) {
+			const word = mod.pdf_bridge_output_word(offset / PDF_BRIDGE_WORD_BYTES);
+			if (!Number.isInteger(word)) throw new Error("PDF converter WASM returned an invalid buffered output word");
+			for (let index = 0; index < PDF_BRIDGE_WORD_BYTES && offset + index < length; index += 1) output[offset + index] = word >>> index * 8 & 255;
+		}
+		return output;
+	} finally {
+		mod.clear_pdf_bridge_output();
+	}
+}
+function decodeXmlEntities(str) {
+	if (!str.includes("&")) return str;
+	return str.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&apos;/g, "'").replace(/&#x([0-9a-fA-F]+);/g, (_, hex) => String.fromCodePoint(parseInt(hex, 16))).replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(parseInt(dec, 10))).replace(/&amp;/g, "&");
+}
+function containsNonLatinCodepoint(text) {
+	for (const char of text) if ((char.codePointAt(0) ?? 0) > 255) return true;
+	return false;
+}
+function isDefaultEmojiPresentationCodepoint(codepoint) {
+	return codepoint >= 126976 && codepoint <= 129791 || codepoint === 169 || codepoint === 174 || codepoint === 8252 || codepoint === 8265 || codepoint === 8482 || codepoint === 8505 || codepoint === 8986 || codepoint === 8987 || codepoint === 9167 || codepoint >= 9193 && codepoint <= 9199 || codepoint === 9200 || codepoint === 9203 || codepoint >= 9208 && codepoint <= 9210 || codepoint === 9410 || codepoint >= 9725 && codepoint <= 9726 || codepoint >= 9748 && codepoint <= 9749 || codepoint >= 9800 && codepoint <= 9811 || codepoint === 9855 || codepoint === 9875 || codepoint === 9889 || codepoint >= 9898 && codepoint <= 9899 || codepoint >= 9917 && codepoint <= 9918 || codepoint >= 9924 && codepoint <= 9925 || codepoint === 9934 || codepoint === 9940 || codepoint === 9962 || codepoint >= 9970 && codepoint <= 9971 || codepoint === 9973 || codepoint === 9978 || codepoint === 9981 || codepoint === 9989 || codepoint >= 9994 && codepoint <= 9995 || codepoint === 10024 || codepoint === 10060 || codepoint === 10062 || codepoint >= 10067 && codepoint <= 10069 || codepoint === 10071 || codepoint >= 10133 && codepoint <= 10135 || codepoint === 10160 || codepoint === 10175 || codepoint >= 10548 && codepoint <= 10549 || codepoint >= 11013 && codepoint <= 11015 || codepoint >= 11035 && codepoint <= 11036 || codepoint === 11088 || codepoint === 11093 || codepoint === 12336 || codepoint === 12349 || codepoint === 12951 || codepoint === 12953;
+}
+function codepointHasExplicitEmojiPresentation(text, index) {
+	const codepoint = text.codePointAt(index) ?? 0;
+	return (text.codePointAt(index + (codepoint > 65535 ? 2 : 1)) ?? 0) === 65039;
+}
+function collectEmojiBitmapFallbackCodepoints(buffer) {
+	const codepoints = /* @__PURE__ */ new Set();
+	try {
+		const files = unzipBrowserPptx(buffer);
+		const decoder = new TextDecoder();
+		const textRegex = /<a:t(?:\s[^>]*)?>([\s\S]*?)<\/a:t>/gu;
+		for (const [filename, bytes] of Object.entries(files)) {
+			if (!filename.endsWith(".xml")) continue;
+			if (!filename.startsWith("ppt/slides/") && !filename.startsWith("ppt/slideLayouts/") && !filename.startsWith("ppt/notesSlides/")) continue;
+			const xml = decoder.decode(bytes);
+			for (const match of xml.matchAll(textRegex)) {
+				const text = decodeXmlEntities(match[1] ?? "");
+				for (let i = 0; i < text.length; i += 1) {
+					const codepoint = text.codePointAt(i) ?? 0;
+					if (isDefaultEmojiPresentationCodepoint(codepoint) || codepointHasExplicitEmojiPresentation(text, i)) codepoints.add(codepoint);
+					if (codepoint > 65535) i += 1;
+				}
+			}
+		}
+	} catch (error) {
+		if (isResourcePolicyError(error)) throw error;
+		return [];
+	}
+	return [...codepoints].sort((a, b) => a - b);
+}
+function pptxHasUnicodeText(buffer) {
+	try {
+		const files = unzipBrowserPptx(buffer);
+		const decoder = new TextDecoder();
+		const textRegex = /<a:t(?:\s[^>]*)?>([\s\S]*?)<\/a:t>/gu;
+		for (const [filename, bytes] of Object.entries(files)) {
+			if (!filename.endsWith(".xml")) continue;
+			if (!filename.startsWith("ppt/slides/") && !filename.startsWith("ppt/slideLayouts/") && !filename.startsWith("ppt/notesSlides/")) continue;
+			const xml = decoder.decode(bytes);
+			for (const match of xml.matchAll(textRegex)) if (containsNonLatinCodepoint(decodeXmlEntities(match[1] ?? ""))) return true;
+		}
+	} catch (error) {
+		if (isResourcePolicyError(error)) throw error;
+		return false;
+	}
+	return false;
+}
+async function resolveUnicodeFallbackFont(options) {
+	const font = options?.unicodeFallbackFont;
+	if (!font) return null;
+	if (font.data) {
+		const data = font.data instanceof Uint8Array ? font.data : new Uint8Array(font.data);
+		if (data.byteLength === 0) return null;
+		return {
+			path: font.path ?? "unicode-fallback.ttf",
+			data
+		};
+	}
+	if (!font.url) return null;
+	const cacheKey = `${font.path ?? "unicode-fallback.ttf"}|${String(font.url)}`;
+	if (unicodeFallbackFontCacheKey !== cacheKey) {
+		unicodeFallbackFontCacheKey = cacheKey;
+		unicodeFallbackFontPromise = null;
+	}
+	unicodeFallbackFontPromise ??= (async () => {
+		try {
+			const response = await fetch(font.url);
+			if (!response.ok) return null;
+			return new Uint8Array(await response.arrayBuffer());
+		} catch {
+			return null;
+		}
+	})();
+	const data = await unicodeFallbackFontPromise;
+	if (!data || data.byteLength === 0) return null;
+	return {
+		path: font.path ?? "unicode-fallback.ttf",
+		data
+	};
+}
+async function resolveEmojiFallbackFont(options) {
+	const font = options?.emojiFallbackFont;
+	if (!font) return null;
+	if (font.data) {
+		const data = font.data instanceof Uint8Array ? font.data : new Uint8Array(font.data);
+		if (data.byteLength === 0) return null;
+		return {
+			path: font.path ?? "emoji-fallback.ttf",
+			data
+		};
+	}
+	if (!font.url) return null;
+	const cacheKey = `${font.path ?? "emoji-fallback.ttf"}|${String(font.url)}`;
+	if (emojiFallbackFontCacheKey !== cacheKey) {
+		emojiFallbackFontCacheKey = cacheKey;
+		emojiFallbackFontPromise = null;
+	}
+	emojiFallbackFontPromise ??= (async () => {
+		try {
+			const response = await fetch(font.url);
+			if (!response.ok) return null;
+			return new Uint8Array(await response.arrayBuffer());
+		} catch {
+			return null;
+		}
+	})();
+	const data = await emojiFallbackFontPromise;
+	if (!data || data.byteLength === 0) return null;
+	return {
+		path: font.path ?? "emoji-fallback.ttf",
+		data
+	};
+}
+async function instantiatePdfWasm(options) {
+	const wasmOpts = {
+		builtins: ["js-string"],
+		importedStringConstants: "_"
+	};
+	const imports = createPdfWasmImports();
+	const wasmBytes = options?.wasmBytes;
+	if (wasmBytes) {
+		const source = wasmBytes instanceof Uint8Array ? wasmBytes : new Uint8Array(wasmBytes);
+		return WebAssembly.instantiate(source, imports, wasmOpts);
+	}
+	const wasmUrl = options?.wasmUrl ?? defaultPdfWasmUrl();
+	const source = new Uint8Array(await fetchWasmBytes(wasmUrl, "pdf-converter"));
+	return WebAssembly.instantiate(source, imports, wasmOpts);
+}
+function defaultPdfWasmUrl() {
+	try {
+		return new URL("./mbt/pdf-converter.wasm", import.meta.url);
+	} catch {
+		return runtimeAssetUrl("./mbt/pdf-converter.wasm", import.meta.url);
+	}
+}
+async function loadPdfWasm(options) {
+	if (options?.wasmBytes) {
+		const exports = (await instantiatePdfWasm(options)).instance.exports;
+		exports._start();
+		assertPdfWasmApi(exports);
+		return exports;
+	}
+	const source = String(options?.wasmUrl ?? defaultPdfWasmUrl());
+	if (pdfWasmSource === source && pdfWasmInstance) return pdfWasmInstance;
+	if (pdfWasmLoadPromise) {
+		if (pdfWasmLoadSource === source) return pdfWasmLoadPromise;
+		try {
+			await pdfWasmLoadPromise;
+		} catch {}
+		return loadPdfWasm(options);
+	}
+	const pending = (async () => {
+		const exports = (await instantiatePdfWasm({
+			...options,
+			wasmUrl: source
+		})).instance.exports;
+		exports._start();
+		assertPdfWasmApi(exports);
+		return exports;
+	})();
+	pdfWasmLoadSource = source;
+	pdfWasmLoadPromise = pending;
+	try {
+		const exports = await pending;
+		if (pdfWasmLoadPromise === pending) {
+			pdfWasmSource = source;
+			pdfWasmInstance = exports;
+		}
+		return exports;
+	} finally {
+		if (pdfWasmLoadPromise === pending) {
+			pdfWasmLoadSource = null;
+			pdfWasmLoadPromise = null;
+		}
+	}
+}
+async function serializePdfWasmConversion(mod, convert) {
+	const current = (conversionTailsByInstance.get(mod) ?? Promise.resolve()).then(convert);
+	const tail = current.then(() => void 0, () => void 0);
+	conversionTailsByInstance.set(mod, tail);
+	try {
+		return await current;
+	} finally {
+		if (conversionTailsByInstance.get(mod) === tail) conversionTailsByInstance.delete(mod);
+	}
+}
+function createBufferedPdfBridge(mod) {
+	return {
+		supportsRegularFonts: typeof mod.clear_registered_regular_fonts === "function",
+		supportsEmojiBitmaps: typeof mod.clear_registered_emoji_bitmap_glyphs === "function",
+		supportsMathFallback: typeof mod.clear_math_fallback_fonts === "function",
+		clearRegularFonts: () => mod.clear_registered_regular_fonts?.(),
+		clearEmojiBitmaps: () => mod.clear_registered_emoji_bitmap_glyphs?.(),
+		clearMathFallback: () => mod.clear_math_fallback_fonts?.(),
+		registerRegularFont: (typeface, style, path, data) => {
+			const encodedTypeface = utf8Bytes(typeface);
+			const encodedStyle = utf8Bytes(style);
+			const encodedPath = utf8Bytes(path);
+			writePdfBridgeInput(mod, [
+				encodedTypeface,
+				encodedStyle,
+				encodedPath,
+				data
+			]);
+			if (mod.register_pdf_font_buffered(encodedTypeface.length, encodedStyle.length, encodedPath.length) !== 1) throw new Error("PDF converter WASM rejected a buffered regular font");
+		},
+		registerEmojiBitmap: (bitmap) => {
+			const mime = utf8Bytes(bitmap.mime);
+			writePdfBridgeInput(mod, [mime, bitmap.data]);
+			if (mod.register_pdf_emoji_bitmap_buffered(bitmap.codepoint, mime.length, bitmap.width, bitmap.height) !== 1) throw new Error("PDF converter WASM rejected a buffered emoji bitmap");
+		},
+		registerMathFallback: (family, data) => {
+			const encodedFamily = utf8Bytes(family);
+			writePdfBridgeInput(mod, [encodedFamily, data]);
+			if (mod.register_pdf_math_fallback_buffered(encodedFamily.length) !== 1) throw new Error("PDF converter WASM rejected a buffered math fallback font");
+		},
+		setOfficeFontFallbacks: (enabled) => mod.set_pdf_office_font_fallbacks(enabled ? 1 : 0),
+		convert: ({ buffer, fallbackFont, licensePayload, runtimePayload, watermarkPayload }) => {
+			const pptx = new Uint8Array(buffer);
+			const fallbackPath = utf8Bytes(fallbackFont?.path ?? "");
+			const fallbackData = fallbackFont?.data ?? /* @__PURE__ */ new Uint8Array();
+			const license = utf8Bytes(licensePayload);
+			const runtime = utf8Bytes(runtimePayload);
+			const watermarks = utf8Bytes(watermarkPayload);
+			writePdfBridgeInput(mod, [
+				pptx,
+				fallbackPath,
+				fallbackData,
+				license,
+				runtime,
+				watermarks
+			]);
+			const outputLength = mod.run_pdf_conversion_buffered(pptx.length, fallbackPath.length, fallbackData.length, license.length, runtime.length, watermarks.length);
+			if (!Number.isSafeInteger(outputLength) || outputLength < 0) throw new Error("PDF converter WASM rejected the buffered conversion request");
+			return readPdfBridgeOutput(mod, outputLength);
+		}
+	};
+}
+function createDirectPdfBridge(mod) {
+	const convertFromString = mod.convert_pptx_to_pdf_from_string;
+	if (!convertFromString) throw new Error("PDF converter WASM does not expose a supported host bridge");
+	return {
+		supportsRegularFonts: typeof mod.clear_registered_regular_fonts === "function" && (typeof mod.register_font_style_from_string === "function" || typeof mod.register_regular_font_from_string === "function"),
+		supportsEmojiBitmaps: typeof mod.clear_registered_emoji_bitmap_glyphs === "function" && typeof mod.register_emoji_bitmap_glyph_from_string === "function",
+		supportsMathFallback: typeof mod.clear_math_fallback_fonts === "function" && typeof mod.register_math_fallback_font_from_string === "function",
+		clearRegularFonts: () => mod.clear_registered_regular_fonts?.(),
+		clearEmojiBitmaps: () => mod.clear_registered_emoji_bitmap_glyphs?.(),
+		clearMathFallback: () => mod.clear_math_fallback_fonts?.(),
+		registerRegularFont: (typeface, style, path, data) => {
+			const latin1 = arrayBufferToLatin1(bytesToArrayBuffer(data));
+			if (mod.register_font_style_from_string) mod.register_font_style_from_string(typeface, style, path, latin1);
+			else if (style === "regular") mod.register_regular_font_from_string?.(typeface, path, latin1);
+		},
+		registerEmojiBitmap: (bitmap) => mod.register_emoji_bitmap_glyph_from_string?.(bitmap.codepoint, bitmap.mime, bitmap.width, bitmap.height, arrayBufferToLatin1(bytesToArrayBuffer(bitmap.data))),
+		registerMathFallback: (family, data) => mod.register_math_fallback_font_from_string?.(family, arrayBufferToLatin1(bytesToArrayBuffer(data))),
+		setOfficeFontFallbacks: (enabled) => mod.register_regular_font_from_string?.(officeFontFallbacksBridgeTypeface, enabled ? "true" : "false", "x"),
+		convert: ({ buffer, fallbackFont, licensePayload, runtimePayload, watermarkPayload }) => {
+			const pptxLatin1 = arrayBufferToLatin1(buffer);
+			if (fallbackFont?.data) {
+				const fallbackData = arrayBufferToLatin1(bytesToArrayBuffer(fallbackFont.data));
+				if (mod.convert_pptx_to_pdf_with_unicode_fallback_license_and_watermarks_from_string) return mod.convert_pptx_to_pdf_with_unicode_fallback_license_and_watermarks_from_string(pptxLatin1, fallbackFont.path, fallbackData, licensePayload, runtimePayload, watermarkPayload);
+				if (watermarkPayload && mod.convert_pptx_to_pdf_with_unicode_fallback_and_watermarks_from_string) return mod.convert_pptx_to_pdf_with_unicode_fallback_and_watermarks_from_string(pptxLatin1, fallbackFont.path, fallbackData, watermarkPayload);
+				if (mod.convert_pptx_to_pdf_with_unicode_fallback_from_string) return mod.convert_pptx_to_pdf_with_unicode_fallback_from_string(pptxLatin1, fallbackFont.path, fallbackData);
+				return convertFromString(pptxLatin1);
+			}
+			if (mod.convert_pptx_to_pdf_with_license_from_string) return mod.convert_pptx_to_pdf_with_license_from_string(pptxLatin1, licensePayload, runtimePayload, watermarkPayload);
+			if (watermarkPayload && mod.convert_pptx_to_pdf_with_watermarks_from_string) return mod.convert_pptx_to_pdf_with_watermarks_from_string(pptxLatin1, watermarkPayload);
+			return convertFromString(pptxLatin1);
+		}
+	};
+}
+function createPdfBridge(mod) {
+	return hasBufferedPdfBridge(mod) ? createBufferedPdfBridge(mod) : createDirectPdfBridge(mod);
+}
+function resetPdfBridgeState(bridge) {
+	bridge.clearRegularFonts();
+	bridge.clearEmojiBitmaps();
+	bridge.clearMathFallback();
+	bridge.setOfficeFontFallbacks(false);
+}
+async function registerRegularFonts(bridge, options) {
+	const fonts = [...options?.regularFonts ?? []];
+	const emojiFallback = await resolveEmojiFallbackFont(options);
+	if (emojiFallback) fonts.push({
+		typeface: PDF_EMOJI_FALLBACK_TYPEFACE,
+		path: emojiFallback.path,
+		data: emojiFallback.data
+	});
+	if (!fonts.length || !bridge.supportsRegularFonts) return;
+	for (const font of fonts) {
+		if (!font?.typeface || !font.data) continue;
+		const data = font.data instanceof Uint8Array ? font.data : new Uint8Array(font.data);
+		if (data.byteLength === 0) continue;
+		const style = font.style ?? "regular";
+		const path = font.path ?? `${font.typeface}-${style}.ttf`;
+		bridge.registerRegularFont(font.typeface, style, path, data);
+	}
+}
+function emojiBitmapFallbackEnabled(options) {
+	return options?.emojiBitmapFallback !== false;
+}
+function emojiBitmapFallbackFont(options) {
+	return (typeof options?.emojiBitmapFallback === "object" ? options.emojiBitmapFallback.fontFamily : "") || "\"Apple Color Emoji\", \"Segoe UI Emoji\", \"Noto Color Emoji\", \"Twemoji Mozilla\", sans-serif";
+}
+function emojiBitmapFallbackPixelSize(options) {
+	const configured = typeof options?.emojiBitmapFallback === "object" ? options.emojiBitmapFallback.pixelSize : 0;
+	return Number.isFinite(configured) && configured >= 64 && configured <= 256 ? configured : 128;
+}
+function emojiPresentationText(codepoint) {
+	const text = String.fromCodePoint(codepoint);
+	return codepoint >= 8960 && codepoint <= 10175 ? `${text}\ufe0f` : text;
+}
+function canvasToBlob(canvas) {
+	return new Promise((resolve) => canvas.toBlob(resolve, "image/png"));
+}
+function cropTransparentCanvas(source, padding) {
+	const ctx = source.getContext("2d");
+	if (!ctx) return source;
+	const { width, height } = source;
+	const data = ctx.getImageData(0, 0, width, height).data;
+	let minX = width;
+	let minY = height;
+	let maxX = -1;
+	let maxY = -1;
+	for (let y = 0; y < height; y += 1) for (let x = 0; x < width; x += 1) {
+		if (data[(y * width + x) * 4 + 3] === 0) continue;
+		if (x < minX) minX = x;
+		if (y < minY) minY = y;
+		if (x > maxX) maxX = x;
+		if (y > maxY) maxY = y;
+	}
+	if (maxX < minX || maxY < minY) return source;
+	minX = Math.max(0, minX - padding);
+	minY = Math.max(0, minY - padding);
+	maxX = Math.min(width - 1, maxX + padding);
+	maxY = Math.min(height - 1, maxY + padding);
+	const cropped = document.createElement("canvas");
+	cropped.width = maxX - minX + 1;
+	cropped.height = maxY - minY + 1;
+	cropped.getContext("2d")?.drawImage(source, minX, minY, cropped.width, cropped.height, 0, 0, cropped.width, cropped.height);
+	return cropped;
+}
+async function renderEmojiBitmapFallback(codepoint, options) {
+	if (typeof document === "undefined") return null;
+	const canvas = document.createElement("canvas");
+	const size = emojiBitmapFallbackPixelSize(options);
+	canvas.width = size;
+	canvas.height = size;
+	const ctx = canvas.getContext("2d");
+	if (!ctx) return null;
+	ctx.clearRect(0, 0, size, size);
+	ctx.font = `${Math.round(size * .78)}px ${emojiBitmapFallbackFont(options)}`;
+	ctx.textAlign = "center";
+	ctx.textBaseline = "middle";
+	ctx.fillText(emojiPresentationText(codepoint), size / 2, size / 2);
+	const cropped = cropTransparentCanvas(canvas, Math.max(2, Math.round(size * .03)));
+	const blob = await canvasToBlob(cropped);
+	if (!blob || blob.size === 0) return null;
+	return {
+		codepoint,
+		mime: "image/png",
+		width: cropped.width,
+		height: cropped.height,
+		data: new Uint8Array(await blob.arrayBuffer())
+	};
+}
+async function registerEmojiBitmapFallbacks(bridge, buffer, options, prepared) {
+	if (!emojiBitmapFallbackEnabled(options) || !bridge.supportsEmojiBitmaps || prepared === void 0 && typeof document === "undefined") return;
+	const bitmaps = [];
+	if (prepared) bitmaps.push(...prepared);
+	else {
+		const codepoints = collectEmojiBitmapFallbackCodepoints(buffer);
+		for (const codepoint of codepoints) {
+			const bitmap = await renderEmojiBitmapFallback(codepoint, options);
+			if (bitmap) bitmaps.push(bitmap);
+		}
+	}
+	if (bitmaps.length === 0) return;
+	for (const bitmap of bitmaps) bridge.registerEmojiBitmap(bitmap);
+}
+async function resolveMathFallbackBytes(options) {
+	const explicit = options?.mathFallbackFont;
+	if (explicit?.data) {
+		const data = explicit.data instanceof Uint8Array ? explicit.data : new Uint8Array(explicit.data);
+		if (data.byteLength > 0) return {
+			family: explicit.family ?? "math-fallback",
+			data
+		};
+	}
+	if (explicit?.url) try {
+		const response = await fetch(explicit.url);
+		if (response.ok) {
+			const data = new Uint8Array(await response.arrayBuffer());
+			if (data.byteLength > 0) return {
+				family: explicit.family ?? "math-fallback",
+				data
+			};
+		}
+	} catch {}
+	const shared = await resolveUnicodeFallbackFont(options);
+	if (shared) return {
+		family: shared.path,
+		data: shared.data
+	};
+	return null;
+}
+async function registerMathFallback(bridge, options) {
+	if (!bridge.supportsMathFallback) return;
+	const resolved = await resolveMathFallbackBytes(options);
+	if (resolved) bridge.registerMathFallback(resolved.family, resolved.data);
+}
+function watermarksJson(options) {
+	return options?.watermarks?.length ? JSON.stringify(options.watermarks) : "";
+}
+function licenseJson(options) {
+	if (options?.license === void 0 || options.license === null) return "";
+	return typeof options.license === "string" ? options.license : JSON.stringify(options.license);
+}
+function runtimeOrigin() {
+	return typeof location !== "undefined" ? location.origin : "";
+}
+function runtimeHostname() {
+	return typeof location !== "undefined" ? location.hostname : "";
+}
+function licenseRuntimeJson(options) {
+	return JSON.stringify({
+		feature: "pdf-export",
+		nowUnixMs: options?.licenseRuntime?.now ?? Date.now(),
+		origin: options?.licenseRuntime?.origin ?? runtimeOrigin(),
+		hostname: options?.licenseRuntime?.hostname ?? runtimeHostname(),
+		deploymentId: options?.licenseRuntime?.deploymentId ?? "",
+		sdkVersion: options?.licenseRuntime?.sdkVersion ?? "",
+		inputBytes: options?.licenseRuntime?.inputBytes,
+		restrictionPolicySnapshot: options?.licenseRuntime?.restrictionPolicySnapshot
+	});
+}
+/** @internal Worker entry; browser callers should use pptxToPdf(). */
+async function pptxToPdfOnCurrentThread(buffer, options, preparedEmojiBitmaps) {
+	options?.signal?.throwIfAborted();
+	const resourceStarted = performance.now();
+	checkBrowserInput(buffer.byteLength);
+	const mod = await loadPdfWasm(options);
+	options?.signal?.throwIfAborted();
+	return serializePdfWasmConversion(mod, () => convertPptxWithPdfWasm(mod, buffer, resourceStarted, options, preparedEmojiBitmaps));
+}
+async function convertPptxWithPdfWasm(mod, buffer, resourceStarted, options, preparedEmojiBitmaps) {
+	options?.signal?.throwIfAborted();
+	const bridge = createPdfBridge(mod);
+	let pdfResult;
+	try {
+		resetPdfBridgeState(bridge);
+		await registerRegularFonts(bridge, options);
+		options?.signal?.throwIfAborted();
+		await registerEmojiBitmapFallbacks(bridge, buffer, options, preparedEmojiBitmaps);
+		options?.signal?.throwIfAborted();
+		await registerMathFallback(bridge, options);
+		options?.signal?.throwIfAborted();
+		const fallbackFont = pptxHasUnicodeText(buffer) ? await resolveUnicodeFallbackFont(options) : null;
+		bridge.setOfficeFontFallbacks(options?.officeFontFallbacks === true);
+		options?.signal?.throwIfAborted();
+		pdfResult = bridge.convert({
+			buffer,
+			fallbackFont,
+			licensePayload: licenseJson(options),
+			runtimePayload: licenseRuntimeJson(options),
+			watermarkPayload: watermarksJson(options)
+		});
+	} finally {
+		resetPdfBridgeState(bridge);
+	}
+	const errorPrefix = typeof pdfResult === "string" ? pdfResult : uint8ArrayToLatin1(pdfResult.subarray(0, 15));
+	if (errorPrefix.startsWith("ERROR_RESOURCE:")) {
+		const rawDetails = (typeof pdfResult === "string" ? pdfResult : new TextDecoder().decode(pdfResult)).slice(15);
+		const violation = resourcePolicyErrorFromDetails(JSON.parse(rawDetails));
+		if (violation) throw violation;
+		throw new Error("PDF conversion returned an invalid Resource Policy failure");
+	}
+	if (errorPrefix.startsWith("ERROR:")) {
+		const errorResult = typeof pdfResult === "string" ? pdfResult : new TextDecoder().decode(pdfResult);
+		throw new Error(errorResult.slice(6) || "Unknown PDF conversion error");
+	}
+	const pdf = typeof pdfResult === "string" ? latin1ToUint8Array(pdfResult) : pdfResult;
+	checkBrowserOutput(pdf.byteLength, "PDF output");
+	checkBrowserElapsed(resourceStarted, "PDF conversion wall clock");
+	return pdf;
+}
+//#endregion
+//#region src/pdf-worker.ts
+const ctx = self;
+const waitingForEmoji = /* @__PURE__ */ new Map();
+const active = /* @__PURE__ */ new Map();
+async function handlePdfRequest(request, emojiBitmaps) {
+	const { id, buffer, options } = request;
+	const abort = active.get(id);
+	if (!abort) return;
+	try {
+		const bytes = await pptxToPdfOnCurrentThread(buffer, {
+			...options,
+			signal: abort.signal
+		}, emojiBitmaps);
+		if (abort.signal.aborted) return;
+		const data = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+		ctx.postMessage({
+			id,
+			status: "success",
+			data
+		}, [data]);
+	} catch (error) {
+		if (abort.signal.aborted) return;
+		ctx.postMessage({
+			id,
+			status: "error",
+			error: serializeWorkerError(error)
+		});
+	} finally {
+		active.delete(id);
+		if (abort.signal.aborted) ctx.postMessage({
+			id,
+			status: "error",
+			error: serializeWorkerError(abort.signal.reason)
+		});
+	}
+}
+ctx.onmessage = (event) => {
+	const request = event.data;
+	if (request.kind === "cancel") {
+		const abort = active.get(request.id);
+		abort?.abort();
+		active.delete(request.id);
+		if (waitingForEmoji.delete(request.id) && abort) ctx.postMessage({
+			id: request.id,
+			status: "error",
+			error: serializeWorkerError(abort.signal.reason)
+		});
+		return;
+	}
+	if (request.kind === "convert") {
+		active.set(request.id, new AbortController());
+		try {
+			const codepoints = request.options?.emojiBitmapFallback === false ? [] : collectEmojiBitmapFallbackCodepoints(request.buffer);
+			if (codepoints.length > 0) {
+				waitingForEmoji.set(request.id, request);
+				ctx.postMessage({
+					id: request.id,
+					status: "emoji-codepoints",
+					codepoints
+				});
+				return;
+			}
+			handlePdfRequest(request, []);
+		} catch (error) {
+			active.delete(request.id);
+			ctx.postMessage({
+				id: request.id,
+				status: "error",
+				error: serializeWorkerError(error)
+			});
+		}
+		return;
+	}
+	const pending = waitingForEmoji.get(request.id);
+	if (!pending) return;
+	waitingForEmoji.delete(request.id);
+	handlePdfRequest(pending, request.emojiBitmaps);
+};
+//#endregion