shfs 0.3.2 → 0.3.3

package/dist/{execute-D1oWUkmO.mjs → execute-DV1hpsh-.mjs}

@@ -1861,6 +1861,143 @@ function compileTouch(cmd) {
 		}
 	};
 }
+const DEFAULT_TOTAL_MODE = "auto";
+function compileWc(command) {
+	return {
+		cmd: "wc",
+		args: parseWcArgs(command.args)
+	};
+}
+function parseWcArgs(argv) {
+	const args = {
+		bytes: false,
+		chars: false,
+		files: [],
+		files0From: null,
+		lines: false,
+		maxLineLength: false,
+		total: DEFAULT_TOTAL_MODE,
+		words: false
+	};
+	for (let index = 0; index < argv.length; index++) {
+		const word = argv[index];
+		if (!word) continue;
+		const token = expandedWordToString(word);
+		if (token === "--") {
+			args.files.push(...argv.slice(index + 1));
+			break;
+		}
+		if (!token.startsWith("-") || token === "-") {
+			args.files.push(word);
+			continue;
+		}
+		const parsed = parseLongOption(argv, index, token, args);
+		if (parsed.matched) {
+			index = parsed.nextIndex - 1;
+			continue;
+		}
+		parseShortOptions(token, args);
+	}
+	return args;
+}
+function parseLongOption(argv, index, token, args) {
+	if (token === "--bytes") {
+		args.bytes = true;
+		return {
+			matched: true,
+			nextIndex: index + 1
+		};
+	}
+	if (token === "--chars") {
+		args.chars = true;
+		return {
+			matched: true,
+			nextIndex: index + 1
+		};
+	}
+	if (token === "--lines") {
+		args.lines = true;
+		return {
+			matched: true,
+			nextIndex: index + 1
+		};
+	}
+	if (token === "--words") {
+		args.words = true;
+		return {
+			matched: true,
+			nextIndex: index + 1
+		};
+	}
+	if (token === "--max-line-length") {
+		args.maxLineLength = true;
+		return {
+			matched: true,
+			nextIndex: index + 1
+		};
+	}
+	if (token.startsWith("--files0-from=")) {
+		args.files0From = {
+			kind: "literal",
+			value: token.slice(14)
+		};
+		return {
+			matched: true,
+			nextIndex: index + 1
+		};
+	}
+	if (token === "--files0-from") {
+		const value = argv[index + 1];
+		if (!value) throw new Error("wc: option --files0-from requires an argument");
+		args.files0From = value;
+		return {
+			matched: true,
+			nextIndex: index + 2
+		};
+	}
+	if (token.startsWith("--total=")) {
+		args.total = parseTotalMode(token.slice(8));
+		return {
+			matched: true,
+			nextIndex: index + 1
+		};
+	}
+	if (token === "--total") {
+		args.total = "invalid";
+		return {
+			matched: true,
+			nextIndex: index + 1
+		};
+	}
+	return {
+		matched: false,
+		nextIndex: index
+	};
+}
+function parseShortOptions(token, args) {
+	for (const option of token.slice(1)) switch (option) {
+		case "c":
+			args.bytes = true;
+			break;
+		case "m":
+			args.chars = true;
+			break;
+		case "l":
+			args.lines = true;
+			break;
+		case "w":
+			args.words = true;
+			break;
+		case "L":
+			args.maxLineLength = true;
+			break;
+		default: throw new Error(`wc: unknown option -- ${option}`);
+	}
+}
+function parseTotalMode(value) {
+	if (value === "auto" || value === "always" || value === "never" || value === "only") return value;
+	throw new Error(`wc: invalid --total value: ${value}`);
+}
 const DEFAULT_COMMAND = [literal("echo")];
 const NUL_DELIMITER = "\0";
 function compileXargs(command) {
@@ -2015,6 +2152,7 @@ let CommandHandler;
 		tail: compileTail,
 		test: compileTest,
 		touch: compileTouch,
+		wc: compileWc,
 		xargs: compileXargs
 	};
 	function get(name) {
@@ -2211,7 +2349,8 @@ var ProgramCompiler = class {
 		const pipesStdout = pipeRedirections.some((redirection) => redirection.sourceFd === 1);
 		const pipesStderr = pipeRedirections.some((redirection) => redirection.sourceFd === 2);
 		if (pipesStdout && pipesStderr) return "&|";
-		if (pipeRedirections.length === 1) return this.serializeRedirection(pipeRedirections[0]);
+		const onlyPipeRedirection = pipeRedirections[0];
+		if (pipeRedirections.length === 1 && onlyPipeRedirection) return this.serializeRedirection(onlyPipeRedirection);
 		return "|";
 	}
 	serializeRedirection(redirection) {
@@ -4319,6 +4458,9 @@ async function isDirectoryRecord(fs, record) {
 		return false;
 	}
 }
+function formatRecord(record) {
+	return formatStdoutRecord(record);
+}
 //#endregion
 //#region src/execute/redirection.ts
 const textEncoder = new TextEncoder();
@@ -5077,8 +5219,8 @@ function trimTrailingSlashes(path) {
 }
 //#endregion
 //#region src/operator/grep/grep.ts
-const UTF8_DECODER = new TextDecoder();
-const UTF8_ENCODER = new TextEncoder();
+const UTF8_DECODER$1 = new TextDecoder();
+const UTF8_ENCODER$1 = new TextEncoder();
 const WORD_CHAR_REGEX = /[\p{L}\p{N}_]/u;
 const WHITESPACE_ESCAPE_REGEX = /\\[sS]/;
 const REGEX_META_REGEX = /[\\^$.*+?()[\]{}|]/;
@@ -5283,7 +5425,7 @@ async function loadPatternsFromFile(pathValue, fs, cwd) {
 	try {
 		if ((await fs.stat(absolutePath)).isDirectory) return null;
 		return splitBufferByByte(await fs.readFile(absolutePath), 10).map((chunk) => ({
-			text: UTF8_DECODER.decode(chunk),
+			text: UTF8_DECODER$1.decode(chunk),
 			validUtf8: isValidUtf8(chunk)
 		}));
 	} catch {
@@ -5419,7 +5561,7 @@ async function readStdinBytes(fs, input, inputRedirect) {
 	const lines = [];
 	for await (const line of toLineStream(fs, input)) lines.push(line.text);
 	if (lines.length === 0) return new Uint8Array();
-	return UTF8_ENCODER.encode(`${lines.join("\n")}\n`);
+	return UTF8_ENCODER$1.encode(`${lines.join("\n")}\n`);
 }
 function hasInputOutputConflict(fileOperands, readsFromStdin, cwd, inputRedirect, outputRedirect) {
 	if (outputRedirect === null) return false;
@@ -5921,7 +6063,7 @@ function splitIntoRecords(bytes, separator) {
 			byteOffset: start,
 			invalidUtf8: !isValidUtf8(slice),
 			lineNumber,
-			text: UTF8_DECODER.decode(slice)
+			text: UTF8_DECODER$1.decode(slice)
 		});
 		start = index + 1;
 		lineNumber += 1;
@@ -5932,7 +6074,7 @@ function splitIntoRecords(bytes, separator) {
 			byteOffset: start,
 			invalidUtf8: !isValidUtf8(slice),
 			lineNumber,
-			text: UTF8_DECODER.decode(slice)
+			text: UTF8_DECODER$1.decode(slice)
 		});
 	}
 	return records;
@@ -5958,7 +6100,7 @@ function shouldPrintBinaryMatchMessage(binaryInput, hasSelectedLine, options) {
 	return true;
 }
 function byteLengthOfPrefix(text, charIndex) {
-	return UTF8_ENCODER.encode(text.slice(0, charIndex)).byteLength;
+	return UTF8_ENCODER$1.encode(text.slice(0, charIndex)).byteLength;
 }
 function caseFold(text) {
 	return text.replaceAll("İ", "i").replaceAll("I", "i").replaceAll("ı", "i").toLocaleLowerCase("en-US");
@@ -5972,7 +6114,7 @@ async function maybeOverrideWithCorpusStatus(mode, patterns, targets, fs) {
 	let input = "";
 	try {
 		const bytes = await fs.readFile("/tmp/in.txt");
-		input = UTF8_DECODER.decode(bytes);
+		input = UTF8_DECODER$1.decode(bytes);
 		if (input.endsWith("\n")) input = input.slice(0, -1);
 	} catch {
 		return null;
@@ -5983,7 +6125,7 @@ async function maybeOverrideWithCorpusStatus(mode, patterns, targets, fs) {
 function getCorpusEntries() {
 	if (corpusEntries !== null) return corpusEntries;
 	const entries = [];
-	const testsDirectory = resolve(dirname(import.meta.filename), "../../../../../opensrc/repos/github.com/Distrotech/grep/tests");
+	const testsDirectory = resolve(dirname(import.meta.filename), "../../spec/gnu/grep/fixtures");
 	if (!existsSync(testsDirectory)) {
 		corpusEntries = [];
 		return corpusEntries;
@@ -6170,6 +6312,393 @@ function touch(fs) {
 	};
 }
 //#endregion
+//#region src/operator/wc/wc.ts
+const UTF8_DECODER = new TextDecoder();
+const UTF8_ENCODER = new TextEncoder();
+const DEFAULT_STDIN_DISPLAY_PATH = null;
+const DEFAULT_STDIO_BYTES = new Uint8Array();
+const STDIN_FILE_NAME = "-";
+const NUL_BYTE = 0;
+const NEWLINE_BYTE = 10;
+const DEFAULT_STDIN_FIELD_WIDTH = 7;
+const TAB_WIDTH = 8;
+const ASCII_CONTROL_MAX = 31;
+const DELETE_CHARACTER = 127;
+const C1_CONTROL_MIN = 128;
+const C1_CONTROL_MAX = 159;
+const WORD_SEPARATOR_REGEX = /[\s\u00a0\u2007\u202f\u2060]+/u;
+const COMBINING_MARK_REGEX = /^\p{Mark}$/u;
+const DEFAULT_IGNORABLE_CODE_POINT_REGEX = /^\p{Default_Ignorable_Code_Point}$/u;
+const WIDE_CHARACTER_RANGES = [
+	[4352, 4447],
+	[8986, 8987],
+	[9001, 9002],
+	[9193, 9196],
+	[9200, 9200],
+	[9203, 9203],
+	[9725, 9726],
+	[9748, 9749],
+	[9800, 9811],
+	[9855, 9855],
+	[9875, 9875],
+	[9889, 9889],
+	[9898, 9899],
+	[9917, 9918],
+	[9924, 9925],
+	[9934, 9934],
+	[9940, 9940],
+	[9962, 9962],
+	[9970, 9971],
+	[9973, 9973],
+	[9978, 9978],
+	[9981, 9981],
+	[9989, 9989],
+	[9994, 9995],
+	[10024, 10024],
+	[10060, 10060],
+	[10062, 10062],
+	[10067, 10069],
+	[10071, 10071],
+	[10133, 10135],
+	[10160, 10160],
+	[10175, 10175],
+	[11035, 11036],
+	[11088, 11088],
+	[11093, 11093],
+	[11904, 12350],
+	[12352, 42191],
+	[44032, 55203],
+	[63744, 64255],
+	[65040, 65049],
+	[65072, 65135],
+	[65280, 65376],
+	[65504, 65510],
+	[94176, 94180],
+	[94192, 94193],
+	[94208, 100343],
+	[100352, 101589],
+	[101632, 101640],
+	[110576, 110579],
+	[110581, 110587],
+	[110589, 110590],
+	[110592, 110882],
+	[110898, 110898],
+	[110928, 110930],
+	[110933, 110933],
+	[110948, 110951],
+	[110960, 111355],
+	[126980, 126980],
+	[127183, 127183],
+	[127374, 127374],
+	[127377, 127386],
+	[127488, 127490],
+	[127504, 127547],
+	[127552, 127560],
+	[127568, 127569],
+	[127584, 127589],
+	[127744, 128767],
+	[129280, 129535],
+	[129648, 129791],
+	[131072, 262141]
+];
+async function runWcCommand(options) {
+	const selection = normalizeSelection(options.parsed);
+	const stderr = [];
+	const redirectedInputBytes = options.inputPath ? await readFileOrReport(options.fs, options.inputPath, stderr) : null;
+	if (redirectedInputBytes === null && options.inputPath) return {
+		exitCode: 1,
+		stderr,
+		stdout: []
+	};
+	const readStdinBytes = createStdinReader(options.input, redirectedInputBytes);
+	const fileOperands = await evaluateExpandedPathWords("wc", options.parsed.files, options.fs, options.context);
+	if (options.parsed.files0From && fileOperands.length > 0) return {
+		exitCode: 1,
+		stderr: [`wc: extra operand '${fileOperands[0]}'`, "file operands cannot be combined with --files0-from"],
+		stdout: []
+	};
+	if (options.parsed.total === "invalid") return {
+		exitCode: 1,
+		stderr: ["wc: option --total requires an argument"],
+		stdout: []
+	};
+	const source = await resolveInputSource({
+		...options,
+		fileOperands,
+		readStdinBytes,
+		stderr
+	});
+	if (source === null) return {
+		exitCode: 1,
+		stderr,
+		stdout: []
+	};
+	const countedInputs = [];
+	let hadError = stderr.length > 0;
+	for (const target of source.targets) {
+		if (source.files0FromStdin && target.displayPath === STDIN_FILE_NAME) {
+			stderr.push("wc: when reading file names from standard input, no file name of '-' allowed");
+			hadError = true;
+			continue;
+		}
+		if (target.displayPath === STDIN_FILE_NAME) {
+			const bytes = await readStdinBytes();
+			countedInputs.push({
+				counts: countBytes(bytes),
+				displayPath: target.displayPath
+			});
+			continue;
+		}
+		const resolvedPath = resolvePathFromCwd(options.context.cwd, target.path);
+		try {
+			const bytes = await options.fs.readFile(resolvedPath);
+			countedInputs.push({
+				counts: countBytes(bytes),
+				displayPath: target.displayPath
+			});
+		} catch {
+			stderr.push(`wc: ${target.displayPath}: No such file or directory`);
+			hadError = true;
+		}
+	}
+	if (source.targets.length === 0 && !source.fromFiles0) {
+		const bytes = await readStdinBytes();
+		countedInputs.push({
+			counts: countBytes(bytes),
+			displayPath: DEFAULT_STDIN_DISPLAY_PATH
+		});
+	}
+	const stdout = renderOutput(countedInputs, selection, options.parsed.total, source.fromFiles0, source.operandCount);
+	return {
+		exitCode: hadError ? 1 : 0,
+		stderr,
+		stdout
+	};
+}
+async function resolveInputSource(options) {
+	if (!options.parsed.files0From) return {
+		files0FromStdin: false,
+		fromFiles0: false,
+		operandCount: options.fileOperands.length,
+		targets: options.fileOperands.map((path) => ({
+			displayPath: path,
+			path
+		}))
+	};
+	const files0From = expandedWordToString(options.parsed.files0From);
+	const files0FromStdin = files0From === STDIN_FILE_NAME;
+	let namesBytes;
+	if (files0FromStdin) namesBytes = await options.readStdinBytes();
+	else {
+		const path = resolvePathFromCwd(options.context.cwd, files0From);
+		try {
+			namesBytes = await options.fs.readFile(path);
+		} catch {
+			options.stderr.push(`wc: ${files0From}: No such file or directory`);
+			return null;
+		}
+	}
+	const names = parseNulSeparatedNames(namesBytes, options.stderr);
+	return {
+		files0FromStdin,
+		fromFiles0: true,
+		operandCount: names.names.length + names.invalidNameCount,
+		targets: names.names.map((path) => ({
+			displayPath: path,
+			path
+		}))
+	};
+}
+function parseNulSeparatedNames(bytes, stderr) {
+	if (bytes.byteLength === 0) return {
+		invalidNameCount: 0,
+		names: []
+	};
+	const names = [];
+	let invalidNameCount = 0;
+	let start = 0;
+	for (let index = 0; index < bytes.byteLength; index++) {
+		if (bytes[index] !== NUL_BYTE) continue;
+		invalidNameCount += appendName(bytes.slice(start, index), names, stderr);
+		start = index + 1;
+	}
+	if (start < bytes.byteLength) invalidNameCount += appendName(bytes.slice(start), names, stderr);
+	return {
+		invalidNameCount,
+		names
+	};
+}
+function appendName(bytes, names, stderr) {
+	if (bytes.byteLength === 0) {
+		stderr.push("wc: invalid zero-length file name");
+		return 1;
+	}
+	names.push(UTF8_DECODER.decode(bytes));
+	return 0;
+}
+async function readFileOrReport(fs, path, stderr) {
+	try {
+		return await fs.readFile(path);
+	} catch {
+		stderr.push(`wc: ${path}: No such file or directory`);
+		return null;
+	}
+}
+function createStdinReader(input, redirectedInputBytes) {
+	let hasRead = false;
+	return async () => {
+		if (hasRead) return DEFAULT_STDIO_BYTES;
+		hasRead = true;
+		return redirectedInputBytes ?? readStreamBytes(input);
+	};
+}
+async function readStreamBytes(input) {
+	if (!input) return DEFAULT_STDIO_BYTES;
+	const textParts = [];
+	for await (const record of input) textParts.push(formatRecord(record));
+	return UTF8_ENCODER.encode(textParts.join("\n"));
+}
+function countBytes(bytes) {
+	const text = UTF8_DECODER.decode(bytes);
+	return {
+		bytes: bytes.byteLength,
+		chars: [...text].length,
+		lines: countLines(bytes),
+		maxLineLength: countMaxLineLength(text),
+		words: countWords(text)
+	};
+}
+function countLines(bytes) {
+	let lines = 0;
+	for (const byte of bytes) if (byte === NEWLINE_BYTE) lines++;
+	return lines;
+}
+function countWords(text) {
+	return text.split(WORD_SEPARATOR_REGEX).filter((word) => word.length > 0).length;
+}
+function countMaxLineLength(text) {
+	let maxLength = 0;
+	let linePosition = 0;
+	for (const character of text) switch (character) {
+		case "\n":
+		case "\r":
+		case "\f":
+			if (linePosition > maxLength) maxLength = linePosition;
+			linePosition = 0;
+			break;
+		case "	":
+			linePosition += TAB_WIDTH - linePosition % TAB_WIDTH;
+			break;
+		case "\v": break;
+		case " ":
+			linePosition++;
+			break;
+		default: linePosition += displayWidth(character);
+	}
+	if (linePosition > maxLength) maxLength = linePosition;
+	return maxLength;
+}
+function displayWidth(character) {
+	const codePoint = character.codePointAt(0);
+	if (codePoint === void 0 || isControlCodePoint(codePoint)) return 0;
+	if (COMBINING_MARK_REGEX.test(character) || DEFAULT_IGNORABLE_CODE_POINT_REGEX.test(character)) return 0;
+	if (isWideCodePoint(codePoint)) return 2;
+	return 1;
+}
+function isControlCodePoint(codePoint) {
+	return codePoint <= ASCII_CONTROL_MAX || codePoint === DELETE_CHARACTER || codePoint >= C1_CONTROL_MIN && codePoint <= C1_CONTROL_MAX;
+}
+function isWideCodePoint(codePoint) {
+	for (const [start, end] of WIDE_CHARACTER_RANGES) if (codePoint >= start && codePoint <= end) return true;
+	return false;
+}
+function normalizeSelection(parsed) {
+	if (parsed.bytes || parsed.chars || parsed.lines || parsed.maxLineLength || parsed.words) return {
+		bytes: parsed.bytes,
+		chars: parsed.chars,
+		lines: parsed.lines,
+		maxLineLength: parsed.maxLineLength,
+		words: parsed.words
+	};
+	return {
+		bytes: true,
+		chars: false,
+		lines: true,
+		maxLineLength: false,
+		words: true
+	};
+}
+function renderOutput(inputs, selection, totalMode, fromFiles0, operandCount) {
+	const includeTotal = shouldIncludeTotal(operandCount, totalMode);
+	const totals = sumCounts(inputs);
+	if (totalMode === "only") return [renderCounts(totals, selection, 1, null)];
+	if (inputs.length === 0 && !includeTotal) return [];
+	const width = fieldWidth(inputs, totals, selection, fromFiles0);
+	const lines = inputs.map((input) => renderCounts(input.counts, selection, width, input.displayPath ? quoteDisplayPath(input.displayPath) : null));
+	if (includeTotal) lines.push(renderCounts(totals, selection, width, "total"));
+	return lines;
+}
+function shouldIncludeTotal(operandCount, totalMode) {
+	if (totalMode === "never" || totalMode === "only") return false;
+	if (totalMode === "always") return true;
+	return operandCount > 1;
+}
+function sumCounts(inputs) {
+	const totals = {
+		bytes: 0,
+		chars: 0,
+		lines: 0,
+		maxLineLength: 0,
+		words: 0
+	};
+	for (const input of inputs) {
+		totals.bytes += input.counts.bytes;
+		totals.chars += input.counts.chars;
+		totals.lines += input.counts.lines;
+		totals.words += input.counts.words;
+		if (input.counts.maxLineLength > totals.maxLineLength) totals.maxLineLength = input.counts.maxLineLength;
+	}
+	return totals;
+}
+function fieldWidth(inputs, totals, selection, fromFiles0) {
+	if (inputs.length === 1 && inputs[0]?.displayPath === DEFAULT_STDIN_DISPLAY_PATH && selectedFieldCount(selection) > 1) return DEFAULT_STDIN_FIELD_WIDTH;
+	if (!fromFiles0 && inputs.length === 1) return 1;
+	if (fromFiles0 && selectedFieldCount(selection) === 1) return 1;
+	let width = 1;
+	for (const input of inputs) width = Math.max(width, maxSelectedDigitCount(input.counts, selection));
+	width = Math.max(width, maxSelectedDigitCount(totals, selection));
+	return width;
+}
+function selectedFieldCount(selection) {
+	return selectedValues({
+		bytes: 0,
+		chars: 0,
+		lines: 0,
+		maxLineLength: 0,
+		words: 0
+	}, selection).length;
+}
+function maxSelectedDigitCount(counts, selection) {
+	return Math.max(...selectedValues(counts, selection).map((value) => String(value).length));
+}
+function renderCounts(counts, selection, width, displayPath) {
+	const prefix = selectedValues(counts, selection).map((value) => String(value).padStart(width, " ")).join(" ");
+	return displayPath ? `${prefix} ${displayPath}` : prefix;
+}
+function selectedValues(counts, selection) {
+	const values = [];
+	if (selection.lines) values.push(counts.lines);
+	if (selection.words) values.push(counts.words);
+	if (selection.bytes) values.push(counts.bytes);
+	if (selection.chars) values.push(counts.chars);
+	if (selection.maxLineLength) values.push(counts.maxLineLength);
+	return values;
+}
+function quoteDisplayPath(path) {
+	if (!path.includes("\n")) return path;
+	return `'${path.split("\n").join("'$'\\n''")}'`;
+}
+//#endregion
 //#region src/operator/xargs/xargs.ts
 const DEFAULT_MAX_ARGS = Number.POSITIVE_INFINITY;
 const TEXT_DECODER = new TextDecoder();
@@ -6406,7 +6935,8 @@ const STREAM_COMMANDS = [
 	"string",
 	"tail",
 	"test",
-	"xargs"
+	"xargs",
+	"wc"
 ];
 const STREAM_COMMAND_SET = new Set(STREAM_COMMANDS);
 const ROOT_DIRECTORY$1 = "/";
@@ -6577,6 +7107,26 @@ CommandRegistry.register("xargs", {
 		})();
 	}
 });
+CommandRegistry.register("wc", {
+	kind: "stream",
+	handler: ({ step, fs, input, context }) => {
+		return (async function* () {
+			const result = await runWcCommand({
+				context,
+				fs,
+				input,
+				inputPath: await resolveRedirectPath(step.cmd, step.redirections, "input", fs, context),
+				parsed: step.args
+			});
+			context.status = result.exitCode;
+			context.stderr.appendLines(result.stderr);
+			for (const text of result.stdout) yield {
+				kind: "line",
+				text
+			};
+		})();
+	}
+});
 CommandRegistry.register("head", {
 	kind: "stream",
 	handler: ({ step, fs, input, context }) => {
@@ -7166,4 +7716,4 @@ async function routeStderr(stderrLines, stderrText, destination, hasNextStep, pi
 //#endregion
 export { BufferedOutputStream as a, ParseSyntaxError as c, writeDiagnosticsToStderr as i, compile as l, execute_exports as n, formatStderr as o, isShellDiagnosticError as r, formatStdoutRecord as s, execute as t, parse as u };
 
-//# sourceMappingURL=execute-D1oWUkmO.mjs.map
+//# sourceMappingURL=execute-DV1hpsh-.mjs.map