@poe-platform/safe-bash 0.1.788 → 0.1.790

package/dist/safe-bash/commands/cmp.js

@@ -1,690 +1,3 @@
-import { FsError, getCommandArguments, isFsError } from "../contracts/index.js";
-import { yieldTurn } from "../contracts/yield.js";
-import { assertCommandRequirements } from "../contracts/command-requirements.js";
-import { PublicDiagnostic, publicDiagnosticMessage } from "../diagnostics.js";
-import { ByteInputBudget } from "./bytes/input-budget.js";
-import { bufferLimit, output, pathOf, UsageError } from "./internal.js";
-import { inputRequirements } from "./portable-requirements.js";
-import { compareCopyIdentity, compareObservedEntries } from "./copy-identity.js";
-const blockBytes = 4096;
-const maxCount = 18446744073709551616n;
-function byteCount(text, option = "bytes") {
-    const invalid = () => { throw new UsageError(`invalid --${option} value '${text}'`); };
-    let position = 0;
-    while (text[position] === " " || text.charCodeAt(position) >= 9 && text.charCodeAt(position) <= 13)
-        position++;
-    if (text[position] === "+")
-        position++;
-    let base = 10;
-    if (text[position] === "0") {
-        base = 8;
-        if (text[position + 1]?.toLowerCase() === "x") {
-            base = 16;
-            position += 2;
-        }
-    }
-    const start = position;
-    let count = 0n;
-    const maximum = option === "bytes" ? 18446744073709551615n : 9223372036854775807n;
-    while (position < text.length) {
-        const digit = "0123456789abcdef".indexOf(text[position].toLowerCase());
-        if (digit < 0 || digit >= base)
-            break;
-        count = count * BigInt(base) + BigInt(digit);
-        if (count > maximum)
-            invalid();
-        position++;
-    }
-    const suffix = text.slice(position);
-    if (position === start) {
-        if (position !== 0 || !"kKMGTPEZY".includes(suffix[0] ?? " "))
-            invalid();
-        count = 1n;
-    }
-    if (suffix) {
-        const power = "KMGTPEZY".indexOf(suffix[0] === "k" ? "K" : suffix[0]) + 1;
-        if (!power || !["", "B", "D", "iB"].includes(suffix.slice(1)))
-            invalid();
-        count *= (suffix.endsWith("B") && !suffix.endsWith("iB") || suffix.endsWith("D") ? 1000n : 1024n) ** BigInt(power);
-    }
-    if (count > maximum)
-        invalid();
-    return count;
-}
-function parse(context) {
-    const parsed = { names: [], skips: [0n, 0n], limit: maxCount, silent: false, verbose: false, printBytes: false };
-    const long = { "print-bytes": "b", "print-chars": "c", "ignore-initial": "i", verbose: "l", bytes: "n", silent: "s", quiet: "s", version: "v", help: "help" };
-    const operands = [];
-    const argumentsWithBytes = getCommandArguments(context);
-    const args = context.args.map((_argument, index) => {
-        const bytes = argumentsWithBytes.bytes(index);
-        return Array.from(bytes, byte => String.fromCharCode(byte)).join("");
-    });
-    let ended = false;
-    const apply = (key, argument) => {
-        if (key === "s" || key === "l") {
-            if (key === "s" ? parsed.verbose : parsed.silent)
-                throw new UsageError("options -l and -s are incompatible");
-            if (key === "s")
-                parsed.silent = true;
-            else
-                parsed.verbose = true;
-        }
-        else if (key === "b" || key === "c")
-            parsed.printBytes = true;
-        else if (key === "n") {
-            const next = byteCount(argument);
-            if (next < parsed.limit)
-                parsed.limit = next;
-        }
-        else if (key === "i") {
-            const delimiter = argument.indexOf(":");
-            const first = delimiter < 0 ? argument : argument.slice(0, delimiter);
-            let firstSkip;
-            try {
-                firstSkip = byteCount(first, "ignore-initial");
-            }
-            catch {
-                throw new UsageError(`invalid --ignore-initial value '${argument}'`);
-            }
-            if (firstSkip > parsed.skips[0])
-                parsed.skips[0] = firstSkip;
-            const secondSkip = delimiter < 0 ? firstSkip : byteCount(argument.slice(delimiter + 1), "ignore-initial");
-            if (secondSkip > parsed.skips[1])
-                parsed.skips[1] = secondSkip;
-        }
-        else
-            parsed.information = key === "v" ? "version" : "help";
-    };
-    for (let index = 0; index < args.length; index++) {
-        const argument = args[index];
-        if (ended || argument === "-" || !argument.startsWith("-")) {
-            operands.push(argument);
-            if (Object.hasOwn(context.env, "POSIXLY_CORRECT"))
-                ended = true;
-        }
-        else if (argument === "--")
-            ended = true;
-        else if (argument.startsWith("--")) {
-            const equals = argument.indexOf("=");
-            const name = argument.slice(2, equals < 0 ? undefined : equals);
-            const matches = Object.keys(long).filter(candidate => candidate.startsWith(name));
-            const selected = Object.hasOwn(long, name) ? name : matches[0];
-            if (!Object.hasOwn(long, name) && matches.length > 1 && new Set(matches.map(match => long[match])).size > 1) {
-                throw new UsageError(`option '${argument}' is ambiguous; possibilities: ${matches.map(match => `'--${match}'`).join(" ")}`);
-            }
-            if (!selected)
-                throw new UsageError(`unrecognized option '${argument}'`);
-            const key = long[selected];
-            let value;
-            if (key === "i" || key === "n") {
-                value = equals < 0 ? args[++index] : argument.slice(equals + 1);
-                if (value === undefined)
-                    throw new UsageError(`option '--${selected}' requires an argument`);
-            }
-            else if (equals >= 0)
-                throw new UsageError(`option '--${selected}' doesn't allow an argument`);
-            apply(key, value);
-        }
-        else {
-            for (let offset = 1; offset < argument.length; offset++) {
-                const key = argument[offset];
-                if (!"bcilnsv".includes(key))
-                    throw new UsageError(`invalid option -- '${key}'`);
-                let value;
-                if (key === "i" || key === "n") {
-                    value = argument.slice(offset + 1) || args[++index];
-                    if (value === undefined)
-                        throw new UsageError(`option requires an argument -- '${key}'`);
-                    offset = argument.length;
-                }
-                apply(key, value);
-                if (parsed.information)
-                    return parsed;
-            }
-        }
-        if (parsed.information)
-            return parsed;
-    }
-    if (!operands.length)
-        throw new UsageError(`missing operand after '${args.at(-1) ?? "cmp"}'`);
-    parsed.names = [operands[0], operands[1] ?? "-"];
-    for (const index of [0, 1]) {
-        if (operands[index + 2] !== undefined) {
-            const next = byteCount(operands[index + 2], "ignore-initial");
-            if (next > parsed.skips[index])
-                parsed.skips[index] = next;
-        }
-    }
-    if (operands.length > 4)
-        throw new UsageError(`extra operand '${operands[4]}'`);
-    return parsed;
-}
-class InputError extends PublicDiagnostic {
-    suppressInSilent;
-    constructor(message, suppressInSilent) {
-        super(message);
-        this.suppressInSilent = suppressInSilent;
-    }
-}
-function inputError(error, name, opening = false) {
-    if (!(error instanceof FsError))
-        return error;
-    const messages = {
-        EACCES: "Permission denied", EBADF: "Bad file descriptor", EIO: "Input/output error", EISDIR: "Is a directory",
-        ELOOP: "Too many levels of symbolic links", ENAMETOOLONG: "File name too long", ENOENT: "No such file or directory",
-        ENOTDIR: "Not a directory", ENOTSUP: "Operation not supported", EPERM: "Operation not permitted",
-    };
-    const detail = messages[error.code];
-    return detail ? new InputError(`${name}: ${detail}`, opening) : error;
-}
-function printByte(byte) {
-    const prefix = byte >= 128 ? "M-" : "";
-    const character = byte & 127;
-    return prefix + (character < 32 ? `^${String.fromCharCode(character + 64)}` : character === 127 ? "^?" : String.fromCharCode(character));
-}
-async function discardsOutput(context) {
-    if (!context.stdoutFile)
-        return false;
-    const options = { signal: context.signal };
-    try {
-        const paths = [context.stdoutFile.path, "/dev/null"];
-        for (const path of paths) {
-            const capabilities = await context.fs.capabilitiesFor?.(path, options) ?? context.fs.capabilities;
-            context.signal.throwIfAborted();
-            if (capabilities.stat === false)
-                return false;
-        }
-        const target = await context.fs.stat(paths[0], options);
-        const empty = await context.fs.stat(paths[1], options);
-        return await compareObservedEntries(context.fs, paths[0], target, context.fs, paths[1], empty, options) === "same";
-    }
-    catch (error) {
-        context.signal.throwIfAborted();
-        if (error instanceof FsError)
-            return false;
-        throw error;
-    }
-}
-class Cursor {
-    name;
-    context;
-    budget;
-    signal;
-    chargeChunk;
-    bytes = new Uint8Array();
-    offset = 0;
-    size = Infinity;
-    stat;
-    position = 0n;
-    skip = 0;
-    requestBytes = blockBytes;
-    reader;
-    iterator;
-    source;
-    finished = false;
-    retirement;
-    handle;
-    acquisition;
-    handleClosing;
-    operations = new Set();
-    constructor(name, context, budget, signal, chargeChunk) {
-        this.name = name;
-        this.context = context;
-        this.budget = budget;
-        this.signal = signal;
-        this.chargeChunk = chargeChunk;
-    }
-    async open(limit, skip) {
-        this.signal.throwIfAborted();
-        const numericSkip = skip > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(skip);
-        this.skip = numericSkip;
-        if (this.name === "-") {
-            const input = this.context.stdinInput;
-            this.stat = input?.stat;
-            this.position = BigInt(input?.position ?? 0);
-            if (this.stat?.type === "file" && Number.isSafeInteger(this.stat.size) && this.stat.size >= 0) {
-                const remaining = BigInt(this.stat.size) - this.position - skip;
-                this.size = remaining > 0n ? Number(remaining) : 0;
-            }
-            this.source = input ? () => ({ [Symbol.asyncIterator]: () => ({ next: () => input.read(this.requestBytes, this.signal) }) }) : () => this.context.stdin;
-        }
-        else {
-            let name;
-            try {
-                name = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(Uint8Array.from(this.name, unit => unit.charCodeAt(0)));
-            }
-            catch {
-                throw new FsError("ENOENT");
-            }
-            const path = pathOf(this.context, name);
-            const capabilities = await this.context.fs.capabilitiesFor?.(path, { signal: this.signal }) ?? this.context.fs.capabilities;
-            this.signal.throwIfAborted();
-            assertCommandRequirements({ ...this.context, signal: this.signal }, inputRequirements, ["file"], capabilities);
-            let stat;
-            if (capabilities.stat !== false) {
-                try {
-                    stat = await this.context.fs.stat(path, { signal: this.signal });
-                }
-                catch (error) {
-                    this.signal.throwIfAborted();
-                    if (!isFsError(error, "ENOTSUP"))
-                        throw error;
-                }
-            }
-            this.signal.throwIfAborted();
-            if (stat?.type !== "directory" && capabilities.retainedRead === true && this.context.fs.openReadFile) {
-                this.acquisition = this.context.fs.openReadFile(path, { signal: this.signal }).then(handle => { this.handle = handle; return handle; });
-                try {
-                    const handle = await this.acquisition;
-                    this.signal.throwIfAborted();
-                    stat = await this.work(() => handle.stat({ signal: this.signal }));
-                }
-                catch (error) {
-                    this.signal.throwIfAborted();
-                    if (this.handle || !isFsError(error, "ENOTSUP"))
-                        throw error;
-                }
-            }
-            if (!this.handle && capabilities.access !== false) {
-                try {
-                    await this.context.fs.access(path, 4, { signal: this.signal });
-                }
-                catch (error) {
-                    this.signal.throwIfAborted();
-                    if (!isFsError(error, "ENOTSUP"))
-                        throw error;
-                }
-            }
-            this.signal.throwIfAborted();
-            if (!stat && limit === 0)
-                throw new FsError("ENOTSUP", { path, message: "zero-byte comparison requires metadata admission" });
-            this.stat = stat;
-            this.position = skip;
-            if (stat?.type === "file" && Number.isSafeInteger(stat.size) && stat.size >= 0) {
-                const remaining = BigInt(stat.size) - skip;
-                this.size = remaining > 0n ? Number(remaining) : 0;
-            }
-            if (limit === 0 && (this.handle || Number.isFinite(this.size) || this.skip === 0)) {
-                this.skip = 0;
-                return;
-            }
-            if (this.handle) {
-                const handle = this.handle;
-                let position = Number.isFinite(this.size) ? Math.min(numericSkip, stat.size) : numericSkip;
-                this.skip = 0;
-                this.source = () => ({ [Symbol.asyncIterator]: () => ({ next: async () => {
-                            const bytes = await this.work(() => handle.read(position, this.requestBytes, { signal: this.signal }));
-                            if (!(bytes instanceof Uint8Array) || bytes.length > this.requestBytes)
-                                throw new FsError("EIO", { path, message: "invalid retained read size" });
-                            position += bytes.length;
-                            return bytes.length ? { done: false, value: bytes } : { done: true, value: undefined };
-                        } }) });
-            }
-            else if (this.context.fs.readStream && capabilities.streamingRead !== false) {
-                const start = Number.isFinite(this.size) ? Math.min(numericSkip, stat.size) : 0;
-                if (Number.isFinite(this.size))
-                    this.skip = 0;
-                this.source = () => this.context.fs.readStream(path, { signal: this.signal, chunkSize: Math.min(blockBytes, limit || this.skip),
-                    ...(start ? { start } : {}),
-                    ...(limit === Infinity || this.skip ? {} : { endExclusive: Math.min(Number.MAX_SAFE_INTEGER, start + limit) }) });
-            }
-            else {
-                if (capabilities.read === false)
-                    throw new FsError("ENOTSUP", { syscall: "readFile", path });
-                const context = this.context;
-                const signal = this.signal;
-                this.source = () => ({ async *[Symbol.asyncIterator]() {
-                        yield await context.fs.readFile(path, { signal });
-                    } });
-            }
-        }
-    }
-    async prepare() {
-        const input = this.name === "-" ? this.context.stdinInput : undefined;
-        if (input?.seek) {
-            this.signal.throwIfAborted();
-            const targetPosition = Math.min(Number.MAX_SAFE_INTEGER, input.position + this.skip);
-            this.position = BigInt(input.position) + BigInt(this.skip);
-            if (this.skip) {
-                try {
-                    await input.seek(targetPosition, this.signal);
-                }
-                catch (error) {
-                    throw inputError(error, this.name);
-                }
-            }
-            this.signal.throwIfAborted();
-            this.skip = 0;
-            if (this.stat?.type === "file") {
-                const remaining = BigInt(this.stat.size) - this.position;
-                this.size = remaining > 0n ? Number(remaining) : 0;
-            }
-        }
-    }
-    async fill(remaining) {
-        this.signal.throwIfAborted();
-        if (remaining === 0 && this.skip === 0)
-            return false;
-        if (!this.reader) {
-            try {
-                this.iterator = this.source()[Symbol.asyncIterator]();
-            }
-            catch (error) {
-                throw inputError(error, this.name);
-            }
-            this.reader = this.budget.read({ [Symbol.asyncIterator]: () => ({
-                    next: async () => {
-                        let result;
-                        try {
-                            result = await this.iterator.next();
-                        }
-                        catch (error) {
-                            throw inputError(error, this.name);
-                        }
-                        if (result.done)
-                            this.finished = true;
-                        return result;
-                    },
-                    return: async () => { await this.retire(); return { done: true, value: undefined }; },
-                }) }, this.signal)[Symbol.asyncIterator]();
-        }
-        while (this.offset === this.bytes.length) {
-            this.signal.throwIfAborted();
-            if (remaining === 0 && this.skip === 0)
-                return false;
-            this.requestBytes = Math.min(blockBytes, this.skip || remaining);
-            const item = await this.reader.next();
-            if (item.done)
-                return false;
-            await this.chargeChunk();
-            this.bytes = new Uint8Array(item.value);
-            this.offset = Math.min(this.skip, this.bytes.length);
-            this.skip -= this.offset;
-        }
-        return true;
-    }
-    retire() {
-        this.retirement ??= Promise.resolve().then(async () => {
-            try {
-                if (!this.finished)
-                    await this.iterator?.return?.();
-            }
-            catch (error) {
-                throw inputError(error, this.name);
-            }
-        });
-        return this.retirement;
-    }
-    work(operation) {
-        this.signal.throwIfAborted();
-        if (this.handleClosing)
-            throw new FsError("EBADF", { path: this.name });
-        const pending = Promise.resolve().then(() => {
-            this.signal.throwIfAborted();
-            return operation();
-        });
-        this.operations.add(pending);
-        void pending.then(() => { this.operations.delete(pending); }, () => { this.operations.delete(pending); });
-        return pending;
-    }
-    async close() {
-        this.handleClosing ??= Promise.resolve().then(async () => {
-            await this.acquisition?.catch(() => undefined);
-            await Promise.allSettled(this.operations);
-            try {
-                await this.handle?.close();
-            }
-            catch (error) {
-                throw inputError(error, this.name);
-            }
-        });
-        const results = await Promise.allSettled([this.retire(), this.reader?.return?.(), this.handleClosing]);
-        this.bytes = new Uint8Array();
-        for (const result of results)
-            if (result.status === "rejected")
-                throw result.reason;
-    }
-}
-async function compare(context, parsed) {
-    const { names, skips, silent, verbose, printBytes } = parsed;
-    const limit = parsed.limit >= maxCount ? Infinity : parsed.limit > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(parsed.limit);
-    const controller = new AbortController();
-    const signal = AbortSignal.any([context.signal, controller.signal]);
-    const budget = new ByteInputBudget(bufferLimit);
-    let chunks = 0;
-    const chargeChunk = async () => {
-        if (++chunks % 64 === 0)
-            await yieldTurn(signal);
-    };
-    const cursors = names.map(name => new Cursor(name, context, budget, signal, chargeChunk));
-    let closing;
-    const cleanupErrors = [];
-    const close = () => {
-        if (!closing) {
-            controller.abort(new FsError("EPIPE", { message: "cmp input closed" }));
-            closing = Promise.allSettled(cursors.map(cursor => cursor.close())).then(results => {
-                for (const result of results)
-                    if (result.status === "rejected")
-                        cleanupErrors.push(result.reason);
-            });
-        }
-        return closing;
-    };
-    context.registerCleanup?.(close);
-    let duplicateStdinClose = false;
-    const run = async () => {
-        assertCommandRequirements({ ...context, signal }, inputRequirements, [names.some(name => name !== "-") ? "file" : "stdin"]);
-        const sharedStdin = names.every(name => name === "-");
-        if (sharedStdin && (skips[0] === skips[1] || !context.stdinInput?.seek && context.stdinInput?.stat?.type !== "file"))
-            return 0;
-        for (const index of [0, 1]) {
-            const cursor = cursors[index];
-            try {
-                await cursor.open(limit, skips[index]);
-            }
-            catch (error) {
-                throw inputError(error, cursor.name, true);
-            }
-            if (index === 0 && names[0] === names[1] && skips[0] === skips[1] && cursor.stat)
-                return 0;
-        }
-        const [left, right] = cursors;
-        for (const cursor of cursors)
-            await cursor.prepare();
-        if (!sharedStdin && left.position === right.position && compareCopyIdentity(left.stat, right.stat) === "same")
-            return 0;
-        if (silent && Number.isFinite(left.size) && Number.isFinite(right.size) && left.size !== right.size && Math.min(left.size, right.size) < limit)
-            return 1;
-        for (const cursor of cursors)
-            if (cursor.stat?.type === "directory")
-                throw inputError(new FsError("EISDIR"), cursor.name);
-        const noStdout = !silent && await discardsOutput(context);
-        const known = Math.min(left.size, right.size, limit);
-        const width = Number.isFinite(known) ? String(known).length : 19;
-        duplicateStdinClose = sharedStdin;
-        let compared = 0;
-        let newlines = 0;
-        let lastByte = -1;
-        let different = false;
-        let report = "";
-        const flush = async () => {
-            if (report) {
-                await output(context, report);
-                report = "";
-            }
-        };
-        for (const cursor of cursors)
-            await cursor.fill(0);
-        while (compared < limit) {
-            const hasLeft = await left.fill(limit - compared);
-            const hasRight = await right.fill(limit - compared);
-            if (!hasLeft || !hasRight) {
-                await flush();
-                if (hasLeft === hasRight)
-                    return different ? 1 : 0;
-                if (!silent) {
-                    const shorter = hasLeft ? right.name : left.name;
-                    const detail = compared === 0 ? "which is empty" : `after byte ${compared}${verbose || noStdout ? "" : `, ${lastByte === 10 ? "" : "in "}line ${newlines + (lastByte === 10 ? 0 : 1)}`}`;
-                    await output({ ...context, stdout: context.stderr }, Uint8Array.from(`cmp: EOF on ${shorter} ${detail}\n`, unit => unit.charCodeAt(0)));
-                }
-                return 1;
-            }
-            const count = Math.min(left.bytes.length - left.offset, right.bytes.length - right.offset, limit - compared, blockBytes - compared % blockBytes);
-            for (let index = 0; index < count; index++) {
-                const leftByte = left.bytes[left.offset++];
-                const rightByte = right.bytes[right.offset++];
-                compared++;
-                if (leftByte !== rightByte) {
-                    different = true;
-                    if (silent || noStdout)
-                        return 1;
-                    if (!verbose) {
-                        const locale = context.env.LC_ALL || context.env.LC_MESSAGES || context.env.LANG;
-                        const unit = !printBytes && (!locale || locale === "C" || locale === "POSIX") ? "char" : "byte";
-                        const detail = printBytes ? ` is ${leftByte.toString(8).padStart(3)} ${printByte(leftByte)} ${rightByte.toString(8).padStart(3)} ${printByte(rightByte)}` : "";
-                        await output(context, Uint8Array.from(`${left.name} ${right.name} differ: ${unit} ${compared}, line ${newlines + 1}${detail}\n`, character => character.charCodeAt(0)));
-                        return 1;
-                    }
-                    report += `${String(compared).padStart(width)} ${leftByte.toString(8).padStart(3)} ${printBytes ? `${printByte(leftByte).padEnd(4)} ` : ""}${rightByte.toString(8).padStart(3)}${printBytes ? ` ${printByte(rightByte)}` : ""}\n`;
-                    if (report.length >= 16384)
-                        await flush();
-                }
-                if (leftByte === 10)
-                    newlines++;
-                lastByte = leftByte;
-            }
-            if (compared % blockBytes === 0)
-                await yieldTurn(signal);
-        }
-        await flush();
-        return different ? 1 : 0;
-    };
-    let result;
-    try {
-        result = await run();
-    }
-    catch (error) {
-        await close();
-        throw error;
-    }
-    await close();
-    if (cleanupErrors.length)
-        throw cleanupErrors[0];
-    if (duplicateStdinClose)
-        throw inputError(new FsError("EBADF"), "-");
-    return result;
-}
-export function cmpCommand() {
-    return { name: "cmp", filesystemRequirements: inputRequirements, async execute(context) {
-            context.signal.throwIfAborted();
-            let silent = false;
-            try {
-                const parsed = parse(context);
-                if (parsed.information) {
-                    await output(context, parsed.information === "version" ? "cmp (virtual-bash)\n" : "Usage: cmp [OPTION]... FILE1 [FILE2 [SKIP1 [SKIP2]]]\nCompare bytes in the virtual filesystem; omitted FILE2 or '-' reads stdin.\n  -s, --silent, --quiet  report status only\n  -l, --verbose         list differing bytes in octal\n  -b, -c, --print-bytes  also display byte characters\n  -i, --ignore-initial=SKIP[:SKIP2]  skip initial bytes\n  -n, --bytes=LIMIT     compare at most LIMIT bytes\n  --help, -v, --version show virtual-bash command information\n");
-                    return { exitCode: 0 };
-                }
-                silent = parsed.silent;
-                return { exitCode: await compare(context, parsed) };
-            }
-            catch (error) {
-                context.signal.throwIfAborted();
-                if (!silent || !(error instanceof InputError) || !error.suppressInSilent) {
-                    const message = publicDiagnosticMessage(error, context.onInternalError);
-                    const diagnostic = `cmp: ${message}\n${error instanceof UsageError ? "cmp: Try 'cmp --help' for more information.\n" : ""}`;
-                    await output({ ...context, stdout: context.stderr }, error instanceof UsageError || error instanceof InputError ? Uint8Array.from(diagnostic, unit => unit.charCodeAt(0)) : diagnostic);
-                }
-                return { exitCode: 2 };
-            }
-        } };
-}
-export function evalSyncCmp(inBytes, opArgs, readFileSync) {
-    try {
-        const operands = [];
-        const skips = [0n, 0n];
-        let count = 9223372036854775807n;
-        let stopped = false;
-        const setSkip = (idx, text) => {
-            const p = byteCount(text, "ignore-initial");
-            if (p > skips[idx])
-                skips[idx] = p;
-        };
-        for (let i = 0; i < opArgs.length; i++) {
-            const a = opArgs[i];
-            if (stopped || a === "-" || !a.startsWith("-")) {
-                operands.push(a);
-                continue;
-            }
-            if (a === "--") {
-                stopped = true;
-                continue;
-            }
-            if (a === "-s" || a === "--silent" || a === "--quiet" || a === "-b" || a === "-c" || a === "--print-bytes" || a === "-l" || a === "--verbose")
-                continue;
-            if (a === "-i" || a === "--ignore-initial" || a.startsWith("-i") || a.startsWith("--ignore-initial=")) {
-                const v = (a === "-i" || a === "--ignore-initial") ? opArgs[++i] : (a.startsWith("--ignore-initial=") ? a.slice(17) : a.slice(2));
-                if (v === undefined || v === "")
-                    return undefined;
-                const d = v.indexOf(":");
-                if (d < 0) {
-                    setSkip(0, v);
-                    if (skips[0] > skips[1])
-                        skips[1] = skips[0];
-                }
-                else {
-                    setSkip(0, v.slice(0, d));
-                    setSkip(1, v.slice(d + 1));
-                }
-                continue;
-            }
-            if (a === "-n" || a === "--bytes" || a.startsWith("-n") || a.startsWith("--bytes=")) {
-                const v = (a === "-n" || a === "--bytes") ? opArgs[++i] : (a.startsWith("--bytes=") ? a.slice(8) : a.slice(2));
-                if (v === undefined || v === "")
-                    return undefined;
-                const p = byteCount(v, "bytes");
-                if (p < count)
-                    count = p;
-                continue;
-            }
-            return undefined;
-        }
-        if (operands.length < 1 || operands.length > 4)
-            return undefined;
-        if (operands[2] !== undefined)
-            setSkip(0, operands[2]);
-        if (operands[3] !== undefined)
-            setSkip(1, operands[3]);
-        const f0 = operands[0];
-        const f1 = operands[1] ?? "-";
-        if (f0 === "-" && f1 === "-") {
-            if (skips[0] === skips[1])
-                return "";
-            return undefined;
-        }
-        const b0 = f0 === "-" ? inBytes : readFileSync?.(f0);
-        const b1 = f1 === "-" ? inBytes : readFileSync?.(f1);
-        if (!b0 || !b1 || b0.byteLength > 16384 || b1.byteLength > 16384)
-            return undefined;
-        if (skips[0] > BigInt(b0.byteLength) || skips[1] > BigInt(b1.byteLength))
-            return undefined;
-        const s0 = Number(skips[0]);
-        const s1 = Number(skips[1]);
-        const rem0 = b0.byteLength - s0;
-        const rem1 = b1.byteLength - s1;
-        const limit = count < BigInt(Math.max(rem0, rem1)) ? Number(count) : Math.max(rem0, rem1);
-        const len0 = Math.min(rem0, limit);
-        const len1 = Math.min(rem1, limit);
-        if (len0 !== len1)
-            return undefined;
-        for (let i = 0; i < len0; i++) {
-            if (b0[s0 + i] !== b1[s1 + i])
-                return undefined;
-        }
-        return "";
-    }
-    catch {
-        return undefined;
-    }
-}
+export * from "../../safe-bash-command-cmp/index.js";
+export { createCmpCommand, createCmpCommands, cmpCommands, cmpCommand, evalSyncCmp } from "../../safe-bash-command-cmp/index.js";
 //# sourceMappingURL=cmp.js.map