node-poppler 8.0.3 → 8.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "node-poppler",
-	"version": "8.0.3",
+	"version": "8.0.4",
 	"description": "Asynchronous Node.js wrapper for the Poppler PDF rendering library",
 	"keywords": [
 		"async",

package/src/index.js

@@ -106,6 +106,22 @@ function parseOptions(acceptedOptions, options, version) {
 class Poppler {
 	#popplerPath;
 
+	#pdfAttachBin;
+	#pdfDetachBin;
+	#pdfFontsBin;
+	#pdfImagesBin;
+	#pdfInfoBin;
+	#pdfSeparateBin;
+	#pdfToCairoBin;
+	#pdfToHtmlBin;
+	#pdfToPpmBin;
+	#pdfToPsBin;
+	#pdfToTextBin;
+	#pdfUniteBin;
+
+	#binVersions = new Map();
+	#acceptedOptions = new Map();
+
 	/**
 	 * @param {string} [binPath] - Path of poppler-utils binaries.
 	 * If not provided, the constructor will attempt to find the Poppler `pdfinfo` binary
@@ -148,6 +164,19 @@ class Poppler {
 			);
 		}
 		this.#popplerPath = normalize(this.#popplerPath);
+
+		this.#pdfAttachBin = pathResolve(this.#popplerPath, "pdfattach");
+		this.#pdfDetachBin = pathResolve(this.#popplerPath, "pdfdetach");
+		this.#pdfFontsBin = pathResolve(this.#popplerPath, "pdffonts");
+		this.#pdfImagesBin = pathResolve(this.#popplerPath, "pdfimages");
+		this.#pdfInfoBin = pathResolve(this.#popplerPath, "pdfinfo");
+		this.#pdfSeparateBin = pathResolve(this.#popplerPath, "pdfseparate");
+		this.#pdfToCairoBin = pathResolve(this.#popplerPath, "pdftocairo");
+		this.#pdfToHtmlBin = pathResolve(this.#popplerPath, "pdftohtml");
+		this.#pdfToPpmBin = pathResolve(this.#popplerPath, "pdftoppm");
+		this.#pdfToPsBin = pathResolve(this.#popplerPath, "pdftops");
+		this.#pdfToTextBin = pathResolve(this.#popplerPath, "pdftotext");
+		this.#pdfUniteBin = pathResolve(this.#popplerPath, "pdfunite");
 	}
 
 	/**
@@ -158,6 +187,445 @@ class Poppler {
 		return this.#popplerPath;
 	}
 
+	/**
+	 * @author Frazer Smith
+	 * @description Returns the version of the specified Poppler binary.
+	 * @param {string} binary - The Poppler binary to get the version of.
+	 * @returns {Promise<string>} A promise that resolves with the version of the binary, or rejects with an `Error` object.
+	 */
+	async #getVersion(binary) {
+		if (!this.#binVersions.has(binary)) {
+			const { stderr } = await execFileAsync(binary, ["-v"]);
+			// @ts-ignore: parseOptions checks if falsy
+			const version = POPPLER_VERSION_REG.exec(stderr)[1];
+			this.#binVersions.set(binary, version);
+		}
+		return this.#binVersions.get(binary);
+	}
+
+	/**
+	 * @author Frazer Smith
+	 * @description Returns the accepted options for the specified Poppler binary function.
+	 * @param {string} functionName - The name of the Poppler binary function.
+	 * @returns {PopplerAcceptedOptions} An object containing the accepted options of the specified function.
+	 */
+	#getAcceptedOptions(functionName) {
+		if (!this.#acceptedOptions.has(functionName)) {
+			switch (functionName) {
+				case "pdfAttach":
+					this.#acceptedOptions.set("pdfAttach", {
+						printVersionInfo: { arg: "-v", type: "boolean" },
+						replace: { arg: "-replace", type: "boolean" },
+					});
+					break;
+				case "pdfDetach":
+					this.#acceptedOptions.set("pdfDetach", {
+						listEmbedded: { arg: "-list", type: "boolean" },
+						outputEncoding: { arg: "-enc", type: "string" },
+						outputPath: { arg: "-o", type: "string" },
+						ownerPassword: { arg: "-opw", type: "string" },
+						printVersionInfo: { arg: "-v", type: "boolean" },
+						saveAllFiles: { arg: "-saveall", type: "boolean" },
+						saveFile: {
+							arg: "-savefile",
+							type: "string",
+							minVersion: "0.86.0",
+						},
+						saveSpecificFile: { arg: "-save", type: "number" },
+						userPassword: { arg: "-upw", type: "string" },
+					});
+					break;
+				case "pdfFonts":
+					this.#acceptedOptions.set("pdfFonts", {
+						firstPageToExamine: { arg: "-f", type: "number" },
+						lastPageToExamine: { arg: "-l", type: "number" },
+						listSubstitutes: { arg: "-subst", type: "boolean" },
+						ownerPassword: { arg: "-opw", type: "string" },
+						printVersionInfo: { arg: "-v", type: "boolean" },
+						userPassword: { arg: "-upw", type: "string" },
+					});
+					break;
+				case "pdfImages":
+					this.#acceptedOptions.set("pdfImages", {
+						allFiles: { arg: "-all", type: "boolean" },
+						ccittFile: { arg: "-ccitt", type: "boolean" },
+						firstPageToConvert: { arg: "-f", type: "number" },
+						lastPageToConvert: { arg: "-l", type: "number" },
+						jbig2File: { arg: "-jbig2", type: "boolean" },
+						jpeg2000File: { arg: "-jp2", type: "boolean" },
+						jpegFile: { arg: "-j", type: "boolean" },
+						list: { arg: "-list", type: "boolean" },
+						ownerPassword: { arg: "-opw", type: "string" },
+						pngFile: { arg: "-png", type: "boolean" },
+						printVersionInfo: { arg: "-v", type: "boolean" },
+						tiffFile: { arg: "-tiff", type: "boolean" },
+						userPassword: { arg: "-upw", type: "string" },
+					});
+					break;
+				case "pdfInfo":
+					this.#acceptedOptions.set("pdfInfo", {
+						firstPageToConvert: { arg: "-f", type: "number" },
+						lastPageToConvert: { arg: "-l", type: "number" },
+						listEncodingOptions: {
+							arg: "-listenc",
+							type: "boolean",
+						},
+						outputEncoding: { arg: "-enc", type: "string" },
+						ownerPassword: { arg: "-opw", type: "string" },
+						printAsJson: { arg: "", type: "boolean" },
+						printBoundingBoxes: { arg: "-box", type: "boolean" },
+						printDocStruct: { arg: "-struct", type: "boolean" },
+						printDocStructText: {
+							arg: "-struct-text",
+							type: "boolean",
+						},
+						printIsoDates: { arg: "-isodates", type: "boolean" },
+						printJS: { arg: "-js", type: "boolean" },
+						printMetadata: { arg: "-meta", type: "boolean" },
+						printNamedDests: { arg: "-dests", type: "boolean" },
+						printRawDates: { arg: "-rawdates", type: "boolean" },
+						printUrls: {
+							arg: "-url",
+							type: "boolean",
+							minVersion: "21.11.0",
+						},
+						printVersionInfo: { arg: "-v", type: "boolean" },
+						userPassword: { arg: "-upw", type: "string" },
+					});
+					break;
+				case "pdfSeparate":
+					this.#acceptedOptions.set("pdfSeparate", {
+						firstPageToExtract: { arg: "-f", type: "number" },
+						lastPageToExtract: { arg: "-l", type: "number" },
+						printVersionInfo: { arg: "-v", type: "boolean" },
+					});
+					break;
+				case "pdfToCairo":
+					this.#acceptedOptions.set("pdfToCairo", {
+						antialias: { arg: "-antialias", type: "string" },
+						cropBox: { arg: "-cropbox", type: "boolean" },
+						cropHeight: { arg: "-H", type: "number" },
+						cropSize: { arg: "-sz", type: "number" },
+						cropWidth: { arg: "-W", type: "number" },
+						cropXAxis: { arg: "-x", type: "number" },
+						cropYAxis: { arg: "-y", type: "number" },
+						duplex: { arg: "-duplex", type: "boolean" },
+						epsFile: { arg: "-eps", type: "boolean" },
+						evenPagesOnly: { arg: "-e", type: "boolean" },
+						fillPage: { arg: "-expand", type: "boolean" },
+						firstPageToConvert: { arg: "-f", type: "number" },
+						grayscaleFile: { arg: "-gray", type: "boolean" },
+						iccFile: { arg: "-icc", type: "string" },
+						jpegFile: { arg: "-jpeg", type: "boolean" },
+						jpegOptions: { arg: "-jpegopt", type: "string" },
+						lastPageToConvert: { arg: "-l", type: "number" },
+						monochromeFile: { arg: "-mono", type: "boolean" },
+						noCenter: { arg: "-nocenter", type: "boolean" },
+						noCrop: { arg: "-nocrop", type: "boolean" },
+						noShrink: { arg: "-noshrink", type: "boolean" },
+						oddPagesOnly: { arg: "-o", type: "boolean" },
+						originalPageSizes: {
+							arg: "-origpagesizes",
+							type: "boolean",
+						},
+						ownerPassword: { arg: "-opw", type: "string" },
+						paperHeight: { arg: "-paperh", type: "number" },
+						paperSize: { arg: "-paper", type: "string" },
+						paperWidth: { arg: "-paperw", type: "number" },
+						pdfFile: { arg: "-pdf", type: "boolean" },
+						pngFile: { arg: "-png", type: "boolean" },
+						printDocStruct: {
+							arg: "-struct",
+							type: "boolean",
+							minVersion: "23.11.0",
+						},
+						printVersionInfo: { arg: "-v", type: "boolean" },
+						psFile: { arg: "-ps", type: "boolean" },
+						psLevel2: { arg: "-level2", type: "boolean" },
+						psLevel3: { arg: "-level3", type: "boolean" },
+						quiet: { arg: "-q", type: "boolean" },
+						resolutionXAxis: { arg: "-rx", type: "number" },
+						resolutionXYAxis: { arg: "-r", type: "number" },
+						resolutionYAxis: { arg: "-ry", type: "number" },
+						scalePageTo: { arg: "-scale-to", type: "number" },
+						scalePageToXAxis: {
+							arg: "-scale-to-x",
+							type: "number",
+						},
+						scalePageToYAxis: {
+							arg: "-scale-to-y",
+							type: "number",
+						},
+						singleFile: { arg: "-singlefile", type: "boolean" },
+						svgFile: { arg: "-svg", type: "boolean" },
+						tiffCompression: {
+							arg: "-tiffcompression",
+							type: "string",
+						},
+						tiffFile: { arg: "-tiff", type: "boolean" },
+						transparentPageColor: {
+							arg: "-transp",
+							type: "boolean",
+						},
+						userPassword: { arg: "-upw", type: "string" },
+					});
+					break;
+				case "pdfToHtml":
+					this.#acceptedOptions.set("pdfToHtml", {
+						complexOutput: { arg: "-c", type: "boolean" },
+						dataUrls: {
+							arg: "-dataurls",
+							type: "boolean",
+							minVersion: "0.75.0",
+						},
+						exchangePdfLinks: { arg: "-p", type: "boolean" },
+						extractHidden: { arg: "-hidden", type: "boolean" },
+						firstPageToConvert: { arg: "-f", type: "number" },
+						fontFullName: { arg: "-fontfullname", type: "boolean" },
+						ignoreImages: { arg: "-i", type: "boolean" },
+						imageFormat: { arg: "-fmt", type: "string" },
+						lastPageToConvert: { arg: "-l", type: "number" },
+						noDrm: { arg: "-nodrm", type: "boolean" },
+						noFrames: { arg: "-noframes", type: "boolean" },
+						noMergeParagraph: { arg: "-nomerge", type: "boolean" },
+						noRoundedCoordinates: {
+							arg: "-noroundcoord",
+							type: "boolean",
+						},
+						outputEncoding: { arg: "-enc", type: "string" },
+						ownerPassword: { arg: "-opw", type: "string" },
+						printVersionInfo: { arg: "-v", type: "boolean" },
+						quiet: { arg: "-q", type: "boolean" },
+						singlePage: { arg: "-s", type: "boolean" },
+						stdout: { arg: "-stdout", type: "boolean" },
+						userPassword: { arg: "-upw", type: "string" },
+						wordBreakThreshold: { arg: "-wbt", type: "number" },
+						xmlOutput: { arg: "-xml", type: "boolean" },
+						zoom: { arg: "-zoom", type: "number" },
+					});
+					break;
+				case "pdfToPpm":
+					this.#acceptedOptions.set("pdfToPpm", {
+						antialiasFonts: { arg: "-aa", type: "string" },
+						antialiasVectors: { arg: "-aaVector", type: "string" },
+						cropBox: { arg: "-cropbox", type: "boolean" },
+						cropHeight: { arg: "-H", type: "number" },
+						cropSize: { arg: "-sz", type: "number" },
+						cropWidth: { arg: "-W", type: "number" },
+						cropXAxis: { arg: "-x", type: "number" },
+						cropYAxis: { arg: "-y", type: "number" },
+						defaultCmykProfile: {
+							arg: "-defaultcmykprofile",
+							type: "string",
+							minVersion: "21.01.0",
+						},
+						defaultGrayProfile: {
+							arg: "-defaultgrayprofile",
+							type: "string",
+							minVersion: "21.01.0",
+						},
+						defaultRgbProfile: {
+							arg: "-defaultrgbprofile",
+							type: "string",
+							minVersion: "21.01.0",
+						},
+						displayProfile: {
+							arg: "-displayprofile",
+							type: "string",
+							minVersion: "0.90.0",
+						},
+						evenPagesOnly: { arg: "-e", type: "boolean" },
+						firstPageToConvert: { arg: "-f", type: "number" },
+						forcePageNumber: {
+							arg: "-forcenum",
+							type: "boolean",
+							minVersion: "0.75.0",
+						},
+						freetype: { arg: "-freetype", type: "string" },
+						grayscaleFile: { arg: "-gray", type: "boolean" },
+						hideAnnotations: {
+							arg: "-hide-annotations",
+							type: "boolean",
+							minVersion: "0.84.0",
+						},
+						jpegFile: { arg: "-jpeg", type: "boolean" },
+						lastPageToConvert: { arg: "-l", type: "number" },
+						monochromeFile: { arg: "-mono", type: "boolean" },
+						oddPagesOnly: { arg: "-o", type: "boolean" },
+						ownerPassword: { arg: "-opw", type: "string" },
+						pngFile: { arg: "-png", type: "boolean" },
+						printProgress: {
+							arg: "-progress",
+							type: "boolean",
+							minVersion: "21.03.0",
+						},
+						printVersionInfo: { arg: "-v", type: "boolean" },
+						quiet: { arg: "-q", type: "boolean" },
+						resolutionXAxis: { arg: "-rx", type: "number" },
+						resolutionXYAxis: { arg: "-r", type: "number" },
+						resolutionYAxis: { arg: "-ry", type: "number" },
+						scalePageTo: { arg: "-scale-to", type: "number" },
+						scalePageToXAxis: {
+							arg: "-scale-to-x",
+							type: "number",
+						},
+						scalePageToYAxis: {
+							arg: "-scale-to-y",
+							type: "number",
+						},
+						separator: {
+							arg: "-sep",
+							type: "string",
+							minVersion: "0.75.0",
+						},
+						singleFile: { arg: "-singlefile", type: "boolean" },
+						thinLineMode: { arg: "-thinlinemode", type: "string" },
+						tiffCompression: {
+							arg: "-tiffcompression",
+							type: "string",
+						},
+						tiffFile: { arg: "-tiff", type: "boolean" },
+						userPassword: { arg: "-upw", type: "string" },
+					});
+					break;
+				case "pdfToPs":
+					this.#acceptedOptions.set("pdfToPs", {
+						antialias: { arg: "-aaRaster", type: "string" },
+						binary: { arg: "-binary", type: "boolean" },
+						defaultCmykProfile: {
+							arg: "-defaultcmykprofile",
+							type: "string",
+							minVersion: "21.01.0",
+						},
+						defaultGrayProfile: {
+							arg: "-defaultgrayprofile",
+							type: "string",
+							minVersion: "21.01.0",
+						},
+						defaultRgbProfile: {
+							arg: "-defaultrgbprofile",
+							type: "string",
+							minVersion: "21.01.0",
+						},
+						duplex: { arg: "-duplex", type: "boolean" },
+						epsFile: { arg: "-eps", type: "boolean" },
+						fillPage: { arg: "-expand", type: "boolean" },
+						firstPageToConvert: { arg: "-f", type: "number" },
+						form: { arg: "-form", type: "boolean" },
+						lastPageToConvert: { arg: "-l", type: "number" },
+						level1: { arg: "-level1", type: "boolean" },
+						level1Sep: { arg: "-level1sep", type: "boolean" },
+						level2: { arg: "-level2", type: "boolean" },
+						level2Sep: { arg: "-level2sep", type: "boolean" },
+						level3: { arg: "-level3", type: "boolean" },
+						level3Sep: { arg: "-level3sep", type: "boolean" },
+						noCenter: { arg: "-nocenter", type: "boolean" },
+						noCrop: { arg: "-nocrop", type: "boolean" },
+						noEmbedCIDFonts: {
+							arg: "-noembcidps",
+							type: "boolean",
+						},
+						noEmbedCIDTrueTypeFonts: {
+							arg: "-noembcidtt",
+							type: "boolean",
+						},
+						noEmbedTrueTypeFonts: {
+							arg: "-noembtt",
+							type: "boolean",
+						},
+						noEmbedType1Fonts: { arg: "-noembt1", type: "boolean" },
+						noShrink: { arg: "-noshrink", type: "boolean" },
+						opi: { arg: "-opi", type: "boolean" },
+						optimizecolorspace: {
+							arg: "-optimizecolorspace",
+							type: "boolean",
+						},
+						originalPageSizes: {
+							arg: "-origpagesizes",
+							type: "boolean",
+						},
+						overprint: { arg: "-overprint", type: "boolean" },
+						ownerPassword: { arg: "-opw", type: "string" },
+						paperHeight: { arg: "-paperh", type: "number" },
+						paperSize: { arg: "-paper", type: "string" },
+						paperWidth: { arg: "-paperw", type: "number" },
+						passfonts: { arg: "-passfonts", type: "boolean" },
+						preload: { arg: "-preload", type: "boolean" },
+						printVersionInfo: { arg: "-v", type: "boolean" },
+						processColorFormat: {
+							arg: "-processcolorformat",
+							type: "string",
+						},
+						processColorProfile: {
+							arg: "-processcolorprofile",
+							type: "string",
+						},
+						quiet: { arg: "-q", type: "boolean" },
+						rasterize: {
+							arg: "-rasterize",
+							type: "string",
+							minVersion: "0.90.0",
+						},
+						resolutionXYAxis: { arg: "-r", type: "number" },
+						userPassword: { arg: "-upw", type: "string" },
+					});
+					break;
+				case "pdfToText":
+					this.#acceptedOptions.set("pdfToText", {
+						boundingBoxXhtml: { arg: "-bbox", type: "boolean" },
+						boundingBoxXhtmlLayout: {
+							arg: "-bbox-layout",
+							type: "boolean",
+						},
+						cropBox: {
+							arg: "-cropbox",
+							type: "boolean",
+							minVersion: "21.03.0",
+						},
+						cropHeight: { arg: "-H", type: "number" },
+						cropWidth: { arg: "-W", type: "number" },
+						cropXAxis: { arg: "-x", type: "number" },
+						cropYAxis: { arg: "-y", type: "number" },
+						eolConvention: { arg: "-eol", type: "string" },
+						firstPageToConvert: { arg: "-f", type: "number" },
+						fixedWidthLayout: { arg: "-fixed", type: "number" },
+						generateHtmlMetaFile: {
+							arg: "-htmlmeta",
+							type: "boolean",
+						},
+						generateTsvFile: { arg: "-tsv", type: "boolean" },
+						lastPageToConvert: { arg: "-l", type: "number" },
+						listEncodingOptions: {
+							arg: "-listenc",
+							type: "boolean",
+						},
+						maintainLayout: { arg: "-layout", type: "boolean" },
+						noDiagonalText: {
+							arg: "-nodiag",
+							type: "boolean",
+							minVersion: "0.80.0",
+						},
+						noPageBreaks: { arg: "-nopgbrk", type: "boolean" },
+						outputEncoding: { arg: "-enc", type: "string" },
+						ownerPassword: { arg: "-opw", type: "string" },
+						printVersionInfo: { arg: "-v", type: "boolean" },
+						quiet: { arg: "-q", type: "boolean" },
+						rawLayout: { arg: "-raw", type: "boolean" },
+						resolution: { arg: "-r", type: "number" },
+						userPassword: { arg: "-upw", type: "string" },
+					});
+					break;
+				case "pdfUnite":
+					this.#acceptedOptions.set("pdfUnite", {
+						printVersionInfo: { arg: "-v", type: "boolean" },
+					});
+					break;
+			}
+		}
+
+		return this.#acceptedOptions.get(functionName);
+	}
+
 	/**
 	 * @author Frazer Smith
 	 * @description Embeds files (attachments) into a PDF file.
@@ -170,19 +638,11 @@ class Poppler {
 	 * @returns {Promise<string>} A promise that resolves with a stdout string, or rejects with an `Error` object.
 	 */
 	async pdfAttach(file, fileToAttach, outputFile, options = {}) {
-		/** @type {PopplerAcceptedOptions} */
-		const acceptedOptions = {
-			printVersionInfo: { arg: "-v", type: "boolean" },
-			replace: { arg: "-replace", type: "boolean" },
-		};
-
+		const acceptedOptions = this.#getAcceptedOptions("pdfAttach");
 		const args = parseOptions(acceptedOptions, options);
 		args.push(file, fileToAttach, outputFile);
 
-		const { stdout } = await execFileAsync(
-			pathResolve(this.#popplerPath, "pdfattach"),
-			args
-		);
+		const { stdout } = await execFileAsync(this.#pdfAttachBin, args);
 		return stdout;
 	}
 
@@ -213,30 +673,11 @@ class Poppler {
 	 * @returns {Promise<string>} A promise that resolves with a stdout string, or rejects with an `Error` object.
 	 */
 	async pdfDetach(file, options = {}) {
-		/** @type {PopplerAcceptedOptions} */
-		const acceptedOptions = {
-			listEmbedded: { arg: "-list", type: "boolean" },
-			outputEncoding: { arg: "-enc", type: "string" },
-			outputPath: { arg: "-o", type: "string" },
-			ownerPassword: { arg: "-opw", type: "string" },
-			printVersionInfo: { arg: "-v", type: "boolean" },
-			saveAllFiles: { arg: "-saveall", type: "boolean" },
-			saveFile: {
-				arg: "-savefile",
-				type: "string",
-				minVersion: "0.86.0",
-			},
-			saveSpecificFile: { arg: "-save", type: "number" },
-			userPassword: { arg: "-upw", type: "string" },
-		};
-
+		const acceptedOptions = this.#getAcceptedOptions("pdfDetach");
 		const args = parseOptions(acceptedOptions, options);
 		args.push(file);
 
-		const { stdout } = await execFileAsync(
-			pathResolve(this.#popplerPath, "pdfdetach"),
-			args
-		);
+		const { stdout } = await execFileAsync(this.#pdfDetachBin, args);
 		return stdout;
 	}
 
@@ -255,33 +696,14 @@ class Poppler {
 	 * @returns {Promise<string>} A promise that resolves with a stdout string, or rejects with an `Error` object.
 	 */
 	async pdfFonts(file, options = {}) {
-		/** @type {PopplerAcceptedOptions} */
-		const acceptedOptions = {
-			firstPageToExamine: { arg: "-f", type: "number" },
-			lastPageToExamine: { arg: "-l", type: "number" },
-			listSubstitutes: { arg: "-subst", type: "boolean" },
-			ownerPassword: { arg: "-opw", type: "string" },
-			printVersionInfo: { arg: "-v", type: "boolean" },
-			userPassword: { arg: "-upw", type: "string" },
-		};
-
-		const { stderr } = await execFileAsync(
-			pathResolve(this.#popplerPath, "pdffonts"),
-			["-v"]
-		);
-
-		// @ts-ignore: parseOptions checks if falsy
-		const versionInfo = POPPLER_VERSION_REG.exec(stderr)[1];
-
+		const acceptedOptions = this.#getAcceptedOptions("pdfFonts");
+		const versionInfo = await this.#getVersion(this.#pdfFontsBin);
 		const args = parseOptions(acceptedOptions, options, versionInfo);
 
 		return new Promise((resolve, reject) => {
 			args.push(Buffer.isBuffer(file) ? "-" : file);
 
-			const child = spawn(
-				pathResolve(this.#popplerPath, "pdffonts"),
-				args
-			);
+			const child = spawn(this.#pdfFontsBin, args);
 
 			if (Buffer.isBuffer(file)) {
 				child.stdin.write(file);
@@ -347,31 +769,8 @@ class Poppler {
 	 * @returns {Promise<string>} A promise that resolves with a stdout string, or rejects with an `Error` object.
 	 */
 	async pdfImages(file, outputPrefix, options = {}) {
-		/** @type {PopplerAcceptedOptions} */
-		const acceptedOptions = {
-			allFiles: { arg: "-all", type: "boolean" },
-			ccittFile: { arg: "-ccitt", type: "boolean" },
-			firstPageToConvert: { arg: "-f", type: "number" },
-			lastPageToConvert: { arg: "-l", type: "number" },
-			jbig2File: { arg: "-jbig2", type: "boolean" },
-			jpeg2000File: { arg: "-jp2", type: "boolean" },
-			jpegFile: { arg: "-j", type: "boolean" },
-			list: { arg: "-list", type: "boolean" },
-			ownerPassword: { arg: "-opw", type: "string" },
-			pngFile: { arg: "-png", type: "boolean" },
-			printVersionInfo: { arg: "-v", type: "boolean" },
-			tiffFile: { arg: "-tiff", type: "boolean" },
-			userPassword: { arg: "-upw", type: "string" },
-		};
-
-		const { stderr } = await execFileAsync(
-			pathResolve(this.#popplerPath, "pdfimages"),
-			["-v"]
-		);
-
-		// @ts-ignore: parseOptions checks if falsy
-		const versionInfo = POPPLER_VERSION_REG.exec(stderr)[1];
-
+		const acceptedOptions = this.#getAcceptedOptions("pdfImages");
+		const versionInfo = await this.#getVersion(this.#pdfImagesBin);
 		const args = parseOptions(acceptedOptions, options, versionInfo);
 
 		return new Promise((resolve, reject) => {
@@ -381,10 +780,7 @@ class Poppler {
 				args.push(outputPrefix);
 			}
 
-			const child = spawn(
-				pathResolve(this.#popplerPath, "pdfimages"),
-				args
-			);
+			const child = spawn(this.#pdfImagesBin, args);
 
 			if (Buffer.isBuffer(file)) {
 				child.stdin.write(file);
@@ -460,35 +856,8 @@ class Poppler {
 	 * `options.printAsJson` is `true`, or rejects with an `Error` object.
 	 */
 	async pdfInfo(file, options = {}) {
-		/** @type {PopplerAcceptedOptions} */
-		const acceptedOptions = {
-			firstPageToConvert: { arg: "-f", type: "number" },
-			lastPageToConvert: { arg: "-l", type: "number" },
-			listEncodingOptions: { arg: "-listenc", type: "boolean" },
-			outputEncoding: { arg: "-enc", type: "string" },
-			ownerPassword: { arg: "-opw", type: "string" },
-			printAsJson: { arg: "", type: "boolean" },
-			printBoundingBoxes: { arg: "-box", type: "boolean" },
-			printDocStruct: { arg: "-struct", type: "boolean" },
-			printDocStructText: { arg: "-struct-text", type: "boolean" },
-			printIsoDates: { arg: "-isodates", type: "boolean" },
-			printJS: { arg: "-js", type: "boolean" },
-			printMetadata: { arg: "-meta", type: "boolean" },
-			printNamedDests: { arg: "-dests", type: "boolean" },
-			printRawDates: { arg: "-rawdates", type: "boolean" },
-			printUrls: { arg: "-url", type: "boolean", minVersion: "21.11.0" },
-			printVersionInfo: { arg: "-v", type: "boolean" },
-			userPassword: { arg: "-upw", type: "string" },
-		};
-
-		const { stderr } = await execFileAsync(
-			pathResolve(this.#popplerPath, "pdfinfo"),
-			["-v"]
-		);
-
-		// @ts-ignore: parseOptions checks if falsy
-		const versionInfo = POPPLER_VERSION_REG.exec(stderr)[1];
-
+		const acceptedOptions = this.#getAcceptedOptions("pdfInfo");
+		const versionInfo = await this.#getVersion(this.#pdfInfoBin);
 		const args = parseOptions(acceptedOptions, options, versionInfo);
 
 		// Fetch file size if stdin input is a Buffer, as Poppler omits it
@@ -503,10 +872,7 @@ class Poppler {
 				args.push(file);
 			}
 
-			const child = spawn(
-				pathResolve(this.#popplerPath, "pdfinfo"),
-				args
-			);
+			const child = spawn(this.#pdfInfoBin, args);
 
 			if (Buffer.isBuffer(file)) {
 				child.stdin.write(file);
@@ -587,28 +953,12 @@ class Poppler {
 	 * @returns {Promise<string>} A promise that resolves with a stdout string, or rejects with an `Error` object.
 	 */
 	async pdfSeparate(file, outputPattern, options = {}) {
-		/** @type {PopplerAcceptedOptions} */
-		const acceptedOptions = {
-			firstPageToExtract: { arg: "-f", type: "number" },
-			lastPageToExtract: { arg: "-l", type: "number" },
-			printVersionInfo: { arg: "-v", type: "boolean" },
-		};
-
-		const { stderr } = await execFileAsync(
-			pathResolve(this.#popplerPath, "pdfseparate"),
-			["-v"]
-		);
-
-		// @ts-ignore: parseOptions checks if falsy
-		const versionInfo = POPPLER_VERSION_REG.exec(stderr)[1];
-
+		const acceptedOptions = this.#getAcceptedOptions("pdfSeparate");
+		const versionInfo = await this.#getVersion(this.#pdfSeparateBin);
 		const args = parseOptions(acceptedOptions, options, versionInfo);
 		args.push(file, outputPattern);
 
-		const { stdout } = await execFileAsync(
-			pathResolve(this.#popplerPath, "pdfseparate"),
-			args
-		);
+		const { stdout } = await execFileAsync(this.#pdfSeparateBin, args);
 		return stdout;
 	}
 
@@ -720,130 +1070,59 @@ class Poppler {
 	 * @returns {Promise<string>} A promise that resolves with a stdout string, or rejects with an `Error` object.
 	 */
 	async pdfToCairo(file, outputFile, options = {}) {
-		/** @type {PopplerAcceptedOptions} */
-		const acceptedOptions = {
-			antialias: { arg: "-antialias", type: "string" },
-			cropBox: { arg: "-cropbox", type: "boolean" },
-			cropHeight: { arg: "-H", type: "number" },
-			cropSize: { arg: "-sz", type: "number" },
-			cropWidth: { arg: "-W", type: "number" },
-			cropXAxis: { arg: "-x", type: "number" },
-			cropYAxis: { arg: "-y", type: "number" },
-			duplex: { arg: "-duplex", type: "boolean" },
-			epsFile: { arg: "-eps", type: "boolean" },
-			evenPagesOnly: { arg: "-e", type: "boolean" },
-			fillPage: { arg: "-expand", type: "boolean" },
-			firstPageToConvert: { arg: "-f", type: "number" },
-			grayscaleFile: { arg: "-gray", type: "boolean" },
-			iccFile: { arg: "-icc", type: "string" },
-			jpegFile: { arg: "-jpeg", type: "boolean" },
-			jpegOptions: { arg: "-jpegopt", type: "string" },
-			lastPageToConvert: { arg: "-l", type: "number" },
-			monochromeFile: { arg: "-mono", type: "boolean" },
-			noCenter: { arg: "-nocenter", type: "boolean" },
-			noCrop: { arg: "-nocrop", type: "boolean" },
-			noShrink: { arg: "-noshrink", type: "boolean" },
-			oddPagesOnly: { arg: "-o", type: "boolean" },
-			originalPageSizes: { arg: "-origpagesizes", type: "boolean" },
-			ownerPassword: { arg: "-opw", type: "string" },
-			paperHeight: { arg: "-paperh", type: "number" },
-			paperSize: { arg: "-paper", type: "string" },
-			paperWidth: { arg: "-paperw", type: "number" },
-			pdfFile: { arg: "-pdf", type: "boolean" },
-			pngFile: { arg: "-png", type: "boolean" },
-			printDocStruct: {
-				arg: "-struct",
-				type: "boolean",
-				minVersion: "23.11.0",
-			},
-			printVersionInfo: { arg: "-v", type: "boolean" },
-			psFile: { arg: "-ps", type: "boolean" },
-			psLevel2: { arg: "-level2", type: "boolean" },
-			psLevel3: { arg: "-level3", type: "boolean" },
-			quiet: { arg: "-q", type: "boolean" },
-			resolutionXAxis: { arg: "-rx", type: "number" },
-			resolutionXYAxis: { arg: "-r", type: "number" },
-			resolutionYAxis: { arg: "-ry", type: "number" },
-			scalePageTo: { arg: "-scale-to", type: "number" },
-			scalePageToXAxis: { arg: "-scale-to-x", type: "number" },
-			scalePageToYAxis: { arg: "-scale-to-y", type: "number" },
-			singleFile: { arg: "-singlefile", type: "boolean" },
-			svgFile: { arg: "-svg", type: "boolean" },
-			tiffCompression: { arg: "-tiffcompression", type: "string" },
-			tiffFile: { arg: "-tiff", type: "boolean" },
-			transparentPageColor: { arg: "-transp", type: "boolean" },
-			userPassword: { arg: "-upw", type: "string" },
-		};
-
-		try {
-			const { stderr } = await execFileAsync(
-				pathResolve(this.#popplerPath, "pdftocairo"),
-				["-v"]
-			);
-
-			// @ts-ignore: parseOptions checks if falsy
-			const versionInfo = POPPLER_VERSION_REG.exec(stderr)[1];
-
-			const args = parseOptions(acceptedOptions, options, versionInfo);
+		const acceptedOptions = this.#getAcceptedOptions("pdfToCairo");
+		const versionInfo = await this.#getVersion(this.#pdfToCairoBin);
+		const args = parseOptions(acceptedOptions, options, versionInfo);
 
-			return new Promise((resolve, reject) => {
-				args.push(
-					Buffer.isBuffer(file) ? "-" : file,
-					outputFile || "-"
-				);
+		return new Promise((resolve, reject) => {
+			args.push(Buffer.isBuffer(file) ? "-" : file, outputFile || "-");
 
-				const child = spawn(
-					pathResolve(this.#popplerPath, "pdftocairo"),
-					args
-				);
+			const child = spawn(this.#pdfToCairoBin, args);
 
-				if (
-					outputFile === undefined &&
-					args.some((arg) => ["-singlefile", "-pdf"].includes(arg))
-				) {
-					child.stdout.setEncoding("binary");
-				}
+			if (
+				outputFile === undefined &&
+				args.some((arg) => ["-singlefile", "-pdf"].includes(arg))
+			) {
+				child.stdout.setEncoding("binary");
+			}
 
-				if (Buffer.isBuffer(file)) {
-					child.stdin.write(file);
-					child.stdin.end();
-				}
+			if (Buffer.isBuffer(file)) {
+				child.stdin.write(file);
+				child.stdin.end();
+			}
 
-				let stdOut = "";
-				let stdErr = "";
+			let stdOut = "";
+			let stdErr = "";
 
-				child.stdout.on("data", (data) => {
-					stdOut += data;
-				});
+			child.stdout.on("data", (data) => {
+				stdOut += data;
+			});
 
-				child.stderr.on("data", (data) => {
-					stdErr += data;
-				});
+			child.stderr.on("data", (data) => {
+				stdErr += data;
+			});
 
-				child.on("close", (code) => {
-					/* istanbul ignore else */
-					if (stdOut !== "") {
-						resolve(stdOut.trim());
-					} else if (code === 0) {
-						resolve(ERROR_MSGS[code]);
-					} else if (stdErr !== "") {
-						reject(new Error(stdErr.trim()));
-					} else {
-						reject(
-							new Error(
-								// @ts-ignore: Second operand used if code is not in ERROR_MSGS
-								ERROR_MSGS[code] ||
-									`pdftocairo ${args.join(
-										" "
-									)} exited with code ${code}`
-							)
-						);
-					}
-				});
+			child.on("close", (code) => {
+				/* istanbul ignore else */
+				if (stdOut !== "") {
+					resolve(stdOut.trim());
+				} else if (code === 0) {
+					resolve(ERROR_MSGS[code]);
+				} else if (stdErr !== "") {
+					reject(new Error(stdErr.trim()));
+				} else {
+					reject(
+						new Error(
+							// @ts-ignore: Second operand used if code is not in ERROR_MSGS
+							ERROR_MSGS[code] ||
+								`pdftocairo ${args.join(
+									" "
+								)} exited with code ${code}`
+						)
+					);
+				}
 			});
-		} catch (err) {
-			return Promise.reject(err);
-		}
+		});
 	}
 
 	/**
@@ -887,45 +1166,8 @@ class Poppler {
 	 * @returns {Promise<string>} A promise that resolves with a stdout string, or rejects with an `Error` object.
 	 */
 	async pdfToHtml(file, outputFile, options = {}) {
-		/** @type {PopplerAcceptedOptions} */
-		const acceptedOptions = {
-			complexOutput: { arg: "-c", type: "boolean" },
-			dataUrls: {
-				arg: "-dataurls",
-				type: "boolean",
-				minVersion: "0.75.0",
-			},
-			exchangePdfLinks: { arg: "-p", type: "boolean" },
-			extractHidden: { arg: "-hidden", type: "boolean" },
-			firstPageToConvert: { arg: "-f", type: "number" },
-			fontFullName: { arg: "-fontfullname", type: "boolean" },
-			ignoreImages: { arg: "-i", type: "boolean" },
-			imageFormat: { arg: "-fmt", type: "string" },
-			lastPageToConvert: { arg: "-l", type: "number" },
-			noDrm: { arg: "-nodrm", type: "boolean" },
-			noFrames: { arg: "-noframes", type: "boolean" },
-			noMergeParagraph: { arg: "-nomerge", type: "boolean" },
-			noRoundedCoordinates: { arg: "-noroundcoord", type: "boolean" },
-			outputEncoding: { arg: "-enc", type: "string" },
-			ownerPassword: { arg: "-opw", type: "string" },
-			printVersionInfo: { arg: "-v", type: "boolean" },
-			quiet: { arg: "-q", type: "boolean" },
-			singlePage: { arg: "-s", type: "boolean" },
-			stdout: { arg: "-stdout", type: "boolean" },
-			userPassword: { arg: "-upw", type: "string" },
-			wordBreakThreshold: { arg: "-wbt", type: "number" },
-			xmlOutput: { arg: "-xml", type: "boolean" },
-			zoom: { arg: "-zoom", type: "number" },
-		};
-
-		const { stderr } = await execFileAsync(
-			pathResolve(this.#popplerPath, "pdftohtml"),
-			["-v"]
-		);
-
-		// @ts-ignore: parseOptions checks if falsy
-		const versionInfo = POPPLER_VERSION_REG.exec(stderr)[1];
-
+		const acceptedOptions = this.#getAcceptedOptions("pdfToHtml");
+		const versionInfo = await this.#getVersion(this.#pdfToHtmlBin);
 		const args = parseOptions(acceptedOptions, options, versionInfo);
 
 		return new Promise((resolve, reject) => {
@@ -935,10 +1177,7 @@ class Poppler {
 				args.push(outputFile);
 			}
 
-			const child = spawn(
-				pathResolve(this.#popplerPath, "pdftohtml"),
-				args
-			);
+			const child = spawn(this.#pdfToHtmlBin, args);
 
 			if (Buffer.isBuffer(file)) {
 				child.stdin.write(file);
@@ -1042,94 +1281,14 @@ class Poppler {
 	 * @returns {Promise<string>} A promise that resolves with a stdout string, or rejects with an `Error` object.
 	 */
 	async pdfToPpm(file, outputPath, options = {}) {
-		/** @type {PopplerAcceptedOptions} */
-		const acceptedOptions = {
-			antialiasFonts: { arg: "-aa", type: "string" },
-			antialiasVectors: { arg: "-aaVector", type: "string" },
-			cropBox: { arg: "-cropbox", type: "boolean" },
-			cropHeight: { arg: "-H", type: "number" },
-			cropSize: { arg: "-sz", type: "number" },
-			cropWidth: { arg: "-W", type: "number" },
-			cropXAxis: { arg: "-x", type: "number" },
-			cropYAxis: { arg: "-y", type: "number" },
-			defaultCmykProfile: {
-				arg: "-defaultcmykprofile",
-				type: "string",
-				minVersion: "21.01.0",
-			},
-			defaultGrayProfile: {
-				arg: "-defaultgrayprofile",
-				type: "string",
-				minVersion: "21.01.0",
-			},
-			defaultRgbProfile: {
-				arg: "-defaultrgbprofile",
-				type: "string",
-				minVersion: "21.01.0",
-			},
-			displayProfile: {
-				arg: "-displayprofile",
-				type: "string",
-				minVersion: "0.90.0",
-			},
-			evenPagesOnly: { arg: "-e", type: "boolean" },
-			firstPageToConvert: { arg: "-f", type: "number" },
-			forcePageNumber: {
-				arg: "-forcenum",
-				type: "boolean",
-				minVersion: "0.75.0",
-			},
-			freetype: { arg: "-freetype", type: "string" },
-			grayscaleFile: { arg: "-gray", type: "boolean" },
-			hideAnnotations: {
-				arg: "-hide-annotations",
-				type: "boolean",
-				minVersion: "0.84.0",
-			},
-			jpegFile: { arg: "-jpeg", type: "boolean" },
-			lastPageToConvert: { arg: "-l", type: "number" },
-			monochromeFile: { arg: "-mono", type: "boolean" },
-			oddPagesOnly: { arg: "-o", type: "boolean" },
-			ownerPassword: { arg: "-opw", type: "string" },
-			pngFile: { arg: "-png", type: "boolean" },
-			printProgress: {
-				arg: "-progress",
-				type: "boolean",
-				minVersion: "21.03.0",
-			},
-			printVersionInfo: { arg: "-v", type: "boolean" },
-			quiet: { arg: "-q", type: "boolean" },
-			resolutionXAxis: { arg: "-rx", type: "number" },
-			resolutionXYAxis: { arg: "-r", type: "number" },
-			resolutionYAxis: { arg: "-ry", type: "number" },
-			scalePageTo: { arg: "-scale-to", type: "number" },
-			scalePageToXAxis: { arg: "-scale-to-x", type: "number" },
-			scalePageToYAxis: { arg: "-scale-to-y", type: "number" },
-			separator: { arg: "-sep", type: "string", minVersion: "0.75.0" },
-			singleFile: { arg: "-singlefile", type: "boolean" },
-			thinLineMode: { arg: "-thinlinemode", type: "string" },
-			tiffCompression: { arg: "-tiffcompression", type: "string" },
-			tiffFile: { arg: "-tiff", type: "boolean" },
-			userPassword: { arg: "-upw", type: "string" },
-		};
-
-		const { stderr } = await execFileAsync(
-			pathResolve(this.#popplerPath, "pdftoppm"),
-			["-v"]
-		);
-
-		// @ts-ignore: parseOptions checks if falsy
-		const versionInfo = POPPLER_VERSION_REG.exec(stderr)[1];
-
+		const acceptedOptions = this.#getAcceptedOptions("pdfToPpm");
+		const versionInfo = await this.#getVersion(this.#pdfToPpmBin);
 		const args = parseOptions(acceptedOptions, options, versionInfo);
 
 		return new Promise((resolve, reject) => {
 			args.push(Buffer.isBuffer(file) ? "-" : file, outputPath);
 
-			const child = spawn(
-				pathResolve(this.#popplerPath, "pdftoppm"),
-				args
-			);
+			const child = spawn(this.#pdfToPpmBin, args);
 
 			if (Buffer.isBuffer(file)) {
 				child.stdin.write(file);
@@ -1273,93 +1432,14 @@ class Poppler {
 	 * @returns {Promise<string>} A promise that resolves with a stdout string, or rejects with an `Error` object.
 	 */
 	async pdfToPs(file, outputFile, options = {}) {
-		/** @type {PopplerAcceptedOptions} */
-		const acceptedOptions = {
-			antialias: { arg: "-aaRaster", type: "string" },
-			binary: { arg: "-binary", type: "boolean" },
-			defaultCmykProfile: {
-				arg: "-defaultcmykprofile",
-				type: "string",
-				minVersion: "21.01.0",
-			},
-			defaultGrayProfile: {
-				arg: "-defaultgrayprofile",
-				type: "string",
-				minVersion: "21.01.0",
-			},
-			defaultRgbProfile: {
-				arg: "-defaultrgbprofile",
-				type: "string",
-				minVersion: "21.01.0",
-			},
-			duplex: { arg: "-duplex", type: "boolean" },
-			epsFile: { arg: "-eps", type: "boolean" },
-			fillPage: { arg: "-expand", type: "boolean" },
-			firstPageToConvert: { arg: "-f", type: "number" },
-			form: { arg: "-form", type: "boolean" },
-			lastPageToConvert: { arg: "-l", type: "number" },
-			level1: { arg: "-level1", type: "boolean" },
-			level1Sep: { arg: "-level1sep", type: "boolean" },
-			level2: { arg: "-level2", type: "boolean" },
-			level2Sep: { arg: "-level2sep", type: "boolean" },
-			level3: { arg: "-level3", type: "boolean" },
-			level3Sep: { arg: "-level3sep", type: "boolean" },
-			noCenter: { arg: "-nocenter", type: "boolean" },
-			noCrop: { arg: "-nocrop", type: "boolean" },
-			noEmbedCIDFonts: { arg: "-noembcidps", type: "boolean" },
-			noEmbedCIDTrueTypeFonts: {
-				arg: "-noembcidtt",
-				type: "boolean",
-			},
-			noEmbedTrueTypeFonts: { arg: "-noembtt", type: "boolean" },
-			noEmbedType1Fonts: { arg: "-noembt1", type: "boolean" },
-			noShrink: { arg: "-noshrink", type: "boolean" },
-			opi: { arg: "-opi", type: "boolean" },
-			optimizecolorspace: {
-				arg: "-optimizecolorspace",
-				type: "boolean",
-			},
-			originalPageSizes: { arg: "-origpagesizes", type: "boolean" },
-			overprint: { arg: "-overprint", type: "boolean" },
-			ownerPassword: { arg: "-opw", type: "string" },
-			paperHeight: { arg: "-paperh", type: "number" },
-			paperSize: { arg: "-paper", type: "string" },
-			paperWidth: { arg: "-paperw", type: "number" },
-			passfonts: { arg: "-passfonts", type: "boolean" },
-			preload: { arg: "-preload", type: "boolean" },
-			printVersionInfo: { arg: "-v", type: "boolean" },
-			processColorFormat: { arg: "-processcolorformat", type: "string" },
-			processColorProfile: {
-				arg: "-processcolorprofile",
-				type: "string",
-			},
-			quiet: { arg: "-q", type: "boolean" },
-			rasterize: {
-				arg: "-rasterize",
-				type: "string",
-				minVersion: "0.90.0",
-			},
-			resolutionXYAxis: { arg: "-r", type: "number" },
-			userPassword: { arg: "-upw", type: "string" },
-		};
-
-		const { stderr } = await execFileAsync(
-			pathResolve(this.#popplerPath, "pdftops"),
-			["-v"]
-		);
-
-		// @ts-ignore: parseOptions checks if falsy
-		const versionInfo = POPPLER_VERSION_REG.exec(stderr)[1];
-
+		const acceptedOptions = this.#getAcceptedOptions("pdfToPs");
+		const versionInfo = await this.#getVersion(this.#pdfToPsBin);
 		const args = parseOptions(acceptedOptions, options, versionInfo);
 
 		return new Promise((resolve, reject) => {
 			args.push(Buffer.isBuffer(file) ? "-" : file, outputFile || "-");
 
-			const child = spawn(
-				pathResolve(this.#popplerPath, "pdftops"),
-				args
-			);
+			const child = spawn(this.#pdfToPsBin, args);
 
 			if (Buffer.isBuffer(file)) {
 				child.stdin.write(file);
@@ -1449,62 +1529,14 @@ class Poppler {
 	 * @returns {Promise<string>} A promise that resolves with a stdout string, or rejects with an `Error` object.
 	 */
 	async pdfToText(file, outputFile, options = {}) {
-		/** @type {PopplerAcceptedOptions} */
-		const acceptedOptions = {
-			boundingBoxXhtml: { arg: "-bbox", type: "boolean" },
-			boundingBoxXhtmlLayout: {
-				arg: "-bbox-layout",
-				type: "boolean",
-			},
-			cropBox: {
-				arg: "-cropbox",
-				type: "boolean",
-				minVersion: "21.03.0",
-			},
-			cropHeight: { arg: "-H", type: "number" },
-			cropWidth: { arg: "-W", type: "number" },
-			cropXAxis: { arg: "-x", type: "number" },
-			cropYAxis: { arg: "-y", type: "number" },
-			eolConvention: { arg: "-eol", type: "string" },
-			firstPageToConvert: { arg: "-f", type: "number" },
-			fixedWidthLayout: { arg: "-fixed", type: "number" },
-			generateHtmlMetaFile: { arg: "-htmlmeta", type: "boolean" },
-			generateTsvFile: { arg: "-tsv", type: "boolean" },
-			lastPageToConvert: { arg: "-l", type: "number" },
-			listEncodingOptions: { arg: "-listenc", type: "boolean" },
-			maintainLayout: { arg: "-layout", type: "boolean" },
-			noDiagonalText: {
-				arg: "-nodiag",
-				type: "boolean",
-				minVersion: "0.80.0",
-			},
-			noPageBreaks: { arg: "-nopgbrk", type: "boolean" },
-			outputEncoding: { arg: "-enc", type: "string" },
-			ownerPassword: { arg: "-opw", type: "string" },
-			printVersionInfo: { arg: "-v", type: "boolean" },
-			quiet: { arg: "-q", type: "boolean" },
-			rawLayout: { arg: "-raw", type: "boolean" },
-			resolution: { arg: "-r", type: "number" },
-			userPassword: { arg: "-upw", type: "string" },
-		};
-
-		const { stderr } = await execFileAsync(
-			pathResolve(this.#popplerPath, "pdftotext"),
-			["-v"]
-		);
-
-		// @ts-ignore: parseOptions checks if falsy
-		const versionInfo = POPPLER_VERSION_REG.exec(stderr)[1];
-
+		const acceptedOptions = this.#getAcceptedOptions("pdfToText");
+		const versionInfo = await this.#getVersion(this.#pdfToTextBin);
 		const args = parseOptions(acceptedOptions, options, versionInfo);
 
 		return new Promise((resolve, reject) => {
 			args.push(Buffer.isBuffer(file) ? "-" : file, outputFile || "-");
 
-			const child = spawn(
-				pathResolve(this.#popplerPath, "pdftotext"),
-				args
-			);
+			const child = spawn(this.#pdfToTextBin, args);
 
 			if (Buffer.isBuffer(file)) {
 				child.stdin.write(file);
@@ -1557,26 +1589,12 @@ class Poppler {
 	 * @returns {Promise<string>} A promise that resolves with a stdout string, or rejects with an `Error` object.
 	 */
 	async pdfUnite(files, outputFile, options = {}) {
-		/** @type {PopplerAcceptedOptions} */
-		const acceptedOptions = {
-			printVersionInfo: { arg: "-v", type: "boolean" },
-		};
-
-		const { stderr } = await execFileAsync(
-			pathResolve(this.#popplerPath, "pdfunite"),
-			["-v"]
-		);
-
-		// @ts-ignore: parseOptions checks if falsy
-		const versionInfo = POPPLER_VERSION_REG.exec(stderr)[1];
-
+		const acceptedOptions = this.#getAcceptedOptions("pdfUnite");
+		const versionInfo = await this.#getVersion(this.#pdfUniteBin);
 		const args = parseOptions(acceptedOptions, options, versionInfo);
 		args.push(...files, outputFile);
 
-		const { stdout } = await execFileAsync(
-			pathResolve(this.#popplerPath, "pdfunite"),
-			args
-		);
+		const { stdout } = await execFileAsync(this.#pdfUniteBin, args);
 		return stdout;
 	}
 }