@songtonyli/dsh-cli 0.1.12 → 0.1.13

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

@@ -0,0 +1,924 @@
+import { createRequire } from "node:module";
+import { constants, lstatSync, readdirSync } from "node:fs";
+import { mkdir, mkdtemp, open, readFile, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { dirname, extname, isAbsolute, join, posix, relative, resolve, sep, win32 } from "node:path";
+import { Worker } from "node:worker_threads";
+import { spawn } from "node:child_process";
+import "fontkit";
+import "fflate";
+import "saxes";
+//#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/native-font-names.js
+/** Localized search names from LibreOffice Core's fixed font-name dictionary. */
+const LOCALIZED_FONT_SEARCH_NAMES = /* @__PURE__ */ new Map([
+	["바탕", "batang"],
+	["바탕체", "batangche"],
+	["궁서", "gungshu"],
+	["궁서체", "gungshuche"],
+	["굴림", "gulim"],
+	["굴림체", "gulimche"],
+	["돋움", "dotum"],
+	["돋움체", "dotumche"],
+	["宋体", "simsun"],
+	["新宋体", "nsimsun"],
+	["黑体", "simhei"],
+	["楷体", "simkai"],
+	["中易宋体", "zycjksun"],
+	["中易黑体", "zycjkhei"],
+	["中易楷体", "zycjkkai"],
+	["方正黑体", "fzhei"],
+	["方正楷体", "fzkai"],
+	["方正宋一", "fzsong"],
+	["方正书宋", "fzshusong"],
+	["方正仿宋", "fzfangsong"],
+	["m简黑", "mhei"],
+	["m潠窪", "mhei"],
+	["m简楷噬", "mkai"],
+	["m潠翱抎", "mkai"],
+	["m简宋", "msong"],
+	["m潠冼", "msong"],
+	["m简夫宋", "cfangsong"],
+	["m潠溘冼", "cfangsong"],
+	["細明體", "mingliu"],
+	["新細明體", "pmingliu"],
+	["桥", "hei"],
+	["歡", "kai"],
+	["浩湧", "ming"],
+	["msゴシック", "msgothic"],
+	["mspゴシック", "mspgothic"],
+	["ms明朝", "msmincho"],
+	["msp明朝", "mspmincho"],
+	["微軟正黑體", "microsoftjhenghei"],
+	["微软雅黑", "microsoftyahei"],
+	["メイリオ", "meiryo"],
+	["hg明朝l", "hgminchol"],
+	["hgゴシックb", "hggothicb"],
+	["hgp明朝l", "hgpminchol"],
+	["hgpゴシックb", "hgpgothicb"],
+	["hg明朝lsun", "hgmincholsun"],
+	["hgゴシックbsun", "hggothicbsun"],
+	["hgp明朝lsun", "hgpmincholsun"],
+	["hgpゴシックbsun", "hgpgothicbsun"],
+	["hg平成明朝体", "hgheiseimin"],
+	["hg平成明朝体w3x12", "hgheiseimin"],
+	["ipa明朝", "ipamincho"],
+	["ipap明朝", "ipapmincho"],
+	["ipaゴシック", "ipagothic"],
+	["ipapゴシック", "ipapgothic"],
+	["ipauiゴシック", "ipauigothic"],
+	["takao明朝", "takaomincho"],
+	["takaop明朝", "takaopmincho"],
+	["takaoゴシック", "takaogothic"],
+	["takaopゴシック", "takaopgothic"],
+	["さざなみ明朝", "sazanamimincho"],
+	["さざなみゴシック", "sazanamigothic"],
+	["東風明朝", "kochimincho"],
+	["東風ゴシック", "kochigothic"],
+	["썬돋움", "sundotum"],
+	["썬굴림", "sungulim"],
+	["썬바탕", "sunbatang"],
+	["백묵돋움", "baekmukdotum"],
+	["백묵굴림", "baekmukgulim"],
+	["백묵바탕", "baekmukbatang"],
+	["方正黑體", "fzheiti"],
+	["方正楷體", "fzkaitib"],
+	["方正明體", "fzmingtib"],
+	["方正宋体", "fzsongti"],
+	["hy견명조", "hymyeongjoextra"],
+	["hy신명조", "hysinmyeongjomedium"],
+	["hy중고딕", "hygothicmedium"],
+	["hy그래픽m", "hygraphicmedium"],
+	["hy그래픽", "hygraphic"],
+	["새굴림", "newgulim"],
+	["썬궁서", "sungungseo"],
+	["hy궁서b", "hygungsobold"],
+	["hy궁서", "hygungso"],
+	["썬헤드라인", "sunheadline"],
+	["hy헤드라인m", "hyheadlinemedium"],
+	["hy헤드라인", "hyheadline"],
+	["휴먼옛체", "yetr"],
+	["hy견고딕", "hygothicextra"],
+	["썬목판", "sunmokpan"],
+	["썬엽서", "sunyeopseo"],
+	["썬백송", "sunbaeksong"],
+	["hy엽서l", "hypostlight"],
+	["hy엽서", "hypost"],
+	["휴먼매직체", "magicr"],
+	["썬크리스탈", "suncrystal"],
+	["썬샘물", "sunsaemmul"],
+	["hy얕은샘물m", "hyshortsamulmedium"],
+	["hy얕은샘물", "hyshortsamul"],
+	["한컴바탕", "haansoftbatang"],
+	["한컴돋움", "haansoftdotum"],
+	["한양해서", "hyhaeseo"],
+	["md솔체", "mdsol"],
+	["md개성체", "mdgaesung"],
+	["md아트체", "mdart"],
+	["md아롱체", "mdalong"],
+	["md이솝체", "mdeasop"],
+	["hgｺﾞｼｯｸe", "hggothice"],
+	["hgpｺﾞｼｯｸe", "hgpgothice"],
+	["hgsｺﾞｼｯｸe", "hgsgothice"],
+	["hgｺﾞｼｯｸm", "hggothicm"],
+	["hgpｺﾞｼｯｸm", "hgpgothicm"],
+	["hgsｺﾞｼｯｸm", "hgsgothicm"],
+	["hg行書体", "hggyoshotai"],
+	["hgp行書体", "hgpgyoshotai"],
+	["hgs行書体", "hgsgyoshotai"],
+	["hg教科書体", "hgkyokashotai"],
+	["hgp教科書体", "hgpkyokashotai"],
+	["hgs教科書体", "hgskyokashotai"],
+	["hg明朝b", "hgminchob"],
+	["hgp明朝b", "hgpminchob"],
+	["hgs明朝b", "hgsminchob"],
+	["hg明朝e", "hgminchoe"],
+	["hgp明朝e", "hgpminchoe"],
+	["hgs明朝e", "hgsminchoe"],
+	["hg創英角ﾎﾟｯﾌﾟ体", "hgsoeikakupoptai"],
+	["hgp創英角ﾎﾟｯﾌﾟ体", "hgpsoeikakupopta"],
+	["hgs創英角ﾎﾟｯﾌﾟ体", "hgssoeikakupopta"],
+	["hg創英ﾌﾟﾚｾﾞﾝｽeb", "hgsoeipresenceeb"],
+	["hgp創英ﾌﾟﾚｾﾞﾝｽeb", "hgpsoeipresenceeb"],
+	["hgs創英ﾌﾟﾚｾﾞﾝｽeb", "hgssoeipresenceeb"],
+	["hg創英角ｺﾞｼｯｸub", "hgsoeikakugothicub"],
+	["hgp創英角ｺﾞｼｯｸub", "hgpsoeikakugothicub"],
+	["hgs創英角ｺﾞｼｯｸub", "hgssoeikakugothicub"],
+	["hg正楷書体-pro", "hgseikaishotaipro"],
+	["hg丸ｺﾞｼｯｸ-pro", "hgmarugothicmpro"],
+	["ヒラギノ明朝pro", "hiraginominchopro"],
+	["ヒラギノ明朝pron", "hiraginominchopron"],
+	["ヒラギノ角ゴシック", "hiraginosans"],
+	["ヒラギノ角ゴpro", "hiraginokakugothicpro"],
+	["ヒラギノ角ゴpron", "hiraginokakugothicpron"],
+	["ヒラギノ丸ゴpro", "hiraginomarugothicpro"],
+	["ヒラギノ丸ゴpron", "hiraginomarugothicpron"],
+	["游ゴシック", "yugothic"],
+	["游ゴシック体", "yugothictai"],
+	["游明朝", "yumincho"],
+	["游明朝体", "yuminchotai"],
+	["源ノ角ゴシック", "sourcehansans"],
+	["源ノ角ゴシックjp", "sourcehansansjp"],
+	["源ノ角ゴシックhw", "sourcehansanshw"],
+	["源ノ明朝", "sourcehanserif"],
+	["源ノ明朝jp", "sourcehanserifjp"],
+	["ipamj明朝", "ipamjmincho"],
+	["ipaexゴシック", "ipaexgothic"],
+	["ipaex明朝", "ipaexmimcho"]
+]);
+//#endregion
+//#region lib/types/native.js
+/** Per-render native helper process ownership and bounded result transport. */
+const METRIC_SEARCH_NAMES = /* @__PURE__ */ new Map([
+	["timesnewroman", "liberationserif"],
+	["arial", "liberationsans"],
+	["arialnarrow", "liberationsansnarrow"],
+	["couriernew", "liberationmono"],
+	["cambria", "caladea"],
+	["calibri", "carlito"],
+	["bundessans", "calibri"],
+	["bundessansoffice", "calibri"],
+	["bundessansregular", "calibri"],
+	["bundesserif", "cambria"],
+	["bundesserifoffice", "cambria"],
+	["bundesserifregular", "cambria"]
+]);
+/** Environment variables the helper inherits from the embedding process. */
+const NATIVE_ENVIRONMENT_KEYS = [
+	"PATH",
+	"SystemRoot",
+	"SYSTEMROOT",
+	"WINDIR",
+	"COMSPEC",
+	"PATHEXT",
+	"LANG",
+	"LC_ALL",
+	"TZ"
+];
+function fontSearchName(value) {
+	const name = value.replaceAll(/[\uff00-\uff5e]/g, (character) => String.fromCharCode(character.charCodeAt(0) - 65248)).replaceAll(/[A-Z]/g, (character) => character.toLowerCase()).replaceAll(/[^a-z0-9;()\u0080-\uffff]/g, "");
+	return LOCALIZED_FONT_SEARCH_NAMES.get(name) ?? name;
+}
+/**
+* Write missing-family choices into the private profile's VCL substitution table.
+* Installed originals and metric-compatible fonts are resolved before this table by LibreOffice.
+* @param profile - Existing, conversion-owned profile directory.
+* @param substitutions - Missing document families and the selected installed family.
+* @returns Resolves after the exclusive profile file is written; empty choices create no file.
+*/
+async function prepareNativeFontProfile(profile, substitutions) {
+	if (substitutions.length === 0) return;
+	const families = new Map(substitutions.map(({ family, substitute }) => [fontSearchName(family), substitute]));
+	for (const [family, substitute] of [...families]) for (let alias = METRIC_SEARCH_NAMES.get(family); alias; alias = METRIC_SEARCH_NAMES.get(alias)) if (!families.has(alias)) families.set(alias, substitute);
+	const escape = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+	const xml = `<?xml version="1.0" encoding="UTF-8"?><oor:items xmlns:oor="http://openoffice.org/2001/registry"><item oor:path="/org.openoffice.VCL/FontSubstitutions/en">${[...families].map(([family, substitute]) => `<node oor:name="${escape(family)}" oor:op="replace"><prop oor:name="SubstFonts" oor:op="fuse"><value>${escape(substitute)}</value></prop></node>`).join("")}</item></oor:items>\n`;
+	const user = join(profile, "user");
+	await mkdir(user, { mode: 448 });
+	await writeFile(join(user, "registrymodifications.xcu"), xml, {
+		flag: "wx",
+		mode: 384
+	});
+}
+/**
+* Linux searches the verified program directory; ambient loader overrides and credentials are excluded.
+* @param profile - Conversion-owned profile directory the helper treats as home.
+* @param programDirectory - Verified engine program directory.
+* @param source - Embedding process environment.
+* @param platform - Host operating system.
+* @returns the environment the helper starts with.
+*/
+function nativeEnvironment(profile, programDirectory, source = process.env, platform = process.platform) {
+	const env = {};
+	for (const key of NATIVE_ENVIRONMENT_KEYS) {
+		const value = source[key];
+		if (value !== void 0) env[key] = value;
+	}
+	if (platform === "linux") env.LD_LIBRARY_PATH = programDirectory;
+	return Object.assign(env, {
+		HOME: profile,
+		USERPROFILE: profile,
+		TMPDIR: profile,
+		TMP: profile,
+		TEMP: profile
+	});
+}
+/**
+* Run one native conversion and await bounded result transport.
+* @param engine - Resolved native engine installation.
+* @param options - Validated conversion limits.
+* @param input - Private source path inside the conversion scratch directory.
+* @param output - Private PDF path inside the conversion scratch directory.
+* @param profile - Conversion-owned profile directory.
+* @param fonts - Installed font files the helper may load.
+* @param substitutions - Missing families and their selected installed substitutes.
+* @param signal - Cancellation; it kills the helper and awaits its exit.
+* @throws ConversionError for a reported conversion failure, and the abort reason for cancellation.
+*/
+async function runNative(engine, options, input, output, profile, fonts, substitutions, signal) {
+	signal.throwIfAborted();
+	await prepareNativeFontProfile(profile, substitutions);
+	signal.throwIfAborted();
+	const env = nativeEnvironment(profile, engine.programDirectory);
+	const child = spawn(engine.executable, [
+		"--program-directory",
+		engine.programDirectory,
+		"--input-path",
+		input,
+		"--output-path",
+		output,
+		"--profile-directory",
+		profile,
+		"--max-output-bytes",
+		String(options.maxOutputBytes),
+		"--max-image-resolution",
+		String(options.maxImageResolution),
+		...fonts.flatMap((path) => ["--font-file", path])
+	], {
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		windowsHide: true,
+		env
+	});
+	let stdout = "";
+	let stderr = "";
+	let failure;
+	const abort = () => {
+		failure ??= signal.reason;
+		child.kill("SIGKILL");
+	};
+	signal.addEventListener("abort", abort, { once: true });
+	child.stdout.setEncoding("utf8");
+	child.stderr.setEncoding("utf8");
+	child.stdout.on("data", (chunk) => {
+		stdout += chunk;
+		if (stdout.length > 65536) {
+			failure ??= /* @__PURE__ */ new Error("LibreOffice helper exceeded its response limit.");
+			child.kill("SIGKILL");
+		}
+	});
+	child.stderr.on("data", (chunk) => {
+		stderr = (stderr + chunk).slice(-65536);
+	});
+	try {
+		const code = await new Promise((resolve, reject) => {
+			child.once("error", (error) => {
+				failure ??= error;
+			});
+			child.once("close", (code, signal) => {
+				if (signal === "SIGXFSZ") failure ??= new ConversionError("output-too-large", "LibreOffice exceeded its output file-size limit.");
+				if (failure) reject(failure);
+				else resolve(code);
+			});
+		});
+		signal.throwIfAborted();
+		let result;
+		try {
+			result = JSON.parse(stdout);
+		} catch (cause) {
+			throw new Error(`LibreOffice helper returned an invalid response (exit ${code}). ${stderr}`, { cause });
+		}
+		if (code !== 0 || result.ok !== true) throw new ConversionError(failureCode(result), `LibreOffice native conversion failed: ${result.error ?? stderr}`);
+	} finally {
+		signal.removeEventListener("abort", abort);
+	}
+}
+//#endregion
+//#region lib/types/fonts.js
+/** Host font metadata snapshots and conversion-local glyph matching over original files. */
+/**
+* @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));
+}
+/**
+* Discover system and per-user font roots using the selected platform's path separators.
+* @param platform - Host operating system.
+* @param home - Host user home used to locate per-user font directories.
+* @param env - Host environment containing Windows and XDG directory overrides.
+* @returns candidate directories; missing platform directories are ignored during indexing.
+*/
+function systemFontDirectories(platform = process.platform, home = homedir(), env = process.env) {
+	if (platform === "win32") return [win32.join(env.SystemRoot ?? "C:\\Windows", "Fonts"), win32.join(env.LOCALAPPDATA ?? win32.join(home, "AppData", "Local"), "Microsoft", "Windows", "Fonts")];
+	if (platform === "darwin") return [
+		"/System/Library/Fonts",
+		"/Library/Fonts",
+		posix.join(home, "Library/Fonts"),
+		...mobileAssetFontDirectories("/System/Library/AssetsV2")
+	];
+	const shared = (env.XDG_DATA_DIRS ?? "/usr/local/share:/usr/share").split(":").filter(Boolean);
+	return [.../* @__PURE__ */ new Set([
+		...shared.map((path) => posix.join(path, "fonts")),
+		posix.join(home, ".fonts"),
+		posix.join(env.XDG_DATA_HOME ?? posix.join(home, ".local/share"), "fonts")
+	])];
+}
+/**
+* Font asset directories macOS publishes under its MobileAsset root.
+* @param assets - Absolute MobileAsset font directory root.
+* @returns matching asset directories, sorted by name.
+* @throws when the root exists but cannot be read for a reason other than its absence or protection.
+*/
+function mobileAssetFontDirectories(assets) {
+	let entries = [];
+	try {
+		entries = readdirSync(assets);
+	} catch (error) {
+		if (!absent(error)) throw error;
+	}
+	return entries.filter((name) => /^com_apple_MobileAsset_Font\d*$/.test(name)).sort().map((name) => join(assets, name));
+}
+//#endregion
+//#region lib/types/options.js
+const SANS_CJK_FAMILIES = [
+	"Microsoft YaHei",
+	"Microsoft YaHei UI",
+	"微软雅黑",
+	"PingFang SC",
+	"Noto Sans CJK SC",
+	"Noto Sans SC",
+	"Source Han Sans SC",
+	"SimHei",
+	"黑体",
+	"Heiti SC",
+	"STHeiti"
+];
+/** Ordered family groups used when the caller supplies none. */
+const FONT_FALLBACKS = [
+	["Calibri", "Carlito"],
+	[
+		"Calibri Light",
+		"Carlito",
+		"Calibri"
+	],
+	["Cambria", "Caladea"],
+	[
+		"宋体",
+		"SimSun",
+		"NSimSun",
+		"Songti SC",
+		"STSong",
+		"Noto Serif CJK SC",
+		"Noto Serif SC",
+		"Source Han Serif SC"
+	],
+	[
+		"黑体",
+		"SimHei",
+		"Heiti SC",
+		"STHeiti",
+		"Noto Sans CJK SC",
+		"Noto Sans SC",
+		"Source Han Sans SC"
+	],
+	[
+		"微软雅黑",
+		"Microsoft YaHei",
+		"Microsoft YaHei UI",
+		"PingFang SC",
+		"Noto Sans CJK SC",
+		"Noto Sans SC"
+	],
+	[
+		"楷体",
+		"KaiTi",
+		"Kaiti SC",
+		"STKaiti",
+		"LXGW WenKai"
+	],
+	[
+		"仿宋",
+		"FangSong",
+		"STFangsong",
+		"Songti SC",
+		"Noto Serif CJK SC"
+	],
+	[
+		"sans-serif",
+		"Arial",
+		"Liberation Sans",
+		"Helvetica",
+		"DejaVu Sans",
+		"Calibri",
+		"Calibri Light",
+		"Carlito",
+		...SANS_CJK_FAMILIES
+	],
+	[
+		"serif",
+		"Times New Roman",
+		"Liberation Serif",
+		"Times",
+		"DejaVu Serif",
+		"Cambria",
+		"Caladea",
+		"SimSun",
+		"NSimSun",
+		"宋体",
+		"Songti SC",
+		"STSong",
+		"Noto Serif CJK SC",
+		"Noto Serif SC",
+		"Source Han Serif SC"
+	],
+	[
+		"monospace",
+		"Courier New",
+		"Liberation Mono",
+		"DejaVu Sans Mono",
+		"Menlo",
+		"Monaco",
+		"Courier",
+		"NSimSun",
+		"Noto Sans Mono CJK SC",
+		...SANS_CJK_FAMILIES
+	],
+	[
+		"Symbol",
+		"Standard Symbols PS",
+		"Symbola",
+		"Segoe UI Symbol",
+		"Apple Symbols",
+		"FreeSerif",
+		"DejaVu Sans"
+	]
+];
+const DEFAULT_LIMITS = {
+	timeoutMs: 12e4,
+	maxInputBytes: 67108864,
+	maxOutputBytes: 134217728,
+	maxImageResolution: 144,
+	maxArchiveEntries: 2e4,
+	maxUncompressedBytes: 536870912,
+	maxFontFiles: 2e4,
+	maxFontFileBytes: 268435456,
+	maxLoadedFontBytes: 536870912
+};
+const FONT_COLLECTION_NAMES = ["fontDirectories", "initialFontFamilies"];
+function positiveSafeInteger(value, name) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) throw new RangeError(`${name} must be a positive safe integer.`);
+	if (name.endsWith("Ms") && value > 2147483647) throw new RangeError(`${name} exceeds the Node timer range.`);
+	return value;
+}
+function fontNames(value, name) {
+	if (!Array.isArray(value)) throw new TypeError(`${name} must contain nonempty strings.`);
+	const names = [];
+	for (const entry of value) {
+		if (typeof entry !== "string" || entry.length === 0 || entry.includes("\0")) throw new TypeError(`${name} must contain nonempty strings.`);
+		names.push(entry);
+	}
+	return names;
+}
+function fontGroups(value) {
+	if (!Array.isArray(value) || value.some((group) => !Array.isArray(group) || group.length < 2 || group.some((entry) => typeof entry !== "string" || !entry.trim()))) throw new TypeError("fontFallbacks must contain groups of at least two nonblank font names.");
+	return value.map((group) => [...group]);
+}
+/**
+* Resolve defaults once; reject misspelled options and malformed font settings.
+* @param input - Caller options; absent fields keep their documented default.
+* @returns The validated limits and font settings, with caller arrays copied.
+* @throws TypeError for a non-object argument or an unknown option name.
+* @throws RangeError for a limit outside the positive safe-integer timer range.
+*/
+function resolveOptions(input = {}) {
+	const callerOptions = input;
+	if (callerOptions === null || typeof callerOptions !== "object" || Array.isArray(callerOptions)) throw new TypeError("Converter options must be an object.");
+	const merged = {
+		...DEFAULT_LIMITS,
+		fontDirectories: systemFontDirectories(),
+		fontFallbacks: FONT_FALLBACKS,
+		initialFontFamilies: [],
+		...input
+	};
+	for (const key of Object.keys(input)) if (!(key in DEFAULT_LIMITS) && !FONT_COLLECTION_NAMES.includes(key) && key !== "fontFallbacks") throw new TypeError(`Unknown converter option: ${key}`);
+	return {
+		timeoutMs: positiveSafeInteger(merged.timeoutMs, "timeoutMs"),
+		maxInputBytes: positiveSafeInteger(merged.maxInputBytes, "maxInputBytes"),
+		maxOutputBytes: positiveSafeInteger(merged.maxOutputBytes, "maxOutputBytes"),
+		maxImageResolution: positiveSafeInteger(merged.maxImageResolution, "maxImageResolution"),
+		maxArchiveEntries: positiveSafeInteger(merged.maxArchiveEntries, "maxArchiveEntries"),
+		maxUncompressedBytes: positiveSafeInteger(merged.maxUncompressedBytes, "maxUncompressedBytes"),
+		maxFontFiles: positiveSafeInteger(merged.maxFontFiles, "maxFontFiles"),
+		maxFontFileBytes: positiveSafeInteger(merged.maxFontFileBytes, "maxFontFileBytes"),
+		maxLoadedFontBytes: positiveSafeInteger(merged.maxLoadedFontBytes, "maxLoadedFontBytes"),
+		fontDirectories: fontNames(merged.fontDirectories, "fontDirectories"),
+		initialFontFamilies: fontNames(merged.initialFontFamilies, "initialFontFamilies"),
+		fontFallbacks: fontGroups(merged.fontFallbacks)
+	};
+}
+//#endregion
+//#region lib/types/engine.js
+/** Resolve installed, version-matched engine packages without downloads or compilation. */
+const require = createRequire(import.meta.url);
+/**
+* Engine-family version every installed engine package must carry. The engine
+* family shares its release version with this Node API.
+*/
+const ENGINE_VERSION = "0.0.1";
+/** npm scope and name prefix shared by the engine packages this adapter installs. */
+const ENGINE_PREFIX = "@deepseek-ai/libreoffice-kit";
+/**
+* Whether an installed engine package directory is present on the resolution path.
+* @param name - Engine package name.
+* @returns true when at least one resolution directory holds the package.
+*/
+function installedPackageExists(name) {
+	return (require.resolve.paths(name) ?? []).some((directory) => lstatSync(join(directory, name), { throwIfNoEntry: false }) !== void 0);
+}
+/**
+* Return the optional package target for the current process ABI.
+* @param platform - Host operating system.
+* @param arch - Host CPU architecture.
+* @param report - Host diagnostic report used to identify glibc.
+* @returns the declared platform target, or undefined for an unsupported host.
+*/
+function platformTarget(platform = process.platform, arch = process.arch, report = hostReport) {
+	if (!["arm64", "x64"].includes(arch)) return void 0;
+	if (platform === "darwin" || platform === "win32") return `${platform}-${arch}`;
+	if (platform !== "linux") return void 0;
+	return report().header?.glibcVersionRuntime ? `linux-${arch}-glibc` : void 0;
+}
+/** @returns the host diagnostic report as the engine resolver reads it. */
+function hostReport() {
+	return process.report.getReport();
+}
+function asset(root, value) {
+	if (typeof value !== "string" || !value || isAbsolute(value)) throw new Error("Engine manifest contains an invalid asset path.");
+	const path = resolve(root, value);
+	if (relative(root, path).startsWith(`..${sep}`) || relative(root, path) === "..") throw new Error("Engine asset escapes its installed package.");
+	return path;
+}
+function glibcVersion(value) {
+	return typeof value === "string" && /^(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\.(0|[1-9]\d*))?$/.test(value) && value.split(".").every((part) => Number.isSafeInteger(Number(part))) ? value.split(".").map(Number) : void 0;
+}
+/**
+* macOS and Windows require their native engine. Linux uses WASM when no compatible development native engine is installed.
+* @param resolvePackage - Package manifest resolver; injectable for selection tests.
+* @param packageExists - Installed-package probe; injectable for selection tests.
+* @param host - Process identification and diagnostic report.
+* @returns the installed native engine, or the installed WASM engine.
+*/
+async function resolveEngine(resolvePackage = (name) => require.resolve(`${name}/package.json`), packageExists = installedPackageExists, { platform = process.platform, arch = process.arch, report = hostReport } = {}) {
+	const details = platform === "linux" ? report() : {};
+	const target = platformTarget(platform, arch, () => details);
+	if (target !== void 0) {
+		const name = `${ENGINE_PREFIX}-${target}`;
+		let packageFile;
+		try {
+			packageFile = resolvePackage(name);
+		} catch (error) {
+			const failure = error;
+			if (!(failure?.code === "MODULE_NOT_FOUND" && typeof failure.message === "string" && failure.message.includes(`${name}/package.json`))) throw error;
+			if (packageExists(name)) throw new Error(`Installed LibreOfficeKit package is incomplete: ${name}`, { cause: error });
+			if (platform !== "linux") throw new Error(`Required LibreOfficeKit native package is missing: ${name}`, { cause: error });
+		}
+		if (packageFile !== void 0) {
+			const engine = await readEngine(packageFile, "native", target);
+			const minimum = glibcVersion(engine.glibcMinimum);
+			const host = glibcVersion(details.header?.glibcVersionRuntime);
+			if (!(minimum && host && minimum.some((part, index) => part > (host[index] ?? 0) && minimum.slice(0, index).every((prior, priorIndex) => prior === host[priorIndex])))) return engine;
+		}
+	}
+	if (platform !== "linux") throw new Error(`Unsupported LibreOfficeKit host: ${platform}-${arch}`);
+	return readEngine(resolvePackage(`${ENGINE_PREFIX}-wasm`), "wasm", "wasm");
+}
+async function engineAsset(root, value, name, kind) {
+	const path = asset(root, value);
+	const status = await stat(path);
+	if (kind === "directory" ? !status.isDirectory() : !status.isFile()) throw new Error(`Installed LibreOfficeKit ${name} is not a ${kind}.`);
+	if (name === "executable" && process.platform !== "win32" && !(status.mode & 73)) throw new Error("Installed LibreOfficeKit executable is not executable.");
+	return path;
+}
+async function readEngine(packageFile, backend, target) {
+	const root = dirname(packageFile);
+	const [pkg, manifest] = await Promise.all([readFile(packageFile, "utf8").then((text) => JSON.parse(text)), readFile(resolve(root, "prebuilds.json"), "utf8").then((text) => JSON.parse(text))]);
+	const engine = manifest.engine;
+	if (pkg.name !== `${ENGINE_PREFIX}-${target}` || pkg.version !== "0.0.1" || manifest.version !== pkg.version || manifest.schemaVersion !== 1 || manifest.status !== "built" || engine === void 0 || engine.kind !== backend || manifest.platform !== target) throw new Error(`Installed LibreOfficeKit ${backend} package has an incompatible or incomplete manifest.`);
+	const minimum = engine.glibcMinimum;
+	if (minimum !== void 0 && (!target.endsWith("-glibc") || !glibcVersion(minimum))) throw new Error("Installed LibreOfficeKit engine has an invalid glibcMinimum.");
+	const glibcFloor = minimum === void 0 ? {} : { glibcMinimum: minimum };
+	if (backend === "native") {
+		const executable = await engineAsset(root, engine.executable, "executable", "file");
+		return {
+			backend,
+			root,
+			programDirectory: await engineAsset(root, engine.programDirectory, "programDirectory", "directory"),
+			executable,
+			...glibcFloor
+		};
+	}
+	return {
+		backend,
+		root,
+		programDirectory: String(engine.programDirectory),
+		loader: await engineAsset(root, engine.loader, "loader", "file"),
+		wasm: await engineAsset(root, engine.wasm, "wasm", "file"),
+		data: await engineAsset(root, engine.data, "data", "file"),
+		metadata: await engineAsset(root, engine.metadata, "metadata", "file"),
+		...glibcFloor
+	};
+}
+//#endregion
+//#region lib/types/document.js
+/** Input suffixes accepted by the public converter. */
+const DOCUMENT_EXTENSIONS = [
+	"doc",
+	"docx",
+	"xls",
+	"xlsx",
+	"ppt",
+	"pptx"
+];
+//#endregion
+//#region lib/types/index.js
+/** Convert caller-authorized disk documents with installed native or Node WASM engines. */
+/** File identity that must match across a bounded read. */
+const CHANGED_KEYS = [
+	"size",
+	"mtimeMs",
+	"ctimeMs"
+];
+async function readBounded(path, limit, signal, role) {
+	const file = await open(path, constants.O_RDONLY | constants.O_NONBLOCK | constants.O_NOFOLLOW);
+	try {
+		const before = await file.stat();
+		const invalid = role === "input" ? "invalid-document" : "invalid-output";
+		if (!before.isFile() || before.size < 1) throw new ConversionError(invalid, "Document must be a nonempty regular file.");
+		if (before.size > limit) throw new ConversionError(`${role}-too-large`, `Document exceeds its ${role} byte limit.`);
+		const bytes = Buffer.alloc(before.size);
+		for (let offset = 0; offset < bytes.length;) {
+			signal.throwIfAborted();
+			const { bytesRead } = await file.read(bytes, offset, bytes.length - offset, offset);
+			if (!bytesRead) throw new ConversionError(invalid, "Document was truncated while reading.");
+			offset += bytesRead;
+		}
+		const after = await file.stat();
+		if (CHANGED_KEYS.some((key) => before[key] !== after[key])) throw new ConversionError(invalid, "Document changed while reading.");
+		signal.throwIfAborted();
+		return bytes;
+	} finally {
+		await file.close();
+	}
+}
+async function runWorker(data, signal, onFonts) {
+	signal.throwIfAborted();
+	const worker = new Worker(new URL("./worker.js", import.meta.url), {
+		workerData: data,
+		name: "libreoffice-conversion",
+		execArgv: [],
+		stdout: true,
+		stderr: true
+	});
+	worker.stdout.resume();
+	worker.stderr.resume();
+	const settled = Promise.withResolvers();
+	const abort = () => {
+		settled.reject(signal.reason);
+	};
+	signal.addEventListener("abort", abort, { once: true });
+	worker.once("error", settled.reject);
+	worker.once("exit", (code) => {
+		settled.reject(new ConversionError("failed", `LibreOffice worker exited before returning a result (${code}).`));
+	});
+	worker.on("message", (message) => {
+		if (message.kind === "fonts") onFonts(message.faces);
+		else if (message.ok) settled.resolve(message);
+		else settled.reject(new ConversionError(failureCode(message), message.error));
+	});
+	try {
+		return await settled.promise;
+	} finally {
+		signal.removeEventListener("abort", abort);
+		await worker.terminate();
+	}
+}
+/**
+* Resolve the installed engine and deployment limits without starting LibreOffice.
+* @param options - Conversion, font, and output limits.
+* @returns A serial converter; dispose it after use.
+* @throws TypeError for invalid options, or an unavailable ConversionError for invalid installed engines.
+* An absent native engine or a known unsupported glibc version selects WASM.
+*/
+async function createConverter(options) {
+	const resolvedOptions = resolveOptions(options);
+	let engine;
+	try {
+		engine = await resolveEngine();
+	} catch (cause) {
+		throw new ConversionError("unavailable", cause.message, { cause });
+	}
+	const lifetime = new AbortController();
+	const active = /* @__PURE__ */ new Set();
+	const waiting = /* @__PURE__ */ new Set();
+	let running = false;
+	let disposal;
+	let fontFaces;
+	async function acquire(signal) {
+		while (running) {
+			signal.throwIfAborted();
+			await new Promise((resolve, reject) => {
+				const cleanup = () => {
+					waiting.delete(wake);
+					signal.removeEventListener("abort", abort);
+				};
+				const wake = () => {
+					cleanup();
+					resolve();
+				};
+				const abort = () => {
+					cleanup();
+					reject(signal.reason);
+				};
+				waiting.add(wake);
+				signal.addEventListener("abort", abort, { once: true });
+			});
+		}
+		signal.throwIfAborted();
+		running = true;
+	}
+	async function render(request, signal) {
+		if (!request || typeof request.inputPath !== "string" || typeof request.outputPath !== "string" || !isAbsolute(request.inputPath) || !isAbsolute(request.outputPath) || request.inputPath.includes("\0") || request.outputPath.includes("\0")) throw new TypeError("inputPath and outputPath must be absolute filesystem paths.");
+		if (resolve(request.inputPath) === resolve(request.outputPath)) throw new Error("Input and output paths must differ.");
+		const extension = extname(request.inputPath).slice(1).toLowerCase();
+		if (!DOCUMENT_EXTENSIONS.includes(extension)) throw new ConversionError("unsupported-format", `Input extension must be ${DOCUMENT_EXTENSIONS.join(", ")}.`);
+		await acquire(signal);
+		const deadline = new AbortController();
+		const stopped = AbortSignal.any([signal, deadline.signal]);
+		const timer = setTimeout(() => {
+			deadline.abort(new ConversionError("timeout", "LibreOffice conversion timed out."));
+		}, resolvedOptions.timeoutMs);
+		let scratch;
+		let output;
+		let succeeded = false;
+		let failure;
+		try {
+			stopped.throwIfAborted();
+			output = await open(request.outputPath, "wx", 384);
+			const bytes = await readBounded(request.inputPath, resolvedOptions.maxInputBytes, stopped, "input");
+			scratch = await mkdtemp(join(tmpdir(), "libreoffice-kit-"));
+			const inputPath = join(scratch, `document.${extension}`);
+			const input = await open(inputPath, "wx", 384);
+			try {
+				await input.writeFile(bytes);
+			} finally {
+				await input.close();
+			}
+			const result = await runWorker({
+				inputPath,
+				extension,
+				options: resolvedOptions,
+				engine,
+				scratch,
+				fontFaces
+			}, stopped, (faces) => {
+				fontFaces = faces;
+			});
+			let pdf;
+			if ("pdf" in result) pdf = result.pdf;
+			else {
+				const native = engine;
+				const profile = join(scratch, "profile");
+				await mkdir(profile, { mode: 448 });
+				const path = join(scratch, "document.pdf");
+				await runNative(native, resolvedOptions, inputPath, path, profile, result.fonts, result.substitutions, stopped);
+				pdf = await readBounded(path, resolvedOptions.maxOutputBytes, stopped, "output");
+			}
+			if (Buffer.from(pdf.subarray(0, 5)).toString() !== "%PDF-") throw new ConversionError("invalid-output", "LibreOffice did not produce a PDF.");
+			stopped.throwIfAborted();
+			await output.writeFile(pdf);
+			stopped.throwIfAborted();
+			succeeded = true;
+			return {
+				backend: engine.backend,
+				missingFonts: result.missingFonts
+			};
+		} catch (error) {
+			failure = error;
+			throw error;
+		} finally {
+			clearTimeout(timer);
+			try {
+				const errors = [];
+				try {
+					await output?.close();
+				} catch (error) {
+					errors.push(error);
+				}
+				const cleanup = await Promise.allSettled([...output && !succeeded ? [unlink(request.outputPath)] : [], ...scratch ? [rm(scratch, {
+					recursive: true,
+					force: true
+				})] : []]);
+				for (const result of cleanup) if (result.status === "rejected") errors.push(result.reason);
+				if (errors.length) throw new AggregateError(failure ? [failure, ...errors] : errors, "LibreOffice conversion cleanup failed.");
+			} finally {
+				running = false;
+				for (const wake of [...waiting]) wake();
+			}
+		}
+	}
+	return {
+		backend: engine.backend,
+		render(request, signal) {
+			const task = render(request, signal ? AbortSignal.any([signal, lifetime.signal]) : lifetime.signal);
+			active.add(task);
+			task.finally(() => {
+				active.delete(task);
+			}).catch((_error) => {});
+			return task;
+		},
+		dispose() {
+			disposal ??= (async () => {
+				lifetime.abort(/* @__PURE__ */ new Error("LibreOffice converter is disposed."));
+				await Promise.allSettled(active);
+			})();
+			return disposal;
+		}
+	};
+}
+//#endregion
+export { ConversionError, ENGINE_VERSION, createConverter };