From c11e17573334dfb487a8e1cc25fa84fa9e138f5c Mon Sep 17 00:00:00 2001 From: Lily <129828376+Soccera1@users.noreply.github.com> Date: Tue, 28 Jul 2026 16:12:21 +1000 Subject: Refactor coreutils into single-call command modules (#1) * Refactor to single call --- src/shared/checksum.js | 265 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 265 insertions(+) create mode 100644 src/shared/checksum.js (limited to 'src/shared/checksum.js') diff --git a/src/shared/checksum.js b/src/shared/checksum.js new file mode 100644 index 0000000..7e7e40f --- /dev/null +++ b/src/shared/checksum.js @@ -0,0 +1,265 @@ +import { readSync } from "node:fs"; +import { open } from "node:fs/promises"; +import { localeQuotedEscapedDiagnostic, normalizeLongOptionByPrefix, normalizeLongOptionsByPrefix, pathDisplayName, shellEscapeLsName } from "./common.js"; +import { UsageError, stdout } from "./diagnostics.js"; + +export const BASE_ENCODING_LONG_OPTIONS = ["decode", "ignore-garbage", "wrap", "help", "version"]; + +export function baseEncodingMetaOption(args) { + return baseLikeMetaOption(args, BASE_ENCODING_LONG_OPTIONS, normalizeBaseEncodingLongOption); +} + +export function baseLikeMetaOption(args, longOptions, normalizeLongOption) { + for (let i = 0; i < args.length; i++) { + const arg = args[i]; + if (arg === "--") return null; + if (arg.startsWith("--")) { + const option = normalizeLongOption(arg); + const [name, inlineValue] = option.slice(2).split(/=(.*)/s, 2); + if (!longOptions.includes(name)) return null; + if ((option === "--help" || option === "--version") && inlineValue == null) return option; + if (name === "wrap") { + const value = inlineValue ?? args[i + 1]; + if (value !== undefined) parseWrap(value); + if (inlineValue == null) i++; + } + else if (inlineValue != null && name !== "wrap") return null; + continue; + } + if (!arg.startsWith("-") || arg === "-") continue; + for (let j = 1; j < arg.length; j++) { + const ch = arg[j]; + if (!["d", "i", "w"].includes(ch)) return null; + if (ch === "w") { + const inlineValue = arg.slice(j + 1); + const value = inlineValue === "" ? args[i + 1] : inlineValue; + if (value !== undefined) parseWrap(value); + if (inlineValue === "") i++; + break; + } + } + } + return null; +} + +export function baseEncodingDiagnosticName(file) { + return shellEscapeLsName(pathDisplayName(file)); +} + +export function ensureSingleInputOperand(operands) { + if (operands.length > 1) throw new UsageError(`extra operand ${localeQuotedEscapedDiagnostic(operands[1])}`, true); +} + +export function parseWrap(value) { + const text = String(value); + if (!/^\+?\d+$/.test(text)) throw new UsageError(`invalid wrap size: ${localeQuotedEscapedDiagnostic(text)}`); + const parsed = BigInt(text); + if (parsed > 9223372036854775807n) return 0; + const wrap = parsed > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(parsed); + return wrap; +} + +export function formatEncodedOutput(encoded, wrap) { + if (encoded === "") return ""; + if (wrap === 0) return encoded; + if (wrap >= encoded.length) return `${encoded}\n`; + return `${encoded.match(new RegExp(`.{1,${wrap}}`, "g"))?.join("\n") ?? ""}\n`; +} + +export function normalizeBaseEncodingLongOptions(args) { + return normalizeLongOptionsByPrefix(args, BASE_ENCODING_LONG_OPTIONS); +} + +export function normalizeBaseEncodingLongOption(arg) { + return normalizeLongOptionByPrefix(arg, BASE_ENCODING_LONG_OPTIONS); +} + +export function decodeBase64(text, ignoreGarbage = false, url = false) { + let cleaned = text.replace(/\s+/g, ""); + const alphabet = url ? "A-Za-z0-9_\\-=" : "A-Za-z0-9+/="; + if (ignoreGarbage) cleaned = cleaned.replace(new RegExp(`[^${alphabet}]`, "g"), ""); + else { + const invalid = cleaned.search(new RegExp(`[^${alphabet}]`)); + if (invalid !== -1) { + const prefix = decodeBase64Clean(cleaned.slice(0, invalid), url).bytes; + if (prefix.length) stdout(prefix); + throw new UsageError("invalid input"); + } + } + const decoded = decodeBase64Clean(cleaned, url); + if (!decoded.valid) { + if (decoded.bytes.length) stdout(decoded.bytes); + throw new UsageError("invalid input"); + } + return decoded.bytes; +} + +export function base64Alphabet(text, url = false) { + return url ? text.replaceAll("-", "+").replaceAll("_", "/") : text; +} + +export function decodeBase64Clean(text, url = false) { + const chunks = []; + let valid = true; + let i = 0; + while (i < text.length) { + let start = i; + while (i < text.length && text[i] !== "=") i++; + let base = text.slice(start, i); + let pads = ""; + while (i < text.length && text[i] === "=") pads += text[i++]; + if (base.length === 0 && pads.length > 0) { + valid = false; + break; + } + if (base.length === 0) continue; + const segment = decodeBase64Segment(base, pads, url); + if (segment.bytes.length) chunks.push(segment.bytes); + if (!segment.valid) { + valid = false; + break; + } + } + return { bytes: Buffer.concat(chunks), valid }; +} + +export function decodeBase64Segment(base, pads, url = false) { + const needPads = (4 - (base.length % 4)) % 4; + const bytes = base.length % 4 === 1 + ? Buffer.from(base64Alphabet(base.slice(0, base.length - 1), url), "base64") + : Buffer.from(base64Alphabet(base + "=".repeat(needPads), url), "base64"); + let valid = base.length % 4 !== 1; + if (pads.length) { + valid &&= pads.length <= 2; + valid &&= (base.length + pads.length) % 4 === 0; + if (pads.length === 1) valid &&= base.length % 4 === 3 && (base64DigitValue(base.at(-1), url) & 0b11) === 0; + else if (pads.length === 2) valid &&= base.length % 4 === 2 && (base64DigitValue(base.at(-1), url) & 0b1111) === 0; + else valid = false; + } else if (base.length % 4 === 2) { + valid &&= (base64DigitValue(base.at(-1), url) & 0b1111) === 0; + } else if (base.length % 4 === 3) { + valid &&= (base64DigitValue(base.at(-1), url) & 0b11) === 0; + } + return { bytes, valid }; +} + +export function base64DigitValue(ch, url = false) { + const alphabet = url ? "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_" : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + return alphabet.indexOf(ch); +} + +export async function forEachInputChunk(file, callback) { + const buffer = Buffer.allocUnsafe(256 * 1024); + if (file === "-") { + while (true) { + const n = readSync(0, buffer, 0, buffer.length, null); + if (n === 0) break; + callback(buffer.subarray(0, n)); + } + return; + } + const handle = await open(file, "r"); + try { + while (true) { + const { bytesRead } = await handle.read(buffer, 0, buffer.length, null); + if (bytesRead === 0) break; + callback(buffer.subarray(0, bytesRead)); + } + } finally { + await handle.close(); + } +} + +export async function sumForFile(file, sysv = false) { + let length = 0; + let sum = 0; + await forEachInputChunk(file, (chunk) => { + length += chunk.length; + for (const byte of chunk) { + if (sysv) sum = (sum + byte) % 0x100000000; + else sum = ((sum >> 1) + ((sum & 1) << 15) + byte) & 0xffff; + } + }); + if (sysv) { + sum = (sum & 0xffff) + Math.floor(sum / 0x10000); + sum = (sum & 0xffff) + Math.floor(sum / 0x10000); + } + return { sum, blocks: Math.ceil(length / (sysv ? 512 : 1024)) }; +} + +export function base32Encode(data) { + const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"; + let bits = 0; + let value = 0; + let out = ""; + for (const byte of data) { + value = (value << 8) | byte; + bits += 8; + while (bits >= 5) { + out += alphabet[(value >>> (bits - 5)) & 31]; + bits -= 5; + } + } + if (bits > 0) out += alphabet[(value << (5 - bits)) & 31]; + while (out.length % 8) out += "="; + return out; +} + +export function base32Decode(text) { + const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"; + const decoded = decodeBase32Clean(text, alphabet); + if (!decoded.valid) { + if (decoded.bytes.length) stdout(decoded.bytes); + throw new UsageError("invalid input"); + } + return decoded.bytes; +} + +export function decodeBase32Clean(text, alphabet) { + const chunks = []; + let valid = true; + let i = 0; + while (i < text.length) { + let start = i; + while (i < text.length && text[i] !== "=") i++; + const base = text.slice(start, i); + let pads = ""; + while (i < text.length && text[i] === "=") pads += text[i++]; + if (base.length === 0 && pads.length > 0) { + valid = false; + break; + } + if (base.length === 0) continue; + const segment = decodeBase32Segment(base, pads, alphabet); + if (segment.bytes.length) chunks.push(segment.bytes); + if (!segment.valid) { + valid = false; + break; + } + } + return { bytes: Buffer.concat(chunks), valid }; +} + +export function decodeBase32Segment(base, pads, alphabet) { + let bits = 0; + let value = 0; + const out = []; + for (const ch of base) { + const idx = alphabet.indexOf(ch); + if (idx === -1) { + return { bytes: Uint8Array.from(out), valid: false }; + } + value = (value << 5) | idx; + bits += 5; + if (bits >= 8) { + out.push((value >>> (bits - 8)) & 255); + bits -= 8; + } + } + const padByRemainder = new Map([[0, 0], [2, 6], [4, 4], [5, 3], [7, 1]]); + const expectedPads = padByRemainder.get(base.length % 8); + let valid = expectedPads !== undefined; + if (pads.length) valid &&= pads.length === expectedPads && (base.length + pads.length) % 8 === 0; + valid &&= bits === 0 || (value & ((1 << bits) - 1)) === 0; + return { bytes: Uint8Array.from(out), valid }; +} -- cgit v1.3