single-file-cli 2.1.1 → 2.1.2

package/compile.sh

@@ -12,11 +12,11 @@ cp -R ./resources "$stage_dir/resources"
 mkdir -p "$dist_dir"
 cd "$stage_dir"
 
-deno compile --allow-read --allow-write --allow-net --allow-env --allow-run --ext=js --output="$dist_dir/single-file-aarch64-apple-darwin" --target=aarch64-apple-darwin ./single-file
-deno compile --allow-read --allow-write --allow-net --allow-env --allow-run --ext=js --output="$dist_dir/single-file-x86_64-apple-darwin" --target=x86_64-apple-darwin ./single-file
-deno compile --allow-read --allow-write --allow-net --allow-env --allow-run --ext=js --output="$dist_dir/single-file-x86_64-linux" --target=x86_64-unknown-linux-gnu ./single-file
-deno compile --allow-read --allow-write --allow-net --allow-env --allow-run --ext=js --output="$dist_dir/single-file-aarch64-linux" --target=aarch64-unknown-linux-gnu ./single-file
-deno compile --allow-all --ext=js --output="$dist_dir/single-file.exe" --target=x86_64-pc-windows-msvc --icon=./resources/single-file.ico ./single-file
+deno compile --minimum-dependency-age=0 --allow-read --allow-write --allow-net --allow-env --allow-run --ext=js --output="$dist_dir/single-file-aarch64-apple-darwin" --target=aarch64-apple-darwin ./single-file
+deno compile --minimum-dependency-age=0 --allow-read --allow-write --allow-net --allow-env --allow-run --ext=js --output="$dist_dir/single-file-x86_64-apple-darwin" --target=x86_64-apple-darwin ./single-file
+deno compile --minimum-dependency-age=0 --allow-read --allow-write --allow-net --allow-env --allow-run --ext=js --output="$dist_dir/single-file-x86_64-linux" --target=x86_64-unknown-linux-gnu ./single-file
+deno compile --minimum-dependency-age=0 --allow-read --allow-write --allow-net --allow-env --allow-run --ext=js --output="$dist_dir/single-file-aarch64-linux" --target=aarch64-unknown-linux-gnu ./single-file
+deno compile --minimum-dependency-age=0 --allow-all --ext=js --output="$dist_dir/single-file.exe" --target=x86_64-pc-windows-msvc --icon=./resources/single-file.ico ./single-file
 
 cd - > /dev/null
 

package/deno.json

@@ -1,12 +1,12 @@
 {
   "name": "@single-file/single-file-cli",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "description": "SingleFile CLI",
   "exports": {
     ".": "./single-file-cli-api.js"
   },
   "imports": {
-    "simple-cdp": "jsr:@simple-cdp/simple-cdp@^1.10.0",
-    "path": "jsr:@std/path@^1.1.2"
+    "simple-cdp": "jsr:@simple-cdp/simple-cdp@^1.10.1",
+    "path": "jsr:@std/path@^1.1.6"
   }
 }

package/deno.lock

