@songtonyli/dsh-cli 0.1.12 → 0.1.14

package/node_modules/@deepseek-ai/libreoffice-kit/lib/worker.js

@@ -0,0 +1,800 @@
+import { createRequire } from "node:module";
+import { parentPort, workerData } from "node:worker_threads";
+import { closeSync, constants, fstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, join } from "node:path";
+import { strFromU8, unzipSync } from "fflate";
+import { SaxesParser } from "saxes";
+import { create } from "fontkit";
+//#region lib/types/errors.js
+/** Stable render failure categories shared across the Node worker and native helper transports. */
+const CODES = /* @__PURE__ */ new Set([
+	"input-too-large",
+	"output-too-large",
+	"invalid-document",
+	"unsupported-format",
+	"invalid-output",
+	"timeout",
+	"unavailable",
+	"failed"
+]);
+/** An actionable converter failure; operating-system errors and caller abort reasons remain unchanged. */
+var ConversionError = class extends Error {
+	/** Published failure category carried across worker and helper transports. */
+	code;
+	/**
+	* @param code - Published failure category.
+	* @param message - Consumer-facing failure description.
+	* @param options - Standard error options; a cause is preserved for diagnostics.
+	*/
+	constructor(code, message, options) {
+		super(message, options);
+		this.name = "ConversionError";
+		this.code = code;
+	}
+};
+/**
+* Only published categories cross worker/helper messages; unknown errors use the generic failure category.
+* @param error - The thrown value, which may be any type and may carry an unpublished `code`.
+* @returns The published category, or `failed` when no published category is present.
+*/
+function failureCode(error) {
+	const code = error?.code;
+	return typeof code === "string" && CODES.has(code) ? code : "failed";
+}
+//#endregion
+//#region lib/types/fonts.js
+/** Host font metadata snapshots and conversion-local glyph matching over original files. */
+const FONT_EXTENSIONS = /* @__PURE__ */ new Set([
+	".ttf",
+	".otf",
+	".ttc",
+	".otc",
+	".dfont"
+]);
+const VCL_WEIGHTS = [
+	400,
+	100,
+	200,
+	300,
+	350,
+	400,
+	500,
+	600,
+	700,
+	800,
+	900
+];
+const GENERIC_FAMILIES = /* @__PURE__ */ new Set([
+	"serif",
+	"sansserif",
+	"monospace",
+	"cursive",
+	"fantasy",
+	"systemui",
+	"symbol"
+]);
+/** File identity read from the descriptor, before and after, to detect concurrent replacement. */
+const STAT_KEYS = [
+	"dev",
+	"ino",
+	"size",
+	"mtimeMs",
+	"ctimeMs"
+];
+/**
+* @param error - Thrown filesystem value.
+* @returns whether it means the path is not a usable font source.
+*/
+function absent(error) {
+	return error instanceof Error && "code" in error && [
+		"ENOENT",
+		"EACCES",
+		"EPERM",
+		"ENOTDIR"
+	].includes(String(error.code));
+}
+/**
+* Case- and separator-insensitive family key used to compare names across sources.
+* @param value - Family, style, or postscript name as recorded by a document or font.
+* @returns The normalized key.
+*/
+function normalize(value) {
+	return value.normalize("NFKC").toLowerCase().replaceAll(/[\s_-]/g, "");
+}
+/**
+* Order named substitutions and their generic text family without excluding unlisted fonts.
+* @param requested - Original family names, in document order.
+* @param groups - Ordered family groups shared with Fontconfig aliases.
+* @param pitch - VCL pitch; one requests a monospaced fallback.
+* @param symbols - Whether symbol alternatives precede the generic fallback.
+* @returns distinct family names, with original requests first.
+*/
+function fontFamilyPriority(requested, groups, pitch = 0, symbols = false) {
+	const original = requested.map(normalize);
+	const matched = groups.filter((group) => group.some((family) => original.includes(normalize(family))));
+	const generic = original.includes("monospace") || pitch === 1 ? "monospace" : original.includes("serif") ? "serif" : matched.flat().map(normalize).find((family) => family === "serif" || family === "sansserif" || family === "monospace") ?? "sansserif";
+	const families = [...requested, ...matched.flat()];
+	for (const kind of symbols ? ["symbol", generic] : [generic]) for (const group of groups) if (group.some((family) => normalize(family) === kind)) families.push(...group);
+	const priority = /* @__PURE__ */ new Map();
+	for (const family of families) {
+		const name = normalize(family);
+		if (!priority.has(name)) priority.set(name, family);
+	}
+	return [...priority.values()];
+}
+function fontPaths(directories, maxFiles) {
+	const pending = [...directories].reverse();
+	const visited = /* @__PURE__ */ new Set();
+	const paths = [];
+	for (let path = pending.pop(); path !== void 0; path = pending.pop()) {
+		let canonical;
+		let status;
+		try {
+			canonical = realpathSync(path);
+			status = statSync(canonical);
+		} catch (error) {
+			if (absent(error)) continue;
+			throw error;
+		}
+		if (visited.has(canonical)) continue;
+		visited.add(canonical);
+		if (status.isDirectory()) {
+			let names;
+			try {
+				names = readdirSync(canonical);
+			} catch (error) {
+				if (absent(error)) continue;
+				throw error;
+			}
+			pending.push(...names.sort().reverse().map((name) => join(canonical, name)));
+		} else if (status.isFile() && FONT_EXTENSIONS.has(extname(canonical).toLowerCase())) {
+			if (paths.length >= maxFiles) throw new Error("The system font catalog exceeds maxFontFiles.");
+			paths.push(canonical);
+		}
+	}
+	return paths;
+}
+function ranges(font) {
+	const points = font.characterSet.filter((point) => font.hasGlyphForCodePoint(point)).sort((left, right) => left - right);
+	const result = [];
+	for (const point of points) {
+		const last = result.at(-1);
+		if (last !== void 0 && point <= last[1] + 1) last[1] = Math.max(last[1], point);
+		else result.push([point, point]);
+	}
+	return result;
+}
+/**
+* Decode glyph coverage for one parsed face.
+* @param font - The parsed physical face.
+* @returns the inclusive ranges the face renders, or none when its glyph tables reject decoding.
+*/
+function faceCoverage(font) {
+	try {
+		return ranges(font);
+	} catch {
+		return [];
+	}
+}
+/**
+* @param parsed - Parsed font file: one face, or a collection of faces.
+* @param face - Indexed metadata naming the face inside that file.
+* @returns the physical face the index names.
+* @throws when the file no longer provides the indexed face.
+*/
+function indexedFace(parsed, face) {
+	const font = "fonts" in parsed ? parsed.fonts[face.faceIndex] : parsed;
+	if (font === void 0 || font.postscriptName !== face.postscriptName) throw new Error("The indexed font face is no longer available; recreate the converter.");
+	return font;
+}
+function covers(face, points) {
+	if (points.length === 0) return [];
+	if (face.coverage === void 0) face.coverage = faceCoverage(indexedFace(create(readFont(face)), face));
+	const coverage = face.coverage;
+	return points.filter((point) => coverage.some(([first, last]) => point >= first && point <= last));
+}
+/**
+* VCL weight, width, and fixed-pitch values for one parsed face.
+* @param font - The parsed physical face, whose `OS/2` and `post` tables may be absent.
+* @returns the recorded classes, or the regular defaults for an absent table.
+*/
+function faceMetrics(font) {
+	const os2 = font["OS/2"];
+	return {
+		weight: os2 === void 0 ? 400 : os2.usWeightClass,
+		width: os2 === void 0 ? 5 : os2.usWidthClass,
+		fixed: Boolean(font.post?.isFixedPitch)
+	};
+}
+function inspect(path, maxBytes) {
+	let status;
+	let bytes;
+	try {
+		const fd = openSync(path, constants.O_RDONLY | constants.O_NONBLOCK | constants.O_NOFOLLOW);
+		try {
+			status = fstatSync(fd);
+			if (!status.isFile() || status.size > maxBytes) return [];
+			bytes = Buffer.alloc(status.size);
+			let offset = 0;
+			while (offset < bytes.length) {
+				const count = readSync(fd, bytes, offset, bytes.length - offset, offset);
+				if (count === 0) throw new Error("A system font was truncated while indexing; reload the font service.");
+				offset += count;
+			}
+			const after = fstatSync(fd);
+			if (after.size !== status.size || after.mtimeMs !== status.mtimeMs || after.ctimeMs !== status.ctimeMs) throw new Error("A system font changed while indexing; reload the font service.");
+		} finally {
+			closeSync(fd);
+		}
+	} catch (error) {
+		if (absent(error)) return [];
+		throw error;
+	}
+	let faces;
+	try {
+		const parsed = create(bytes);
+		faces = ("fonts" in parsed ? parsed.fonts : [parsed]).map((font, faceIndex) => {
+			const names = [
+				"fontFamily",
+				"preferredFamily",
+				"fullName",
+				"postscriptName"
+			].flatMap((key) => Object.values(font.name?.records[key] ?? {})).filter((name) => typeof name === "string");
+			const aliases = [...new Set([
+				...names,
+				font.familyName,
+				font.fullName,
+				font.postscriptName
+			].filter((name) => Boolean(name)).map(normalize))];
+			return {
+				path,
+				size: status.size,
+				mtimeMs: status.mtimeMs,
+				ctimeMs: status.ctimeMs,
+				dev: status.dev,
+				ino: status.ino,
+				faceIndex,
+				family: font.familyName,
+				style: font.subfamilyName,
+				aliases,
+				...faceMetrics(font),
+				italic: font.italicAngle !== 0,
+				postscriptName: font.postscriptName
+			};
+		});
+	} catch {
+		return [];
+	}
+	return faces;
+}
+function regionalPriority(face, language) {
+	const locale = language.toLowerCase();
+	const preferred = locale.startsWith("ja") ? ["jp"] : locale.startsWith("ko") ? ["kr"] : locale.startsWith("zh") ? /hant|tw|hk|mo/.test(locale) ? ["tc", "hk"] : ["sc"] : [];
+	if (preferred.length === 0) return 0;
+	const region = `${face.family} ${face.postscriptName} ${basename(face.path)}`.toLowerCase().match(/(?:cjk|[\s_-])(sc|tc|jp|kr|hk)(?=[\s_.-]|$)/)?.[1];
+	return region === void 0 ? 1 : preferred.includes(region) ? 0 : 2;
+}
+/**
+* Snapshot eligible local font metadata without retaining font bytes or decoding glyph coverage.
+* @param options - Host font roots and physical file limits.
+* @returns metadata reused for the converter lifetime; recreate it after changing installed fonts.
+*/
+function indexSystemFonts(options) {
+	return fontPaths(options.directories, options.maxFiles).flatMap((path) => inspect(path, options.maxFileBytes));
+}
+/** Conversion-local glyph coverage over the converter's first metadata snapshot. */
+var SystemFontCatalog = class {
+	options;
+	faces;
+	/**
+	* @param options - Host metadata snapshot and fallback families.
+	*/
+	constructor(options) {
+		this.options = options;
+		this.faces = options.faces.map((face) => ({ ...face }));
+	}
+	/**
+	* Find installed faces covering the requested family or missing characters.
+	* Exact families precede configured alternatives, symbol families for missing symbols,
+	* generic families, then other glyph-covering faces.
+	* @param request - VCL family/style attributes and Unicode scalars missing from its current font.
+	* @param signal - cancellation checked between synchronous font reads.
+	* @returns selected physical files, deduplicated across collection faces; absent glyphs remain unresolved.
+	* @throws if an indexed font changes or cannot be read during glyph matching.
+	*/
+	match(request, signal) {
+		signal.throwIfAborted();
+		const requested = request.family.split(";").map((family) => family.trim()).filter(Boolean);
+		const primary = requested[0];
+		let missingFamily;
+		if (primary !== void 0 && !GENERIC_FAMILIES.has(normalize(primary)) && !this.faces.some((face) => face.aliases.includes(normalize(primary)))) missingFamily = primary;
+		const priority = fontFamilyPriority(requested, this.options.fallbackFamilies, request.pitch, request.codePoints.some((point) => /\p{Symbol}/u.test(String.fromCodePoint(point)))).map(normalize);
+		const missing = new Set(request.codePoints);
+		const ranked = this.faces.map((face) => {
+			const rank = priority.findIndex((family) => face.aliases.includes(family));
+			const region = regionalPriority(face, request.language);
+			const style = (request.style && normalize(request.style) === normalize(face.style) ? -1 : 0) + (request.italic === 3 || request.italic !== 0 === face.italic ? 0 : 100) + (request.pitch === 0 || request.pitch === 1 === face.fixed ? 0 : 50) + Math.abs((VCL_WEIGHTS[request.weight] ?? 400) - face.weight) / 100 + (request.width === 0 ? 0 : Math.abs(request.width - face.width));
+			return {
+				face,
+				rank: rank < 0 ? priority.length : rank,
+				region,
+				style
+			};
+		}).sort((left, right) => left.rank - right.rank || left.region - right.region || left.style - right.style || left.face.path.localeCompare(right.face.path, "en") || left.face.faceIndex - right.face.faceIndex);
+		const selected = [];
+		const files = /* @__PURE__ */ new Set();
+		for (const { face } of ranked) {
+			signal.throwIfAborted();
+			const covered = covers(face, [...missing]);
+			if (missing.size > 0 && covered.length === 0) continue;
+			if (!files.has(face.path)) {
+				selected.push(face);
+				files.add(face.path);
+			}
+			for (const point of covered) missing.delete(point);
+			if (missing.size === 0) break;
+		}
+		return {
+			fonts: selected,
+			...missingFamily === void 0 ? {} : { missingFamily }
+		};
+	}
+};
+/**
+* Read the unchanged indexed regular file; reject concurrent replacement or truncation.
+* @param face - Indexed face metadata whose identity and timestamps must still match the file.
+* @returns the complete original font bytes.
+* @throws when the file changed, was replaced, or was truncated since indexing.
+*/
+function readFont(face) {
+	const fd = openSync(face.path, constants.O_RDONLY | constants.O_NONBLOCK | constants.O_NOFOLLOW);
+	try {
+		const before = fstatSync(fd);
+		if (!before.isFile() || STAT_KEYS.some((key) => before[key] !== face[key])) throw new Error("An indexed font changed; recreate the converter.");
+		const bytes = Buffer.alloc(face.size);
+		for (let offset = 0; offset < bytes.length;) {
+			const count = readSync(fd, bytes, offset, bytes.length - offset, offset);
+			if (!count) throw new Error("An indexed font was truncated.");
+			offset += count;
+		}
+		const after = fstatSync(fd);
+		if (STAT_KEYS.some((key) => after[key] !== face[key])) throw new Error("An indexed font changed while reading.");
+		return bytes;
+	} finally {
+		closeSync(fd);
+	}
+}
+//#endregion
+//#region lib/types/ooxml.js
+/** Bounded OOXML inspection and declared font diagnostics, using maintained ZIP/XML parsers. */
+const MAIN_PARTS = {
+	docx: ["word/document.xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"],
+	xlsx: ["xl/workbook.xml", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"],
+	pptx: ["ppt/presentation.xml", "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml"]
+};
+/**
+* @param character - One code point as yielded by iteration over a string.
+* @returns the Unicode scalar the character encodes; iteration never yields an empty string.
+*/
+function codePointOf(character) {
+	return character.codePointAt(0);
+}
+/**
+* Validate ZIP size and membership before decoding selected document XML.
+* @param bytes - Complete source document bytes.
+* @param extension - Input extension, which selects the main document part.
+* @param limits - Archive entry and declared uncompressed byte limits.
+* @returns declared font families and the scalar values readable document XML declares.
+* @throws ConversionError when the extension is unsupported or the archive violates its limits.
+*/
+function inspectDocument$1(bytes, extension, limits) {
+	const main = MAIN_PARTS[extension];
+	if (!main) throw new ConversionError("unsupported-format", "Input extension must be docx, xlsx, or pptx.");
+	const names = /* @__PURE__ */ new Set();
+	let total = 0;
+	let files;
+	try {
+		files = unzipSync(bytes, { filter(entry) {
+			total += entry.originalSize;
+			if (names.has(entry.name) || names.size >= limits.maxArchiveEntries || !Number.isSafeInteger(total) || total > limits.maxUncompressedBytes) throw new Error("OOXML archive exceeds its limits or repeats an entry.");
+			names.add(entry.name);
+			return entry.name === "[Content_Types].xml" || /^(word|xl|ppt)\/.*\.xml$/.test(entry.name) && !entry.name.endsWith("/fontTable.xml") && !entry.name.includes("/theme/");
+		} });
+	} catch (cause) {
+		throw new ConversionError("invalid-document", "Input is not a supported, bounded OOXML archive.", { cause });
+	}
+	const contentTypes = files["[Content_Types].xml"];
+	if (!names.has("_rels/.rels") || !names.has(main[0]) || contentTypes === void 0 || !strFromU8(contentTypes).includes(main[1])) throw new ConversionError("invalid-document", `Input does not contain a ${extension} document.`);
+	const families = /* @__PURE__ */ new Map();
+	const codePoints = /* @__PURE__ */ new Set();
+	for (const [name, data] of Object.entries(files)) {
+		if (name === "[Content_Types].xml") continue;
+		const partFamilies = [];
+		const partPoints = /* @__PURE__ */ new Set();
+		const parser = new SaxesParser({ xmlns: true });
+		parser.on("opentag", (tag) => {
+			const word = /wordprocessingml\/(?:2006\/)?main$/.test(tag.uri) && tag.local === "rFonts";
+			const drawing = /drawingml\/(?:2006\/)?main$/.test(tag.uri);
+			const sheet = /spreadsheetml\/(?:2006\/)?main$/.test(tag.uri) && tag.local === "name";
+			for (const attribute of Object.values(tag.attributes)) if (word && [
+				"ascii",
+				"hAnsi",
+				"eastAsia",
+				"cs"
+			].includes(attribute.local) || drawing && attribute.local === "typeface" || sheet && attribute.local === "val") partFamilies.push(attribute.value);
+		});
+		parser.on("text", (text) => {
+			for (const char of text) if (!/\s/u.test(char)) partPoints.add(codePointOf(char));
+		});
+		const encoding = data[0] === 255 && data[1] === 254 ? "utf-16le" : data[0] === 254 && data[1] === 255 ? "utf-16be" : "utf-8";
+		try {
+			parser.write(new TextDecoder(encoding).decode(data)).close();
+		} catch {
+			continue;
+		}
+		for (const declared of partFamilies) for (const family of declared.split(";").map((value) => value.trim()).filter((value) => value && !/^\+(?:mj|mn)-(?:lt|ea|cs)$/.test(value))) families.set(normalize(family), family);
+		for (const point of partPoints) codePoints.add(point);
+	}
+	return {
+		families,
+		codePoints: [...codePoints]
+	};
+}
+//#endregion
+//#region lib/types/document.js
+/** Select bounded OOXML inspection or a legacy Office compound-file import. */
+/** Input suffixes accepted by the public converter. */
+const DOCUMENT_EXTENSIONS = [
+	"doc",
+	"docx",
+	"xls",
+	"xlsx",
+	"ppt",
+	"pptx"
+];
+const COMPOUND_SIGNATURE = [
+	208,
+	207,
+	17,
+	224,
+	161,
+	177,
+	26,
+	225
+];
+/**
+* Inspect the input container before invoking LibreOffice's document importer.
+* Compound-file streams and legacy font tables are interpreted by LibreOffice;
+* they do not supply the API's OOXML font diagnostics.
+* @param bytes - Source bytes already bounded by maxInputBytes.
+* @param extension - Lowercase source suffix.
+* @param limits - Limits applied to ZIP-based document contents.
+* @returns OOXML font metadata, or empty diagnostics for a binary document.
+*/
+function inspectDocument(bytes, extension, limits) {
+	if (!DOCUMENT_EXTENSIONS.includes(extension)) throw new ConversionError("unsupported-format", `Input extension must be ${DOCUMENT_EXTENSIONS.join(", ")}.`);
+	if ([
+		"docx",
+		"xlsx",
+		"pptx"
+	].includes(extension)) return inspectDocument$1(bytes, extension, limits);
+	if (bytes.length < 512 || !COMPOUND_SIGNATURE.every((value, index) => bytes[index] === value)) throw new ConversionError("invalid-document", "Legacy Office input must contain an OLE compound document.");
+	const header = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const version = header.getUint16(26, true);
+	const sectorShift = header.getUint16(30, true);
+	if (header.getUint16(28, true) !== 65534 || header.getUint16(32, true) !== 6 || !(version === 3 && sectorShift === 9 || version === 4 && sectorShift === 12) || bytes.length < 2 ** sectorShift * 2 || bytes.length % 2 ** sectorShift !== 0) throw new ConversionError("invalid-document", "Legacy Office input has an invalid or truncated compound-file header.");
+	return {
+		families: /* @__PURE__ */ new Map(),
+		codePoints: []
+	};
+}
+//#endregion
+//#region lib/types/font-loader.js
+/** Conversion-local font imports and exact-family diagnostics. */
+/** Build the metadata catalog inside a cancellable conversion worker. */
+function createFontLoader(options, document, install, faces) {
+	const catalog = new SystemFontCatalog({
+		faces,
+		fallbackFamilies: options.fontFallbacks
+	});
+	const loaded = /* @__PURE__ */ new Map();
+	const resolved = /* @__PURE__ */ new Map();
+	const missing = /* @__PURE__ */ new Map();
+	const substitutions = /* @__PURE__ */ new Map();
+	const signal = new AbortController().signal;
+	let bytes = 0;
+	return {
+		get missingFonts() {
+			return [...missing.values()];
+		},
+		get substitutions() {
+			return [...substitutions.values()];
+		},
+		get files() {
+			return [...loaded.values()];
+		},
+		resolve(request) {
+			const key = JSON.stringify(request);
+			const cached = resolved.get(key);
+			if (cached) return cached;
+			const match = catalog.match(request, signal);
+			if (match.missingFamily && document.families.has(normalize(match.missingFamily))) {
+				const family = normalize(match.missingFamily);
+				missing.set(family, match.missingFamily);
+				if (match.fonts[0]) substitutions.set(family, {
+					family: match.missingFamily,
+					substitute: match.fonts[0].family
+				});
+			}
+			const paths = match.fonts.map((face) => {
+				const installed = loaded.get(face.path);
+				if (installed !== void 0) return installed;
+				if (bytes + face.size > options.maxLoadedFontBytes) throw new Error("Imported fonts exceed maxLoadedFontBytes.");
+				const path = install(`${loaded.size}${extname(face.path)}`, readFont(face));
+				bytes += face.size;
+				loaded.set(face.path, path);
+				return path;
+			});
+			resolved.set(key, paths);
+			return paths;
+		}
+	};
+}
+/** Supply native imports and seed WASM's first usable default font. */
+function preloadFonts(loader, options, document, native = false) {
+	const families = [
+		...options.initialFontFamilies,
+		...native ? [...document.families.values()] : [],
+		"sans-serif"
+	];
+	for (const family of families) loader.resolve({
+		family,
+		style: "",
+		weight: 5,
+		italic: 0,
+		width: 5,
+		pitch: 0,
+		language: "",
+		codePoints: native ? document.codePoints : []
+	});
+}
+/**
+* Fontconfig XML restricts WASM discovery to imported originals in MEMFS.
+* @param families - Ordered family groups; the first name of each group is its canonical spelling.
+* @param requested - Additional family names the document declared.
+* @returns the fontconfig document written into the module's memory filesystem.
+*/
+function memoryFontConfig(families, requested = []) {
+	const escape = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+	return `<?xml version="1.0"?><!DOCTYPE fontconfig SYSTEM "fonts.dtd"><fontconfig><dir>/dsh-fonts</dir><cachedir>/dsh/font-cache</cachedir>${[...new Map([...families.flatMap((group) => group.slice(0, 1)), ...requested].map((name) => [normalize(name), name])).values()].map((name) => {
+		const alternatives = fontFamilyPriority([name], families).filter((family) => normalize(family) !== normalize(name));
+		return `<alias><family>${escape(name)}</family><accept>${alternatives.map((family) => `<family>${escape(family)}</family>`).join("")}</accept></alias>`;
+	}).join("")}</fontconfig>`;
+}
+//#endregion
+//#region lib/types/wasm.js
+/** Node-only LibreOffice module execution; the owner terminates this worker on cancellation. */
+const require = createRequire(import.meta.url);
+function engineError(module, office) {
+	const pointer = module.ccall("dsh_lok_error", "number", ["number"], [office]);
+	if (!pointer) return /* @__PURE__ */ new Error("LibreOffice WASM could not convert the document.");
+	try {
+		return new Error(module.UTF8ToString(pointer));
+	} finally {
+		module.ccall("free", null, ["number"], [pointer]);
+	}
+}
+/**
+* @param loader - Loader the module's pre-run hook installs.
+* @returns the initialized font loader.
+* @throws when the module resolved without running its pre-run hook.
+*/
+function requiredFontLoader(loader) {
+	if (loader === void 0) throw new Error("LibreOffice initialized without its font loader.");
+	return loader;
+}
+/**
+* Convert bounded source bytes; return owned PDF bytes only after engine teardown.
+* @param request - Engine installation, source bytes, limits, and font metadata.
+* @returns the generated PDF bytes and the declared families the catalog could not provide.
+*/
+async function convertWithWasm(request) {
+	const { engine, bytes, extension, options, document: metadata, faces } = request;
+	const factory = require(engine.loader);
+	const raw = readFileSync(engine.data);
+	const data = raw.buffer.slice(raw.byteOffset, raw.byteOffset + raw.byteLength);
+	let module;
+	let office = 0;
+	let document = 0;
+	let fontLoader;
+	let fatal = false;
+	let failure;
+	try {
+		module = await factory({
+			noInitialRun: true,
+			mainScriptUrlOrBlob: engine.loader,
+			locateFile(name) {
+				const file = basename(name);
+				if (![
+					engine.loader,
+					engine.data,
+					engine.wasm,
+					engine.metadata
+				].some((path) => basename(path) === file)) throw new Error(`LibreOffice requested an unlisted asset: ${file}`);
+				return join(dirname(engine.loader), file);
+			},
+			getPreloadedPackage: () => data,
+			dshResolveSystemFonts(request) {
+				if (!fontLoader) throw new Error("LibreOffice requested fonts before initializing MEMFS.");
+				return fontLoader.resolve(request);
+			},
+			preRun: [(loadedModule) => {
+				for (const path of [
+					"/dsh/profile",
+					"/dsh/font-cache",
+					"/dsh-fonts"
+				]) loadedModule.FS.mkdirTree(path);
+				loadedModule.FS.writeFile("/dsh/fonts.conf", new TextEncoder().encode(memoryFontConfig(options.fontFallbacks, metadata.families.values())));
+				Object.assign(loadedModule.ENV, {
+					HOME: "/dsh/profile",
+					TMPDIR: "/tmp",
+					FONTCONFIG_FILE: "/dsh/fonts.conf",
+					LOK_HOST_ALLOWLIST: "^$"
+				});
+				fontLoader = createFontLoader(options, metadata, (name, bytes) => {
+					const path = `/dsh-fonts/${name}`;
+					loadedModule.FS.writeFile(path, bytes);
+					return path;
+				}, faces);
+				preloadFonts(fontLoader, options, metadata);
+			}],
+			onAbort() {
+				fatal = true;
+			},
+			print() {},
+			printErr() {}
+		});
+		const instance = module;
+		const input = `/dsh/document.${extension}`;
+		const output = "/dsh/document.pdf";
+		instance.FS.writeFile(input, bytes);
+		office = instance.ccall("dsh_lok_initialize", "number", ["string", "string"], [engine.programDirectory, "file:///dsh/profile"]);
+		if (!office) throw engineError(instance, 0);
+		document = instance.ccall("dsh_lok_document_load", "number", [
+			"number",
+			"string",
+			"string"
+		], [
+			office,
+			`file://${input}`,
+			"Batch=true,EnableMacrosExecution=false"
+		]);
+		if (!document) throw engineError(instance, office);
+		if (!instance.ccall("dsh_lok_document_save_pdf", "number", [
+			"number",
+			"string",
+			"string"
+		], [
+			document,
+			`file://${output}`,
+			JSON.stringify({
+				ExportBookmarks: {
+					type: "boolean",
+					value: "true"
+				},
+				ReduceImageResolution: {
+					type: "boolean",
+					value: "true"
+				},
+				MaxImageResolution: {
+					type: "long",
+					value: String(options.maxImageResolution)
+				}
+			})
+		])) throw engineError(instance, office);
+		if (!instance.FS.analyzePath(output).exists) throw new ConversionError("invalid-output", "LibreOffice did not create its PDF output.");
+		const status = instance.FS.stat(output);
+		if (!instance.FS.isFile(status.mode)) throw new ConversionError("invalid-output", "Generated PDF is not a regular file.");
+		if (status.size > options.maxOutputBytes) throw new ConversionError("output-too-large", "Generated PDF exceeds its output byte limit.");
+		const pdf = instance.FS.readFile(output);
+		if (new TextDecoder().decode(pdf.subarray(0, 5)) !== "%PDF-") throw new ConversionError("invalid-output", "LibreOffice did not produce a PDF.");
+		return {
+			pdf,
+			missingFonts: requiredFontLoader(fontLoader).missingFonts
+		};
+	} catch (error) {
+		fatal ||= error instanceof WebAssembly.RuntimeError;
+		failure = error;
+		throw error;
+	} finally {
+		const errors = [];
+		if (module && !fatal) {
+			if (document) try {
+				if (!module.ccall("dsh_lok_document_destroy", "number", ["number"], [document])) throw engineError(module, office);
+			} catch (error) {
+				errors.push(error);
+				fatal ||= error instanceof WebAssembly.RuntimeError;
+			}
+			if (office && !fatal) try {
+				if (!module.ccall("dsh_lok_destroy", "number", ["number"], [office])) throw engineError(module, 0);
+			} catch (error) {
+				errors.push(error);
+			}
+		}
+		if (module) try {
+			module.PThread.terminateAllThreads();
+		} catch (error) {
+			errors.push(error);
+		}
+		if (errors.length) throw new AggregateError(failure ? [failure, ...errors] : errors, "LibreOffice WASM cleanup failed.");
+	}
+}
+//#endregion
+//#region lib/types/worker.js
+/** Cancellable CPU work and WASM conversion run outside the Node event loop. */
+/**
+* @param port - The parent port, present inside a Worker thread.
+* @returns the connected parent port.
+* @throws when this entry is loaded outside a Worker.
+*/
+function requireParentPort(port) {
+	if (port === null) throw new Error("The LibreOffice conversion worker requires a parent port.");
+	return port;
+}
+const port = requireParentPort(parentPort);
+try {
+	const { inputPath, extension, options, engine, scratch, fontFaces } = workerData;
+	const bytes = readFileSync(inputPath);
+	const document = inspectDocument(bytes, extension, options);
+	const faces = fontFaces ?? indexSystemFonts({
+		directories: options.fontDirectories,
+		maxFiles: options.maxFontFiles,
+		maxFileBytes: options.maxFontFileBytes
+	});
+	if (!fontFaces) port.postMessage({
+		kind: "fonts",
+		faces
+	});
+	if (engine.backend === "wasm") {
+		if (faces.length === 0) throw new ConversionError("unavailable", "No usable fonts were found. Install fonts or configure fontDirectories before converting documents.");
+		const result = await convertWithWasm({
+			engine,
+			bytes,
+			extension,
+			options,
+			document,
+			faces
+		});
+		port.postMessage({
+			ok: true,
+			...result
+		}, [result.pdf.buffer]);
+	} else {
+		const directory = join(scratch, "fonts");
+		mkdirSync(directory, { mode: 448 });
+		const fonts = createFontLoader(options, document, (name, data) => {
+			const path = join(directory, name);
+			writeFileSync(path, data, {
+				flag: "wx",
+				mode: 384
+			});
+			return path;
+		}, faces);
+		preloadFonts(fonts, options, document, true);
+		port.postMessage({
+			ok: true,
+			fonts: fonts.files,
+			substitutions: fonts.substitutions,
+			missingFonts: fonts.missingFonts
+		});
+	}
+} catch (error) {
+	port.postMessage({
+		ok: false,
+		code: failureCode(error),
+		error: error instanceof Error ? error.message : String(error),
+		stack: error instanceof Error ? error.stack : void 0
+	});
+}
+//#endregion
+export {};