@s8fy/pptx-parser 1.0.0

package/dist/wasm-worker.js

@@ -0,0 +1,1137 @@
+//#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));
+}
+//#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;
+}
+function createWasmStringConstants() {
+	return new Proxy(Object.create(null), { get: (_target, prop) => typeof prop === "string" ? prop : void 0 });
+}
+//#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 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 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/wasm-worker.ts
+let instance = null;
+let instanceSource = null;
+async function ensureWasm(wasmUrl) {
+	const sourceUrl = wasmUrl ?? new URL("./mbt/main.wasm", import.meta.url);
+	const source = String(sourceUrl);
+	if (instance && instanceSource === source) return instance;
+	const wasmBytes = await fetchWasmBytes(sourceUrl, "wasm-worker");
+	const { instance: inst } = await WebAssembly.instantiate(new Uint8Array(wasmBytes), { _: createWasmStringConstants() }, {
+		builtins: ["js-string"],
+		importedStringConstants: "_"
+	});
+	instance = inst.exports;
+	instanceSource = source;
+	instance._start();
+	return instance;
+}
+async function parseWithWasmUnzip(mod, buffer) {
+	const t0 = performance.now();
+	checkBrowserInput(buffer.byteLength);
+	const latin1 = arrayBufferToLatin1(buffer);
+	const t1 = performance.now();
+	const fileCount = mod.decompress(latin1);
+	const t2 = performance.now();
+	mod.parse_only();
+	const t3 = performance.now();
+	const jsonStr = mod.serialize_result();
+	const t4 = performance.now();
+	const result = JSON.parse(jsonStr);
+	const t5 = performance.now();
+	const violation = resourcePolicyErrorFromDetails(result.resourceViolation);
+	if (violation) throw violation;
+	checkBrowserElapsed(t0, "[wasm-parser] Worker parse");
+	return {
+		result,
+		timing: {
+			latin1: t1 - t0,
+			decompress: t2 - t1,
+			fileCount,
+			parse: t3 - t2,
+			serialize: t4 - t3,
+			jsonParse: t5 - t4,
+			total: t5 - t0
+		}
+	};
+}
+async function parseWithJsUnzip(mod, buffer) {
+	const t0 = performance.now();
+	checkBrowserInput(buffer.byteLength);
+	const files = unzipBrowserPptx(buffer);
+	const t1 = performance.now();
+	let fileCount = 0;
+	for (const [filename, data] of Object.entries(files)) {
+		mod.add_predecompressed_file(filename, uint8ArrayToLatin1(data));
+		fileCount++;
+	}
+	const t2 = performance.now();
+	const jsonStr = mod.parse_from_predecompressed();
+	const t3 = performance.now();
+	const result = JSON.parse(jsonStr);
+	const t4 = performance.now();
+	const violation = resourcePolicyErrorFromDetails(result.resourceViolation);
+	if (violation) throw violation;
+	checkBrowserElapsed(t0, "[wasm-parser] Worker parse");
+	return {
+		result,
+		timing: {
+			latin1: 0,
+			decompress: t1 - t0,
+			fileCount,
+			parse: t3 - t2,
+			serialize: t2 - t1,
+			jsonParse: t4 - t3,
+			total: t4 - t0
+		}
+	};
+}
+const active = /* @__PURE__ */ new Set();
+self.onmessage = async (e) => {
+	if ("kind" in e.data && e.data.kind === "cancel") {
+		active.delete(e.data.id);
+		return;
+	}
+	const id = e.data instanceof ArrayBuffer ? 0 : e.data.id ?? 0;
+	active.add(id);
+	try {
+		const { buffer, unzipMode, wasmUrl } = e.data instanceof ArrayBuffer ? {
+			buffer: e.data,
+			unzipMode: "wasm"
+		} : e.data;
+		const mod = await ensureWasm(wasmUrl);
+		if (!active.has(id)) return;
+		const { result, timing } = unzipMode === "js" ? await parseWithJsUnzip(mod, buffer) : await parseWithWasmUnzip(mod, buffer);
+		if (!active.has(id)) return;
+		if (result.error) {
+			self.postMessage({
+				id,
+				status: "error",
+				error: serializeWorkerError(/* @__PURE__ */ new Error(`WASM parser error: ${result.error}`))
+			});
+			return;
+		}
+		self.postMessage({
+			id,
+			status: "ok",
+			data: result,
+			timing
+		});
+	} catch (err) {
+		if (!active.has(id)) return;
+		self.postMessage({
+			id,
+			status: "error",
+			error: serializeWorkerError(err)
+		});
+	} finally {
+		if (!active.delete(id)) self.postMessage({
+			id,
+			status: "error",
+			error: serializeWorkerError(new DOMException("The operation was aborted.", "AbortError"))
+		});
+	}
+};
+//#endregion