@@ -1,17 +1,17 @@
 {
   "version": "5",
   "specifiers": {
-    "jsr:@simple-cdp/simple-cdp@^1.10.0": "1.10.0",
+    "jsr:@simple-cdp/simple-cdp@^1.10.1": "1.10.1",
     "jsr:@std/internal@^1.0.14": "1.0.14",
-    "jsr:@std/path@^1.1.2": "1.1.6",
-    "npm:@eslint/js@^9.39.1": "9.39.5",
-    "npm:esbuild@~0.27.4": "0.27.7",
+    "jsr:@std/path@^1.1.6": "1.1.6",
+    "npm:@eslint/js@^9.39.5": "9.39.5",
+    "npm:esbuild@~0.27.7": "0.27.7",
     "npm:eslint@^10.8.1": "10.8.1",
-    "npm:simple-cdp@^1.10.0": "1.10.0"
+    "npm:simple-cdp@^1.10.1": "1.10.1"
   },
   "jsr": {
-    "@simple-cdp/simple-cdp@1.10.0": {
-      "integrity": "3f8c91e22598c3e15a680f14ee3d2aa174c21b9b528caad5ec8552e3df0c3897"
+    "@simple-cdp/simple-cdp@1.10.1": {
+      "integrity": "33c686242e812a53d13ba7fcebd18ed81b4685fb02da37c2ee6ed9a5123f9b8c"
     },
     "@std/internal@1.0.14": {
       "integrity": "291516b3d4c35024d6ffbc0a9df5bf4c64116e05b50012cf846710152d2ffdf7"
@@ -527,8 +527,8 @@
     "shebang-regex@3.0.0": {
       "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="
     },
-    "simple-cdp@1.10.0": {
-      "integrity": "sha512-UXDAaiges1GqNKtBy39po+CD4hXDJxQEDtR1GF9bK2J9MNN0epTo2GpoSmEc8o5ofW8dutpHafBjowEchSNgig=="
+    "simple-cdp@1.10.1": {
+      "integrity": "sha512-svGX76zc2MY2ErGAWGb9NWP9aF5XQgDyx00iqAGCgRi1qQd5MQjtBwuC7mcktliFH263gpHdnHicfsB+n7Vnyg=="
     },
     "type-check@0.4.0": {
       "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
@@ -558,15 +558,15 @@
   },
   "workspace": {
     "dependencies": [
-      "jsr:@simple-cdp/simple-cdp@^1.10.0",
-      "jsr:@std/path@^1.1.2"
+      "jsr:@simple-cdp/simple-cdp@^1.10.1",
+      "jsr:@std/path@^1.1.6"
     ],
     "packageJson": {
       "dependencies": [
-        "npm:@eslint/js@^9.39.1",
-        "npm:esbuild@~0.27.4",
+        "npm:@eslint/js@^9.39.5",
+        "npm:esbuild@~0.27.7",
         "npm:eslint@^10.8.1",
-        "npm:simple-cdp@^1.10.0"
+        "npm:simple-cdp@^1.10.1"
       ]
     }
   }

package/lib/browser.js

@@ -80,8 +80,13 @@ async function launchBrowser(options = {}, indexPath = 0) {
 	} catch (error) {
 		await remove(profilePath, { recursive: true }).catch(() => { });
 		profilePath = undefined;
-		if (error instanceof errors.NotFound && indexPath + 1 < BROWSER_PATHS[build.os].length) {
-			return launchBrowser(options, indexPath + 1);
+		if (error instanceof errors.NotFound) {
+			if (!options.executablePath && indexPath + 1 < BROWSER_PATHS[build.os].length) {
+				return launchBrowser(options, indexPath + 1);
+			}
+			throw new Error(options.executablePath ?
+				`The browser executable was not found at ${JSON.stringify(executablePath)}` :
+				"The browser executable was not found, use --browser-executable-path to set its location");
 		}
 		throw error;
 	}

package/lib/cdp-client.js

@@ -102,7 +102,7 @@ function relaunchBrowser() {
 
 async function getPageData(options) {
 	const EMPTY_PAGE_URL = "about:blank";
-	const pageContext = { options, consoleMessages: [], debugMessages: [], httpInfo: {} };
+	const pageContext = { options, consoleMessages: [], debugMessages: [], httpInfo: {}, fetchAbortController: new AbortController() };
 	let targetInfo, cdp;
 	try {
 		logData(["Loading page", EMPTY_PAGE_URL], pageContext);
@@ -131,6 +131,7 @@ async function getPageData(options) {
 		throw error;
 	} finally {
 		logData(["Closing page"], pageContext);
+		pageContext.fetchAbortController.abort();
 		await closeTarget();
 		logData(["Finishing"], pageContext);
 	}
@@ -454,14 +455,16 @@ async function loadPage({ Page, Runtime }, { options, debugMessages }) {
 			]),
 			waitForTimeout(loadTimeoutAbortSignal, options.browserLoadMaxTime, LOAD_TIMEOUT_ERROR_MESSAGE, LOAD_TIMEOUT_ERROR)
 		]);
+		// only called when the page loaded, these calls can hang forever on an
+		// unresponsive page and would mask the load timeout error
+		await Page.setLifecycleEventsEnabled({ enabled: false });
+		await Runtime.disable();
+		await Page.disable();
 		return contextId;
 	} finally {
 		if (!loadTimeoutAbortSignal.aborted) {
 			loadTimeoutAbortController.abort();
 		}
-		await Page.setLifecycleEventsEnabled({ enabled: false });
-		await Runtime.disable();
-		await Page.disable();
 	}
 }
 
@@ -571,7 +574,7 @@ function setupPageDataCapture({ Runtime }, _contextId, { options, debugMessages
 	});
 }
 
-async function setupBindings({ Page, Runtime }, contextId, { options, debugMessages }) {
+async function setupBindings({ Page, Runtime }, contextId, { options, debugMessages, fetchAbortController }) {
 	await Runtime.addBinding({ name: SET_PAGE_DATA_FUNCTION_NAME, executionContextId: contextId });
 	if (options.embedScreenshot && options.compressContent) {
 		await setupScreenshotCapture({ Page, Runtime }, contextId, { options, debugMessages });
@@ -582,7 +585,7 @@ async function setupBindings({ Page, Runtime }, contextId, { options, debugMessa
 	await Runtime.addBinding({ name: FETCH_FUNCTION_NAME, executionContextId: contextId });
 	Runtime.addEventListener(BINDING_CALLED_EVENT_TYPE, ignoringErrors(async ({ params }) => {
 		if (params.name === FETCH_FUNCTION_NAME) {
-			await handleFetchRequest({ Runtime }, params, contextId, { options, debugMessages });
+			await handleFetchRequest({ Runtime }, params, contextId, { options, debugMessages, fetchAbortController });
 		}
 	}, { options, debugMessages }));
 }
@@ -645,12 +648,12 @@ async function setupPdfCapture({ Page, Runtime }, contextId, { options, debugMes
 	}
 }
 
-async function handleFetchRequest({ Runtime }, params, contextId, { options, debugMessages }) {
+async function handleFetchRequest({ Runtime }, params, contextId, { options, debugMessages, fetchAbortController }) {
 	const { payload } = params;
 	const { requestId, url, options: fetchOptions } = JSON.parse(payload);
 	logData(["Fetching URL", url], { options, debugMessages });
 	try {
-		const response = await fetch(url, fetchOptions);
+		const response = await fetch(url, Object.assign({}, fetchOptions, { signal: fetchAbortController.signal }));
 		const arrayBuffer = await response.arrayBuffer();
 		const base64Data = arrayBufferToBase64(arrayBuffer);
 		const result = {

package/lib/deno-polyfill.js

@@ -53,6 +53,12 @@ const errors = {
 			super(message);
 			this.name = "NotFound";
 		}
+	},
+	AlreadyExists: DENO_RUNTIME_DETECTED ? Deno.errors.AlreadyExists : class AlreadyExists extends Error {
+		constructor(message) {
+			super(message);
+			this.name = "AlreadyExists";
+		}
 	}
 };
 
@@ -157,7 +163,7 @@ async function writeTextFile(path, data, options = {}) {
 		if (options.append) {
 			return fsPromise.appendFile(path, data, options);
 		} else {
-			return fsPromise.writeFile(path, data, options);
+			return nodeWriteFile(fsPromise, path, data, options);
 		}
 	}
 }
@@ -167,7 +173,18 @@ async function writeFile(path, data, options = {}) {
 		return Deno.writeFile(path, data, options);
 	} else {
 		const fsPromise = await import(NODE_MODULES["fs"]);
-		return fsPromise.writeFile(path, data, options);
+		return nodeWriteFile(fsPromise, path, data, options);
+	}
+}
+
+async function nodeWriteFile(fsPromise, path, data, options) {
+	if (options.createNew) {
+		options.flag = "wx";
+	}
+	try {
+		return await fsPromise.writeFile(path, data, options);
+	} catch (error) {
+		throw error.code == "EEXIST" ? new errors.AlreadyExists(error.message) : error;
 	}
 }
 

package/lib/version.js

@@ -1 +1 @@
-export const version = "2.1.1";
+export const version = "2.1.2";

package/options.js

@@ -203,76 +203,155 @@ const OPTIONS_INFO = [{
 }];
 
 const { args, exit } = Deno;
-const options = getOptions();
-export { options, parseArgs };
+export { getOptions, parseArgs, applySettings, parseUrlsFile };
 
-function getOptions() {
-	const { positionals, options } = parseArgs(Array.from(args));
-	const unknownOptions = [];
-	positionals.forEach(positional => {
-		if (positional.startsWith("--")) {
-			unknownOptions.push(positional);
-			positionals.splice(positionals.indexOf(positional), 1);
-		}
-	});
-	if ((!positionals.length || positionals.length > 2 || options.help || unknownOptions.length) && (!options.version && !options.urlsFile)) {
-		console.log(USAGE_TEXT + "\n"); // eslint-disable-line no-console
-		console.log("Options:"); // eslint-disable-line no-console
-		OPTIONS_INFO.forEach(category => {
-			const categoryName = CATEGORIES[OPTIONS_INFO.indexOf(category)];
-			console.log(`  * ${categoryName}:`); // eslint-disable-line no-console
-			Object.keys(category).forEach(optionName => {
-				const optionInfo = getOptionInfo(optionName);
-				let optionType = optionInfo.type;
-				if (isArray(optionType)) {
-					optionType = optionType.replace("[]", "*");
-				}
-				const optionDescription = optionInfo.description;
-				const optionDefaultValue = optionInfo.defaultValue === undefined ? "" : `(default: ${JSON.stringify(optionInfo.defaultValue)})`;
-				console.log(`    --${optionName}: ${optionDescription} <${optionType}> ${optionDefaultValue}`); // eslint-disable-line no-console
-			});
-			console.log(""); // eslint-disable-line no-console
+function parseUrlsFile(content) {
+	return content.split("\n")
+		.map(line => line.trim())
+		.filter(line => line)
+		.map(line => {
+			let optionPosition = line.indexOf(" --");
+			if (optionPosition < 0) {
+				optionPosition = line.indexOf("\t--");
+			}
+			if (optionPosition > 0) {
+				const url = line.substring(0, optionPosition).trim();
+				const { options, positionals, invalidOptions } = parseArgs(tokenizeArgs(line.substring(optionPosition + 1).trim()), false);
+				positionals.filter(positional => positional.startsWith("--")).forEach(option =>
+					console.warn(`Warning: Unknown option ${option} (${url})`)); // eslint-disable-line no-console
+				invalidOptions.forEach(({ name, value }) => console.warn(value === undefined ? // eslint-disable-line no-console
+					`Warning: Missing value for --${name} (${url})` :
+					`Warning: Invalid value for --${name}: ${JSON.stringify(value)} (${url})`));
+				return [url, options];
+			} else {
+				return line;
+			}
 		});
-		if (unknownOptions.length) {
-			console.log(`Error: Unknown option${unknownOptions.length > 1 ? "s" : ""} ${unknownOptions.join(", ")}`); // eslint-disable-line no-console
-			console.log(""); // eslint-disable-line no-console
+}
+
+function tokenizeArgs(argsString) {
+	const args = [];
+	let previousCharacter, previousPreviousCharacter, lastQuoteCharacter;
+	let lastCharIndex = 0;
+	for (let currentCharIndex = 0; currentCharIndex < argsString.length; currentCharIndex++) {
+		const character = argsString[currentCharIndex];
+		if (character == lastQuoteCharacter && (previousCharacter != "\\" || previousPreviousCharacter == "\\")) {
+			args.push(argsString.substring(lastCharIndex, currentCharIndex));
+			lastQuoteCharacter = null;
+			lastCharIndex = currentCharIndex + 1;
+		} else if (!lastQuoteCharacter) {
+			if (character == "'" || character == "\"") {
+				lastQuoteCharacter = character;
+				lastCharIndex = currentCharIndex + 1;
+			} else if (character == " " || character == "\t" || character == "=") {
+				if (lastCharIndex < currentCharIndex) {
+					args.push(argsString.substring(lastCharIndex, currentCharIndex));
+				}
+				lastCharIndex = currentCharIndex + 1;
+			}
 		}
+		previousPreviousCharacter = previousCharacter;
+		previousCharacter = character;
+	}
+	if (lastCharIndex < argsString.length) {
+		args.push(argsString.substring(lastCharIndex).trim());
+	}
+	return args;
+}
+
+function applySettings(options, settings, explicitOptions = parseArgs(Array.from(args), false).options) {
+	const profiles = settings.profiles || {};
+	let profileName = options.settingsFileProfile;
+	if (profileName == "default" || profileName === undefined) {
+		profileName = "__Default_Settings__";
+	} else if (!profiles[profileName]) {
+		const profileNames = Object.keys(profiles).filter(name => name != "__Default_Settings__");
+		throw new Error(`Unknown profile ${JSON.stringify(profileName)}, available profiles: ${profileNames.join(", ")}`);
+	}
+	Object.assign(options, profiles[profileName], explicitOptions);
+	delete options.settingsFile;
+}
+
+function getOptions() {
+	const { positionals, options, invalidOptions } = parseArgs(Array.from(args));
+	const unknownOptions = positionals.filter(positional => positional.startsWith("--"));
+	const urls = positionals.filter(positional => !positional.startsWith("--"));
+	if (options.help) {
+		printUsage();
 		exit(0);
 	}
 	if (options.version) {
 		console.log(version); // eslint-disable-line no-console
 		exit(0);
 	}
-	return { ...options, url: positionals[0], output: positionals[1] };
+	const errorMessages = [];
+	unknownOptions.forEach(option => errorMessages.push(`Unknown option ${option}`));
+	invalidOptions.forEach(({ name, value }) => errorMessages.push(value === undefined ?
+		`Missing value for --${name}` :
+		`Invalid value for --${name}: ${JSON.stringify(value)}`));
+	if (!urls.length && !options.urlsFile) {
+		errorMessages.push("The URL or path of the page to save is required");
+	}
+	if (urls.length > 2) {
+		errorMessages.push(`Unexpected arguments: ${urls.slice(2).join(", ")}`);
+	}
+	if (errorMessages.length) {
+		printUsage();
+		errorMessages.forEach(message => console.error(`Error: ${message}`)); // eslint-disable-line no-console
+		exit(1);
+	}
+	return { ...options, url: urls[0], output: urls[1] };
+}
+
+function printUsage() {
+	console.log(USAGE_TEXT + "\n"); // eslint-disable-line no-console
+	console.log("Options:"); // eslint-disable-line no-console
+	OPTIONS_INFO.forEach(category => {
+		const categoryName = CATEGORIES[OPTIONS_INFO.indexOf(category)];
+		console.log(`  * ${categoryName}:`); // eslint-disable-line no-console
+		Object.keys(category).forEach(optionName => {
+			const optionInfo = category[optionName];
+			let optionType = optionInfo.type;
+			if (isArray(optionType)) {
+				optionType = optionType.replace("[]", "*");
+			}
+			const optionDescription = optionInfo.description;
+			const optionDefaultValue = optionInfo.defaultValue === undefined ? "" : `(default: ${JSON.stringify(optionInfo.defaultValue)})`;
+			console.log(`    --${optionName}: ${optionDescription} <${optionType}> ${optionDefaultValue}`); // eslint-disable-line no-console
+		});
+		console.log(""); // eslint-disable-line no-console
+	});
 }
 
 function parseArgs(args, setDefaultValues = true) {
 	const positionals = [];
 	const options = {};
-	const result = { positionals, options: {} };
+	const invalidOptions = [];
+	const result = { positionals, options: {}, invalidOptions };
 	let argIndex = 0;
 	while (argIndex < args.length) {
 		const arg = args[argIndex];
-		const { argName, argValue, optionInfo } = parseArg(arg);
-		if (optionInfo) {
-			if (options[argName] === undefined) {
-				options[argName] = [];
+		const { argValue, option } = parseArg(arg);
+		if (option) {
+			const optionName = option.name;
+			if (options[optionName] === undefined) {
+				options[optionName] = [];
 			}
-			let nextArgName;
 			if (argValue === undefined) {
-				if (
-					argIndex + 1 < args.length &&
-					({ argName: nextArgName } = parseArg(args[argIndex + 1])) &&
-					(nextArgName === undefined || !getOptionInfo(nextArgName)) &&
-					isValid(optionInfo.type, args[argIndex + 1]) &&
-					(isArray(optionInfo.type) || !options[argName].length)) {
-					options[argName].push(args[argIndex + 1]);
-					argIndex++;
+				if (argIndex + 1 < args.length && !parseArg(args[argIndex + 1]).option) {
+					const nextArg = args[argIndex + 1];
+					if (isValid(option.info.type, nextArg)) {
+						options[optionName].push(nextArg);
+						argIndex++;
+					} else if (option.info.type.startsWith("number")) {
+						invalidOptions.push({ name: optionName, value: nextArg });
+						argIndex++;
+					}
 				}
-			} else if (isValid(optionInfo.type, argValue) && (isArray(optionInfo.type) || !options[argName].length)) {
-				options[argName].push(argValue);
+			} else if (isValid(option.info.type, argValue)) {
+				options[optionName].push(argValue);
 			} else {
-				positionals.push(arg);
+				invalidOptions.push({ name: optionName, value: argValue });
 			}
 		} else {
 			positionals.push(arg);
@@ -280,34 +359,38 @@ function parseArgs(args, setDefaultValues = true) {
 		argIndex++;
 	}
 	Object.keys(options).forEach(optionName => {
-		const optionInfo = getOptionInfo(optionName);
+		const optionInfo = getOptionInfo(optionName).info;
 		const optionKey = getOptionKey(optionName, optionInfo);
 		let optionValue = options[optionName];
 		const isArrayType = isArray(optionInfo.type);
+		if (!optionInfo.type.startsWith("boolean") && !optionValue.length &&
+			!invalidOptions.some(invalidOption => invalidOption.name == optionName)) {
+			invalidOptions.push({ name: optionName });
+		}
 		if (optionInfo.type.startsWith("boolean")) {
 			optionValue = optionValue.map(value => value == "true");
 			optionValue = isArrayType ?
 				optionValue.length ? optionValue : true :
-				optionValue.length ? optionValue[0] : true;
+				optionValue.length ? optionValue[optionValue.length - 1] : true;
 		} else if (optionInfo.type.startsWith("number")) {
 			optionValue = optionValue.map(value => Number(value));
 			optionValue = isArrayType ?
 				optionValue.length ? optionValue : optionInfo.defaultValue || 0 :
-				optionValue.length ? optionValue[0] : optionInfo.defaultValue || 0;
+				optionValue.length ? optionValue[optionValue.length - 1] : optionInfo.defaultValue || 0;
 		} else {
 			optionValue = isArrayType ?
 				optionValue.length ? optionValue : optionInfo.defaultValue || "" :
-				optionValue.length ? optionValue[0] : optionInfo.defaultValue || "";
+				optionValue.length ? optionValue[optionValue.length - 1] : optionInfo.defaultValue || "";
 		}
 		result.options[optionKey] = optionValue;
 	});
 	if (setDefaultValues) {
 		OPTIONS_INFO.forEach(categoryOptions => {
 			Object.keys(categoryOptions).forEach(optionName => {
-				const optionInfo = getOptionInfo(optionName);
+				const optionInfo = categoryOptions[optionName];
 				const optionKey = getOptionKey(optionName, optionInfo);
 				if (result.options[optionKey] === undefined && optionInfo.defaultValue !== undefined) {
-					result.options[optionKey] = categoryOptions[optionName].defaultValue;
+					result.options[optionKey] = optionInfo.defaultValue;
 				}
 			});
 		});
@@ -332,7 +415,11 @@ function parseArgs(args, setDefaultValues = true) {
 	}
 	if (result.options.browserArgs) {
 		const browserArguments = result.options.browserArguments || [];
-		browserArguments.push(...JSON.parse(result.options.browserArgs));
+		try {
+			browserArguments.push(...JSON.parse(result.options.browserArgs));
+		} catch {
+			invalidOptions.push({ name: "browser-args", value: result.options.browserArgs });
+		}
 		result.options.browserArgs = browserArguments;
 		delete result.options.browserArguments;
 	}
@@ -340,46 +427,14 @@ function parseArgs(args, setDefaultValues = true) {
 		result.options.browserArgs = result.options.browserArguments;
 		delete result.options.browserArguments;
 	}
-	if (result.options.errorFile) {
+	if (result.options.errorFile !== undefined) {
 		result.options.errorsFile = result.options.errorFile;
 		delete result.options.errorFile;
 	}
-	if (result.options.errorTracesDisabled) {
+	if (result.options.errorTracesDisabled !== undefined) {
 		result.options.errorsTracesDisabled = result.options.errorTracesDisabled;
 		delete result.options.errorTracesDisabled;
 	}
-	if (result.options.crawlReplaceUrls) {
-		result.options.crawlReplaceURLs = result.options.crawlReplaceUrls;
-		delete result.options.crawlReplaceUrls;
-	}
-	if (result.options.saveOriginalUrls) {
-		result.options.saveOriginalURLs = result.options.saveOriginalUrls;
-		delete result.options.saveOriginalUrls;
-	}
-	if (result.options.browserRemoteDebuggingUrl) {
-		result.options.browserRemoteDebuggingURL = result.options.browserRemoteDebuggingUrl;
-		delete result.options.browserRemoteDebuggingUrl;
-	}
-	if (result.options.crawlRemoveUrlFragment) {
-		result.options.crawlRemoveURLFragment = result.options.crawlRemoveUrlFragment;
-		delete result.options.crawlRemoveUrlFragment;
-	}
-	if (result.options.compressCss) {
-		result.options.compressCSS = result.options.compressCss;
-		delete result.options.compressCss;
-	}
-	if (result.options.compressHtml) {
-		result.options.compressHTML = result.options.compressHtml;
-		delete result.options.compressHtml;
-	}
-	if (result.options.insertMetaCsp) {
-		result.options.insertMetaCSP = result.options.insertMetaCsp;
-		delete result.options.insertMetaCsp;
-	}
-	if (result.options.blockedUrlPatterns) {
-		result.options.blockedURLPatterns = result.options.blockedUrlPatterns;
-		delete result.options.blockedUrlPatterns;
-	}
 	if (result.options.filenameReplacedCharacters) {
 		const filenameReplacedCharacters = result.options.filenameReplacedCharacters;
 		result.options.filenameReplacedCharacters = [];
@@ -404,6 +459,49 @@ function parseArgs(args, setDefaultValues = true) {
 			}
 		});
 	}
+	if (result.options.httpHeaders) {
+		const headers = {};
+		result.options.httpHeaders.forEach(header => {
+			const separatorIndex = header.indexOf("=");
+			if (separatorIndex <= 0) {
+				invalidOptions.push({ name: "http-header", value: header });
+			} else {
+				headers[header.substring(0, separatorIndex).trim()] = header.substring(separatorIndex + 1).trim();
+			}
+		});
+		result.options.httpHeaders = headers;
+	}
+	if (result.options.emulateMediaFeatures) {
+		result.options.emulateMediaFeatures = result.options.emulateMediaFeatures
+			.map(feature => {
+				const separatorIndex = feature.indexOf(":");
+				if (separatorIndex <= 0) {
+					invalidOptions.push({ name: "emulate-media-feature", value: feature });
+				} else {
+					return {
+						name: feature.substring(0, separatorIndex),
+						value: feature.substring(separatorIndex + 1)
+					};
+				}
+			})
+			.filter(feature => feature);
+	}
+	if (result.options.browserCookies) {
+		result.options.browserCookies = result.options.browserCookies.map(cookie => {
+			const [name, value, domain, path, expires, httpOnly, secure, sameSite, url] = cookie.split(",");
+			return {
+				name,
+				value,
+				url,
+				domain,
+				path,
+				secure: secure === "true",
+				httpOnly: httpOnly === "true",
+				sameSite,
+				expires: expires && !isNaN(Number(expires)) ? Number(expires) : undefined
+			};
+		});
+	}
 	return result;
 }
 
@@ -423,13 +521,13 @@ function parseArg(arg) {
 	const parsedArg = arg.match(ARGS_REGEX);
 	if (parsedArg && parsedArg.length) {
 		let [_, argName, argValue] = parsedArg; // eslint-disable-line no-unused-vars
-		const optionInfo = getOptionInfo(argName);
+		const option = getOptionInfo(argName);
 		if (argValue !== undefined &&
 			((argValue.startsWith("\"") && argValue.endsWith("\"")) ||
 				(argValue.startsWith("'") && argValue.endsWith("'")))) {
 			argValue = argValue.substring(1, argValue.length - 1);
 		}
-		return { argName, argValue, optionInfo };
+		return { argName, argValue, option };
 	} else {
 		return {};
 	}
@@ -440,7 +538,7 @@ function getOptionInfo(optionName) {
 	OPTIONS_INFO.forEach(categoryOptions => {
 		Object.keys(categoryOptions).forEach(keyName => {
 			if (keyName.toLowerCase() == optionName.toLowerCase() || categoryOptions[keyName].alias == optionName.toLowerCase()) {
-				result = categoryOptions[keyName];
+				result = { name: keyName, info: categoryOptions[keyName] };
 			}
 		});
 	});
@@ -455,7 +553,7 @@ function isValid(type, value) {
 	if (type.startsWith("boolean")) {
 		return value == "true" || value == "false";
 	} else if (type.startsWith("number")) {
-		return !isNaN(value);
+		return value.trim() != "" && !isNaN(value);
 	} else {
 		return true;
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "single-file-cli",
-	"version": "2.1.1",
+	"version": "2.1.2",
 	"description": "SingleFile CLI",
 	"author": "Gildas Lormeau",
 	"engines": {
@@ -10,18 +10,18 @@
 	},
 	"type": "module",
 	"scripts": {
-		"test": "node --test \"test/**/*.test.js\"",
+		"test": "node --test --test-concurrency=2 \"test/**/*.test.js\"",
 		"lint": "eslint ."
 	},
 	"bin": {
 		"single-file": "single-file-node.js"
 	},
 	"dependencies": {
-		"simple-cdp": "^1.10.0"
+		"simple-cdp": "^1.10.1"
 	},
 	"devDependencies": {
-		"@eslint/js": "^9.39.1",
-		"esbuild": "^0.27.4",
+		"@eslint/js": "^9.39.5",
+		"esbuild": "^0.27.7",
 		"eslint": "^10.8.1"
 	}
 }

package/single-file-cli-api.js

@@ -106,7 +106,6 @@ async function initialize(options) {
 
 async function capture(urls, options) {
 	let newTasks;
-	const taskUrls = tasks.map(task => task.url);
 	newTasks = await Promise.all(urls.map(value => {
 		let url, taskOptions;
 		if (Array.isArray(value)) {
@@ -118,7 +117,7 @@ async function capture(urls, options) {
 		}
 		return createTask(url, taskOptions);
 	}));
-	newTasks = newTasks.filter(task => task && !taskUrls.includes(task.url));
+	newTasks = newTasks.filter((task, taskIndex) => task && !mergeDuplicateTask(task, tasks.concat(newTasks.slice(0, taskIndex))));
 	if (newTasks.length) {
 		tasks = tasks.concat(newTasks);
 		await saveTasks();
@@ -300,37 +299,27 @@ async function capturePage(options) {
 			pageData.comment = undefined;
 			content = JSON.stringify(pageData, null, 2);
 		}
-		if (options.output) {
-			filename = await getFilename(options.output, options);
-		} else if (options.dumpContent) {
+		if (options.dumpContent && !options.output) {
 			if (options.compressContent) {
 				await stdout.write(content);
 			} else {
 				console.log(content || ""); // eslint-disable-line no-console
 			}
 		} else {
-			filename = await getFilename(pageData.filename, options);
+			let outputFilename = options.output || pageData.filename;
+			if (options.outputJson && !outputFilename.endsWith(".json")) {
+				outputFilename += ".json";
+			}
+			filename = await writeOutputFile(outputFilename, content, options);
 		}
 		if (filename) {
-			if (options.outputJson) {
-				filename += filename.endsWith(".json") ? "" : ".json";
-			}
-			const directoryName = path.dirname(filename);
-			if (directoryName !== ".") {
-				await mkdir(directoryName, { recursive: true });
-			}
-			if (content instanceof Uint8Array) {
-				await writeFile(filename, content);
-			} else {
-				await writeTextFile(filename, content);
-			}
 			const outputDirectory = getOutputDirectory(options);
 			pageData.filename = filename.startsWith(outputDirectory) ? filename.substring(outputDirectory.length) : filename;
 		}
 		return pageData;
 	} catch (error) {
 		const date = new Date();
-		let message = `[${date.toISOString()}] URL: ${options.url}`;
+		let message = `[${date.toISOString()}] URL: ${options.url} Error: ${error.message || error}`;
 		if (!options.errorsTracesDisabled) {
 			message += "\nStack: " + error.stack;
 		}
@@ -366,6 +355,37 @@ function getOutputDirectory(options) {
 	return outputDirectory;
 }
 
+async function writeOutputFile(outputFilename, content, options) {
+	while (true) {
+		const filename = await getFilename(outputFilename, options);
+		if (!filename) {
+			return;
+		}
+		const directoryName = path.dirname(filename);
+		if (directoryName !== ".") {
+			await mkdir(directoryName, { recursive: true });
+		}
+		// exclusive creation prevents parallel tasks writing the same filename
+		// from silently overwriting each other
+		const writeOptions = { createNew: options.filenameConflictAction != "overwrite" };
+		try {
+			if (content instanceof Uint8Array) {
+				await writeFile(filename, content, writeOptions);
+			} else {
+				await writeTextFile(filename, content, writeOptions);
+			}
+			return filename;
+		} catch (error) {
+			if (!(error instanceof errors.AlreadyExists)) {
+				throw error;
+			}
+			if (options.filenameConflictAction == "skip") {
+				return;
+			}
+		}
+	}
+}
+
 async function getFilename(filename, options, index = 1) {
 	let newFilename = getOutputDirectory(options) + filename;
 	if (options.filenameConflictAction == "overwrite") {

package/single-file-launcher.js

@@ -24,7 +24,7 @@
 import { initialize } from "./single-file-cli-api.js";
 import { closeBrowser } from "./lib/browser.js";
 import { Deno } from "./lib/deno-polyfill.js";
-import { options, parseArgs } from "./options.js";
+import { getOptions, applySettings, parseUrlsFile } from "./options.js";
 
 const { readTextFile, readFile, exit, addSignalListener } = Deno;
 
@@ -43,39 +43,17 @@ export { run };
 
 async function run() {
 	try {
+		const options = getOptions();
 		let urls;
 		if (options.settingsFile) {
-			const settings = JSON.parse(await Deno.readTextFile(options.settingsFile));
-			let profileName = options.settingsProfile || "default";
-			if (profileName == "default" || !settings.profiles[profileName]) {
-				profileName = "__Default_Settings__";
-			}
-			Object.assign(options, settings.profiles[profileName]);
-			delete options.settingsFile;
+			const settings = JSON.parse(await readTextFile(options.settingsFile));
+			applySettings(options, settings);
 		}
 		if (options.urlsFile) {
 			urls = await getUrlsFile(options.urlsFile);
 		} else {
 			urls = [options.url];
 		}
-		if (options.browserCookies) {
-			const cookies = [];
-			for (const cookie of options.browserCookies) {
-				const [name, value, domain, path, expires, httpOnly, secure, sameSite, url] = cookie.split(",");
-				cookies.push({
-					name,
-					value,
-					url,
-					domain,
-					path,
-					secure: secure === "true",
-					httpOnly: httpOnly === "true",
-					sameSite,
-					expires: isNaN(Number(expires)) ? undefined : Number(expires)
-				});
-			}
-			options.browserCookies = cookies;
-		}
 		if (options.browserCookiesFile) {
 			const cookiesContent = await readTextFile(options.browserCookiesFile);
 			try {
@@ -84,23 +62,6 @@ async function run() {
 				options.browserCookies = parseCookies(cookiesContent);
 			}
 		}
-		if (options.emulateMediaFeatures) {
-			options.emulateMediaFeatures = options.emulateMediaFeatures.map(feature => {
-				const colonIndex = feature.indexOf(":");
-				return {
-					name: feature.substring(0, colonIndex),
-					value: feature.substring(colonIndex + 1)
-				};
-			});
-		}
-		if (options.httpHeaders) {
-			const headers = {};
-			for (const header of options.httpHeaders) {
-				const [name, value] = header.split("=");
-				headers[name] = value.trim();
-			}
-			options.httpHeaders = headers;
-		}
 		if (options.embeddedImage) {
 			options.embeddedImage = Array.from(await readFile(options.embeddedImage));
 		}
@@ -148,54 +109,5 @@ async function closeBrowserAndExit(code) {
 }
 
 async function getUrlsFile(urlsFile) {
-	let urls = (await readTextFile(urlsFile)).split("\n");
-	urls = urls.map(value => {
-		value = value.trim();
-		let optionPosition = value.indexOf(" --");
-		if (optionPosition < 0) {
-			optionPosition = value.indexOf("\t--");
-		}
-		if (optionPosition > 0) {
-			const url = value.substring(0, optionPosition).trim();
-			const argsString = value.substring(optionPosition + 1).trim();
-			const args = [];
-			let previousCharacter, previousPreviousCharacter, lastQuoteCharacter;
-			let lastCharIndex = 0;
-			for (let currentCharIndex = 0; currentCharIndex < argsString.length; currentCharIndex++) {
-				const character = argsString[currentCharIndex];
-				if (character == lastQuoteCharacter && (previousCharacter != "\\" || previousPreviousCharacter == "\\")) {
-					args.push(argsString.substring(lastCharIndex, currentCharIndex));
-					lastQuoteCharacter = null;
-					lastCharIndex = currentCharIndex + 1;
-				} else if (!lastQuoteCharacter) {
-					if (character == "'" || character == "\"") {
-						lastQuoteCharacter = argsString[currentCharIndex];
-						lastCharIndex = currentCharIndex + 1;
-					} else {
-						const isSpaceCharacter = character == " " || character == "\t";
-						if (isSpaceCharacter || character == "=") {
-							if (isSpaceCharacter && (currentCharIndex == lastCharIndex + 1)) {
-								lastCharIndex++;
-							} else if (lastCharIndex < currentCharIndex) {
-								args.push(argsString.substring(lastCharIndex, currentCharIndex));
-								lastCharIndex = currentCharIndex + 1;
-							} else {
-								lastCharIndex = currentCharIndex + 1;
-							}
-						}
-					}
-				}
-				previousPreviousCharacter = previousCharacter;
-				previousCharacter = character;
-			}
-			if (lastCharIndex < argsString.length) {
-				args.push(argsString.substring(lastCharIndex).trim());
-			}
-			const { options } = parseArgs(args, false);
-			return [url, options];
-		} else {
-			return value;
-		}
-	});
-	return urls;
+	return parseUrlsFile(await readTextFile(urlsFile));
 }

package/test/e2e/errors-file.test.js

@@ -0,0 +1,31 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import process from "node:process";
+
+const execFileAsync = promisify(execFile);
+const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+test("errors file lines include the error message", { timeout: 120000 }, async () => {
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const errorsPath = join(directory, "errors.txt");
+		const url = "http://localhost:1/";
+		await execFileAsync(process.execPath, [
+			"single-file-node.js", url, join(directory, "out.html"),
+			"--errors-file", errorsPath
+		], { cwd: cliDirectory });
+		const content = await readFile(errorsPath, "utf8");
+		assert.ok(content.includes("URL: " + url));
+		const errorMessage = content.match(/Error: (.*)/);
+		assert.ok(errorMessage);
+		assert.ok(errorMessage[1].trim().length > 0);
+	} finally {
+		await rm(directory, { recursive: true });
+	}
+});

package/test/e2e/frame-gate.test.js

@@ -51,7 +51,8 @@ test("capture waits for the top frame, not a fast iframe", { timeout: 120000 },
 		await execFileAsync(process.execPath, [
 			"single-file-node.js", url, outputPath,
 			"--browser-wait-until", "networkIdle",
-			"--browser-wait-until-delay", "1000"
+			"--browser-wait-until-delay", "1000",
+			"--browser-wait-until-fallback", "false"
 		], { cwd: cliDirectory });
 		const content = await readFile(outputPath, "utf8");
 		assert.ok(content.includes(LOAD_MARKER), "page was captured before the top frame finished loading");

package/test/e2e/timeouts.test.js

@@ -0,0 +1,70 @@
+/* global setInterval, clearInterval */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdtemp, rm } from "node:fs/promises";
+import { Buffer } from "node:buffer";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import process from "node:process";
+
+const execFileAsync = promisify(execFile);
+const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+test("load timeout is reported when the page never loads", { timeout: 120000 }, async () => {
+	const server = createServer(() => { });
+	await new Promise(resolve => server.listen(0, "localhost", resolve));
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const url = "http://localhost:" + server.address().port + "/";
+		const { stderr } = await runCli([
+			url, join(directory, "out.html"),
+			"--browser-load-max-time", "5000",
+			"--browser-wait-until-fallback", "false"
+		]);
+		assert.ok(stderr.includes("Load timeout"), "stderr: " + stderr);
+	} finally {
+		await rm(directory, { recursive: true });
+		server.closeAllConnections();
+		server.close();
+	}
+});
+
+test("capture timeout is reported when capturing an endless download", { timeout: 120000 }, async () => {
+	const chunk = Buffer.alloc(65536);
+	const server = createServer((_, response) => {
+		response.writeHead(200, { "content-type": "application/octet-stream", "content-disposition": "attachment; filename=big.bin" });
+		const intervalId = setInterval(() => response.write(chunk), 50);
+		response.on("close", () => clearInterval(intervalId));
+	});
+	await new Promise(resolve => server.listen(0, "localhost", resolve));
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const url = "http://localhost:" + server.address().port + "/";
+		const { stderr } = await runCli([
+			url, join(directory, "out.html"),
+			"--browser-load-max-time", "5000",
+			"--browser-capture-max-time", "10000"
+		]);
+		assert.ok(stderr.includes("Capture timeout") || stderr.includes("Load timeout"), "stderr: " + stderr);
+	} finally {
+		await rm(directory, { recursive: true });
+		server.closeAllConnections();
+		server.close();
+	}
+});
+
+async function runCli(args) {
+	try {
+		return await execFileAsync(process.execPath, ["single-file-node.js", ...args], { cwd: cliDirectory, timeout: 90000, killSignal: "SIGKILL" });
+	} catch (error) {
+		if (error.killed) {
+			throw new Error("the process did not exit before the timeout");
+		}
+		return { stdout: error.stdout, stderr: error.stderr };
+	}
+}

package/test/e2e/urls-file.test.js

@@ -0,0 +1,37 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import process from "node:process";
+
+const execFileAsync = promisify(execFile);
+const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+test("duplicate urls in a urls file are captured once", { timeout: 120000 }, async () => {
+	const server = createServer((_, response) => response
+		.writeHead(200, { "content-type": "text/html" })
+		.end("<html><head><title>Same Page</title></head><body>content</body></html>"));
+	await new Promise(resolve => server.listen(0, "localhost", resolve));
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const url = "http://localhost:" + server.address().port + "/";
+		const urlsFilePath = join(directory, "urls.txt");
+		await writeFile(urlsFilePath, url + "\n\n" + url + "\n");
+		const { stderr } = await execFileAsync(process.execPath, [
+			"single-file-node.js",
+			"--urls-file", urlsFilePath,
+			"--output-directory", directory,
+			"--filename-template", "{page-title}.html"
+		], { cwd: cliDirectory });
+		const files = (await readdir(directory)).filter(file => file.endsWith(".html"));
+		assert.deepEqual(files, ["Same Page.html"], "stderr: " + stderr);
+	} finally {
+		await rm(directory, { recursive: true });
+		server.close();
+	}
+});

package/test/unit/cli-usage.test.js

@@ -0,0 +1,56 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import process from "node:process";
+
+const execFileAsync = promisify(execFile);
+const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+async function runCli(args) {
+	try {
+		const { stdout, stderr } = await execFileAsync(process.execPath, ["single-file-node.js", ...args], { cwd: cliDirectory });
+		return { code: 0, stdout, stderr };
+	} catch (error) {
+		return { code: error.code, stdout: error.stdout, stderr: error.stderr };
+	}
+}
+
+test("help is displayed with an exit code of 0", async () => {
+	const { code, stdout } = await runCli(["--help"]);
+	assert.equal(code, 0);
+	assert.ok(stdout.includes("--browser-executable-path"));
+});
+
+test("a missing url is reported as an error", async () => {
+	const { code, stderr } = await runCli(["--browser-executable-path", "/path/to/chrome"]);
+	assert.equal(code, 1);
+	assert.ok(stderr.includes("The URL or path of the page to save is required"));
+});
+
+test("unknown options are reported as errors", async () => {
+	const { code, stderr } = await runCli(["--foo", "--bar", "https://example.com", "out.html"]);
+	assert.equal(code, 1);
+	assert.ok(stderr.includes("Unknown option --foo"));
+	assert.ok(stderr.includes("Unknown option --bar"));
+});
+
+test("invalid option values are reported as errors", async () => {
+	const { code, stderr } = await runCli(["--browser-width", "abc", "https://example.com"]);
+	assert.equal(code, 1);
+	assert.ok(stderr.includes("Invalid value for --browser-width: \"abc\""));
+});
+
+test("a wrong browser executable path is reported with the path", async () => {
+	const { code, stderr } = await runCli(["https://localhost:1/", "out.html", "--browser-executable-path", "/nonexistent/chrome"]);
+	assert.notEqual(code, 0);
+	assert.ok(stderr.includes("The browser executable was not found at \"/nonexistent/chrome\""));
+});
+
+test("unexpected extra arguments are reported as errors", async () => {
+	const { code, stderr } = await runCli(["https://example.com", "out.html", "extra.html"]);
+	assert.equal(code, 1);
+	assert.ok(stderr.includes("Unexpected arguments: extra.html"));
+});

package/test/unit/options.test.js

@@ -0,0 +1,136 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { parseArgs, applySettings, parseUrlsFile } from "../../options.js";
+
+const parse = args => parseArgs(args).options;
+
+test("boolean options with uppercase canonical names can be disabled", () => {
+	assert.equal(parse(["--compress-html", "false"]).compressHTML, false);
+	assert.equal(parse(["--compress-HTML", "false"]).compressHTML, false);
+	assert.equal(parse(["--crawl-remove-url-fragment", "false"]).crawlRemoveURLFragment, false);
+	assert.equal(parse(["--insert-meta-csp", "false"]).insertMetaCSP, false);
+});
+
+test("option names are canonicalized regardless of case", () => {
+	assert.equal(parse(["--include-bom"]).includeBOM, true);
+	assert.equal(parse(["--Include-BOM"]).includeBOM, true);
+	assert.equal(parse(["--crawl-replace-urls"]).crawlReplaceURLs, true);
+	assert.equal(parse(["--save-original-urls"]).saveOriginalURLs, true);
+	assert.deepEqual(parse(["--blocked-url-pattern", "ads"]).blockedURLPatterns, ["ads"]);
+	const options = parse(["--compress-html", "false"]);
+	assert.equal("compressHtml" in options, false);
+});
+
+test("aliases map to the canonical option", () => {
+	assert.equal(parse(["--error-file", "errors.txt"]).errorsFile, "errors.txt");
+	assert.equal(parse(["--errors-file", "errors.txt"]).errorsFile, "errors.txt");
+	assert.equal(parse(["--error-traces-disabled", "false"]).errorsTracesDisabled, false);
+	assert.equal(parse(["--errors-traces-disabled", "false"]).errorsTracesDisabled, false);
+	assert.equal(parse([]).errorsTracesDisabled, true);
+});
+
+test("browser arguments are merged", () => {
+	assert.deepEqual(parse(["--browser-arg", "--disable-gpu"]).browserArgs, ["--disable-gpu"]);
+	assert.deepEqual(parse(["--browser-args", "[\"--mute-audio\"]"]).browserArgs, ["--mute-audio"]);
+	assert.deepEqual(parse(["--browser-arg", "--disable-gpu", "--browser-args", "[\"--mute-audio\"]"]).browserArgs, ["--disable-gpu", "--mute-audio"]);
+});
+
+test("default values are applied under canonical keys", () => {
+	const options = parse([]);
+	assert.equal(options.compressHTML, true);
+	assert.equal(options.crawlRemoveURLFragment, true);
+	assert.equal(options.insertMetaCSP, true);
+	assert.equal(options.browserWidth, 1280);
+});
+
+test("invalid and missing values are reported", () => {
+	assert.deepEqual(parseArgs(["--browser-width", "abc"]).invalidOptions, [{ name: "browser-width", value: "abc" }]);
+	assert.deepEqual(parseArgs(["--browser-width=abc"]).invalidOptions, [{ name: "browser-width", value: "abc" }]);
+	assert.deepEqual(parseArgs(["--browser-height="]).invalidOptions, [{ name: "browser-height", value: "" }]);
+	assert.deepEqual(parseArgs(["--output-directory"]).invalidOptions, [{ name: "output-directory" }]);
+	assert.deepEqual(parseArgs(["--browser-width", "abc"]).positionals, []);
+	assert.deepEqual(parseArgs(["--browser-debug"]).invalidOptions, []);
+});
+
+test("the last value wins when a scalar option is repeated", () => {
+	const { options, positionals } = parseArgs(["--browser-width", "100", "--browser-width", "200"]);
+	assert.equal(options.browserWidth, 200);
+	assert.deepEqual(positionals, []);
+	assert.equal(parse(["--browser-width=100", "--browser-width=200"]).browserWidth, 200);
+});
+
+test("http headers keep characters after the first equals sign", () => {
+	const options = parse(["--http-header", "authorization=Basic dGVzdA==", "--http-header", " x-test = value "]);
+	assert.deepEqual(options.httpHeaders, { authorization: "Basic dGVzdA==", "x-test": "value" });
+	assert.deepEqual(parseArgs(["--http-header", "no-separator"]).invalidOptions, [{ name: "http-header", value: "no-separator" }]);
+});
+
+test("media features are split on the first colon", () => {
+	assert.deepEqual(parse(["--emulate-media-feature", "prefers-color-scheme:dark"]).emulateMediaFeatures, [{ name: "prefers-color-scheme", value: "dark" }]);
+	assert.deepEqual(parseArgs(["--emulate-media-feature", "no-separator"]).invalidOptions, [{ name: "emulate-media-feature", value: "no-separator" }]);
+});
+
+test("browser cookies are parsed into objects", () => {
+	const options = parse(["--browser-cookie", "name,value,example.com,/,,true,true,None,https://example.com"]);
+	assert.deepEqual(options.browserCookies, [{
+		name: "name",
+		value: "value",
+		url: "https://example.com",
+		domain: "example.com",
+		path: "/",
+		secure: true,
+		httpOnly: true,
+		sameSite: "None",
+		expires: undefined
+	}]);
+	assert.equal(parse(["--browser-cookie", "name,value,example.com,/,1893456000,false,false,Lax,https://example.com"]).browserCookies[0].expires, 1893456000);
+});
+
+test("invalid browser args json is reported", () => {
+	assert.deepEqual(parseArgs(["--browser-args", "not json"]).invalidOptions, [{ name: "browser-args", value: "not json" }]);
+});
+
+test("explicit options win over settings file profiles", () => {
+	const options = parse(["--settings-file-profile", "custom", "--browser-width", "1024"]);
+	const settings = { profiles: { custom: { compressHTML: false, browserWidth: 800 } } };
+	applySettings(options, settings, { browserWidth: 1024 });
+	assert.equal(options.compressHTML, false);
+	assert.equal(options.browserWidth, 1024);
+});
+
+test("the default profile maps to the default settings", () => {
+	const options = parse([]);
+	applySettings(options, { profiles: { __Default_Settings__: { compressHTML: false } } }, {});
+	assert.equal(options.compressHTML, false);
+});
+
+test("an unknown settings profile is reported", () => {
+	const options = parse(["--settings-file-profile", "missing"]);
+	assert.throws(
+		() => applySettings(options, { profiles: { __Default_Settings__: {}, work: {} } }, {}),
+		/Unknown profile "missing", available profiles: work/);
+});
+
+test("blank lines in urls files are skipped", () => {
+	assert.deepEqual(parseUrlsFile("https://a.example\n\n \nhttps://b.example\r\n"), ["https://a.example", "https://b.example"]);
+});
+
+test("single character values in urls file options are kept", () => {
+	const [url, options] = parseUrlsFile("https://a.example --crawl-max-depth 2 --browser-width 100")[0];
+	assert.equal(url, "https://a.example");
+	assert.equal(options.crawlMaxDepth, 2);
+	assert.equal(options.browserWidth, 100);
+});
+
+test("quoted and equal form values in urls files are parsed", () => {
+	const [, options] = parseUrlsFile("https://a.example --filename-template \"My Page.html\" --browser-height=600")[0];
+	assert.equal(options.filenameTemplate, "My Page.html");
+	assert.equal(options.browserHeight, 600);
+});
+
+test("values are parsed from both spaced and equal forms", () => {
+	assert.equal(parse(["--browser-width", "1024"]).browserWidth, 1024);
+	assert.equal(parse(["--browser-width=1024"]).browserWidth, 1024);
+	assert.equal(parse(["--browser-headless=false"]).browserHeadless, false);
+	assert.equal(parse(["--filename-template={page-title}.html"]).filenameTemplate, "{page-title}.html");
+});

package/test/unit/write-file.test.js

@@ -0,0 +1,37 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Deno } from "../../lib/deno-polyfill.js";
+
+const { writeTextFile, writeFile, readTextFile, errors } = Deno;
+
+test("exclusive creation fails when the file exists", async () => {
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const filename = join(directory, "out.txt");
+		await writeTextFile(filename, "first", { createNew: true });
+		await assert.rejects(
+			() => writeTextFile(filename, "second", { createNew: true }),
+			error => error instanceof errors.AlreadyExists);
+		await assert.rejects(
+			() => writeFile(filename, new Uint8Array([1]), { createNew: true }),
+			error => error instanceof errors.AlreadyExists);
+		assert.equal(await readTextFile(filename), "first");
+	} finally {
+		await rm(directory, { recursive: true });
+	}
+});
+
+test("writing without exclusive creation overwrites", async () => {
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const filename = join(directory, "out.txt");
+		await writeTextFile(filename, "first");
+		await writeTextFile(filename, "second");
+		assert.equal(await readTextFile(filename), "second");
+	} finally {
+		await rm(directory, { recursive: true });
+	}
+});