@poe-platform/safe-bash 0.1.799 → 0.1.801

package/dist/safe-bash/commands/diff-patch/diff.js

@@ -1,657 +1,2 @@
-import { byteLength, concatBytes, decodeBytes, encodeBytes } from "../../byte-encoding.js";
-import { basename, createCommandArguments, isFsError, toByteSource, writeBytes } from "../../contracts/index.js";
-import { publicDiagnosticMessage } from "../../diagnostics.js";
-import { writeDiagnostic } from "../../escaping.js";
-import { pathOf } from "../internal.js";
-import { Budget, ToolError, definition, host, inspect, sameIdentity } from "./shared.js";
-import { contextual, normal } from "./diff-format.js";
-import { sideBySide, script, ifdef, expandTabs, quoteDiffName, quoteDiffArgument } from "./diff-output.js";
-import { flags } from "./diff-options.js";
-import { Pattern } from "../text-programs/regex.js";
-import { createPrCommand } from "../pr/index.js";
-async function comparisonLines(lines, options, budget) {
-    const whitespace = options.whitespace;
-    if (whitespace === "exact" && !options.ignoreCase && !options.ignoreTabs && !options.ignoreTrailing)
-        return lines;
-    const result = [];
-    for (const line of lines) {
-        budget.step(1 + line.length);
-        {
-            const c = budget.checkpoint();
-            if (c)
-                await c;
-        }
-        let body = line.endsWith("\n") ? line.slice(0, -1) : line;
-        if (options.ignoreTabs)
-            body = expandTabs(body);
-        if (whitespace !== "exact")
-            body = body.replace(/[ \t\v\f\r]+/gu, whitespace === "all" ? "" : " ");
-        if (options.ignoreTrailing || whitespace !== "exact")
-            body = body.replace(/[ \t\v\f\r]+$/u, "");
-        if (options.ignoreCase)
-            body = body.replace(/[A-Z]/gu, letter => letter.toLowerCase());
-        // Whitespace options ignore an absent final LF; -i alone does not.
-        result.push(body + (whitespace !== "exact" || options.ignoreTrailing || options.ignoreTabs ? "" : line.endsWith("\n") ? "\n" : ""));
-    }
-    return result;
-}
-async function equivalent(oldKeys, newKeys, budget) {
-    if (oldKeys.length !== newKeys.length)
-        return false;
-    for (let index = 0; index < oldKeys.length; index++) {
-        if (!budget.equal(oldKeys[index], newKeys[index]))
-            return false;
-        {
-            const c = budget.checkpoint();
-            if (c)
-                await c;
-        }
-    }
-    return true;
-}
-async function edits(oldLines, newLines, oldKeys, newKeys, budget) {
-    let prefix = 0;
-    while (prefix < Math.min(oldLines.length, newLines.length) && budget.equal(oldKeys[prefix], newKeys[prefix])) {
-        prefix++;
-        {
-            const c = budget.checkpoint();
-            if (c)
-                await c;
-        }
-    }
-    let suffix = 0;
-    while (suffix < Math.min(oldLines.length, newLines.length) - prefix
-        && budget.equal(oldKeys[oldLines.length - suffix - 1], newKeys[newLines.length - suffix - 1])) {
-        suffix++;
-        {
-            const c = budget.checkpoint();
-            if (c)
-                await c;
-        }
-    }
-    const oldCount = oldLines.length - prefix - suffix;
-    const newCount = newLines.length - prefix - suffix;
-    const cells = (oldCount + 1) * (newCount + 1);
-    if (oldCount && newCount && cells > budget.limits.maxMatrixCells)
-        throw new ToolError("diff matrix cell limit exceeded");
-    const width = newCount + 1;
-    const matrix = oldCount && newCount ? new Uint32Array(cells) : undefined;
-    const ids = new Map();
-    const intern = async (keys, count) => {
-        const result = new Uint32Array(count);
-        for (let index = 0; index < count; index++) {
-            const key = keys[prefix + index];
-            budget.step(1 + key.length);
-            let id = ids.get(key);
-            if (id === undefined) {
-                id = ids.size;
-                ids.set(key, id);
-            }
-            result[index] = id;
-            const checkpoint = budget.checkpoint();
-            if (checkpoint)
-                await checkpoint;
-        }
-        return result;
-    };
-    const oldIds = matrix ? await intern(oldKeys, oldCount) : undefined;
-    const newIds = matrix ? await intern(newKeys, newCount) : undefined;
-    if (matrix) {
-        for (let oldIndex = oldCount - 1; oldIndex >= 0; oldIndex--) {
-            budget.step(newCount);
-            const oldId = oldIds[oldIndex];
-            const rowOffset = oldIndex * width;
-            const nextRowOffset = rowOffset + width;
-            for (let newIndex = newCount - 1; newIndex >= 0; newIndex--) {
-                const position = rowOffset + newIndex;
-                const nextPos = nextRowOffset + newIndex;
-                if (oldId === newIds[newIndex]) {
-                    matrix[position] = 1 + matrix[nextPos + 1];
-                }
-                else {
-                    const down = matrix[nextPos];
-                    const right = matrix[position + 1];
-                    matrix[position] = down >= right ? down : right;
-                }
-            }
-            const checkpoint = budget.checkpoint();
-            if (checkpoint)
-                await checkpoint;
-        }
-    }
-    const result = oldLines.slice(0, prefix).map((line, index) => ({ kind: " ", line, newLine: newLines[index] }));
-    let oldIndex = 0;
-    let newIndex = 0;
-    while (oldIndex < oldCount || newIndex < newCount) {
-        budget.step();
-        if (oldIndex < oldCount && newIndex < newCount && budget.equal(oldKeys[prefix + oldIndex], newKeys[prefix + newIndex])) {
-            result.push({ kind: " ", line: oldLines[prefix + oldIndex++], newLine: newLines[prefix + newIndex++] });
-        }
-        else if (oldIndex < oldCount && (newIndex === newCount || matrix[oldIndex * width + newIndex + width] >= matrix[oldIndex * width + newIndex + 1])) {
-            result.push({ kind: "-", line: oldLines[prefix + oldIndex++] });
-        }
-        else
-            result.push({ kind: "+", line: newLines[prefix + newIndex++] });
-        {
-            const c = budget.checkpoint();
-            if (c)
-                await c;
-        }
-    }
-    for (let index = 0; index < suffix; index++) {
-        result.push({ kind: " ", line: oldLines[oldLines.length - suffix + index], newLine: newLines[newLines.length - suffix + index] });
-        budget.step();
-        {
-            const c = budget.checkpoint();
-            if (c)
-                await c;
-        }
-    }
-    return result;
-}
-async function exclusionPatterns(options, budget) {
-    const exclusions = [];
-    let patternBytes = 0;
-    const append = async (source, ignoreCase, start = 0, end = source.length) => {
-        budget.step(1 + end - start);
-        {
-            const c = budget.checkpoint();
-            if (c)
-                await c;
-        }
-        if (exclusions.length >= budget.limits.maxExcludePatterns)
-            throw new ToolError("exclusion pattern count limit exceeded");
-        // UTF-16 length is a lower bound on UTF-8 bytes; admit the slice before allocating it.
-        const remaining = budget.limits.maxExcludePatternBytes - patternBytes;
-        if (end - start > remaining)
-            throw new ToolError("exclusion pattern byte limit exceeded");
-        const sourcePattern = source.slice(start, end);
-        const bytes = byteLength(sourcePattern);
-        if (bytes > remaining)
-            throw new ToolError("exclusion pattern byte limit exceeded");
-        patternBytes += bytes;
-        exclusions.push(globPattern(sourcePattern, ignoreCase));
-    };
-    for (const { pattern, ignoreCase } of options.excludes)
-        await append(pattern, ignoreCase);
-    for (const { path, ignoreCase } of options.excludeFiles) {
-        if (path !== "-")
-            await inspect(budget, path, "follow");
-        const contents = await (path === "-" ? budget.read("-") : budget.readDiff(pathOf(budget.context, path)));
-        let start = 0;
-        while (start < contents.length) {
-            const newline = contents.indexOf("\n", start);
-            const end = newline < 0 ? contents.length : newline;
-            if (end > start)
-                await append(contents, ignoreCase, start, end);
-            else {
-                budget.step();
-                {
-                    const c = budget.checkpoint();
-                    if (c)
-                        await c;
-                }
-            }
-            start = end + 1;
-        }
-    }
-    return exclusions;
-}
-function childPath(directory, name) {
-    let end = directory.length;
-    while (end > 0 && directory[end - 1] === "/")
-        end--;
-    return `${directory.slice(0, end)}/${name}`;
-}
-async function run(context, budget) {
-    const options = flags(context.args);
-    const exclusions = await exclusionPatterns(options, budget);
-    const pieces = [];
-    let encoding = "utf8";
-    const append = (text) => { budget.output(text, encoding); pieces.push(encodeBytes(text, encoding)); };
-    let different = false;
-    let trouble = false;
-    let stdin;
-    const symlinks = options.noDereference ? "compare" : "follow";
-    let inspectionFailed = false;
-    const inspectOperand = async (path) => {
-        try {
-            return await inspect(budget, path, symlinks);
-        }
-        catch (error) {
-            if (isFsError(error, "ENOENT"))
-                return undefined;
-            if (!isFsError(error))
-                throw error;
-            await writeDiagnostic(context.stderr, `diff: ${publicDiagnosticMessage(error, context.onInternalError)}\n`, context.signal);
-            inspectionFailed = trouble = true;
-            return undefined;
-        }
-    };
-    const pairs = options.fromFile !== undefined ? options.files.map(right => ({ left: options.fromFile, right }))
-        : options.toFile !== undefined ? options.files.map(left => ({ left, right: options.toFile }))
-            : [{ left: options.files[0], right: options.files[1] }];
-    const pending = pairs.reverse().map(pair => ({ ...pair, nested: false, leftParents: [], rightParents: [] }));
-    while (pending.length) {
-        encoding = "utf8";
-        inspectionFailed = false;
-        budget.file();
-        {
-            const c = budget.checkpoint();
-            if (c)
-                await c;
-        }
-        const pair = pending.pop();
-        let left = pair.left;
-        let right = pair.right;
-        const isStdin = (path) => path === "-" || !options.noDereference
-            && (pathOf(context, path) === "/dev/stdin" || pathOf(context, path) === "/dev/fd/0");
-        let leftStat = pair.leftEntry === false ? undefined : isStdin(left) ? { type: "file" } : await inspectOperand(left);
-        let rightStat = pair.rightEntry === false ? undefined : isStdin(right) ? { type: "file" } : await inspectOperand(right);
-        if (inspectionFailed)
-            continue;
-        if (options.format === "ifdef" && (leftStat?.type === "directory" || rightStat?.type === "directory")) {
-            throw new ToolError("-D option not supported with directories");
-        }
-        if (!pair.nested && leftStat && rightStat && (leftStat.type === "directory") !== (rightStat.type === "directory")) {
-            if (isStdin(left) || isStdin(right))
-                throw new ToolError("cannot compare stdin with a directory");
-            if (leftStat.type === "directory") {
-                left = childPath(left, basename(right));
-                leftStat = await inspectOperand(left);
-            }
-            else {
-                right = childPath(right, basename(left));
-                rightStat = await inspectOperand(right);
-            }
-            if (inspectionFailed)
-                continue;
-        }
-        const treatMissingAsEmpty = (!leftStat && (options.newFile || options.unidirectionalNewFile)) || (!rightStat && options.newFile);
-        const missingError = !leftStat && !rightStat
-            || treatMissingAsEmpty && (leftStat?.type === "symlink" || rightStat?.type === "symlink")
-            || !leftStat && pair.leftEntry === true || !rightStat && pair.rightEntry === true
-            || !treatMissingAsEmpty && (!leftStat || !rightStat) && !pair.nested;
-        if (missingError) {
-            for (const path of [leftStat ? undefined : left, rightStat ? undefined : right]) {
-                if (path !== undefined)
-                    await writeDiagnostic(context.stderr, `diff: ${path}: No such file or directory\n`, context.signal);
-            }
-            trouble = true;
-            continue;
-        }
-        if ((!leftStat || !rightStat) && !treatMissingAsEmpty) {
-            const present = leftStat ? left : right;
-            append(`Only in ${present.slice(0, present.lastIndexOf("/")) || "/"}: ${basename(present)}\n`);
-            different = true;
-            continue;
-        }
-        const streamType = (type) => type === "character" || type === "fifo";
-        const comparable = (type) => type === "file" || streamType(type);
-        if (leftStat && rightStat && leftStat.type !== rightStat.type
-            && (pair.nested || !comparable(leftStat.type) || !comparable(rightStat.type))) {
-            const typeName = (stat) => stat.type === "symlink" ? "symbolic link"
-                : stat.type === "file" ? stat.size === 0 ? "regular empty file" : "regular file"
-                    : stat.type === "character" ? "character special file" : stat.type;
-            append(`File ${left} is a ${typeName(leftStat)} while file ${right} is a ${typeName(rightStat)}\n`);
-            different = true;
-            continue;
-        }
-        if (leftStat?.type === "symlink" || rightStat?.type === "symlink") {
-            if (!context.fs.readlink)
-                throw new ToolError("filesystem cannot read symbolic links");
-            const readlink = context.fs.readlink.bind(context.fs);
-            const oldTarget = await host(context, () => readlink(pathOf(context, left), { signal: context.signal }));
-            const newTarget = await host(context, () => readlink(pathOf(context, right), { signal: context.signal }));
-            if (!budget.equal(oldTarget, newTarget)) {
-                append(`Symbolic links ${left} and ${right} differ\n`);
-                different = true;
-            }
-            else if (options.reportSame)
-                append(`Files ${options.labels[0] ?? left} and ${options.labels[1] ?? right} are identical\n`);
-            continue;
-        }
-        if (leftStat?.type === "directory" || rightStat?.type === "directory") {
-            if (pair.nested && !options.recursive) {
-                append(`Common subdirectories: ${left} and ${right}\n`);
-                continue;
-            }
-            const leftIdentity = leftStat?.type !== "directory" ? undefined : sameIdentity(leftStat, leftStat) ? leftStat
-                : await host(context, () => context.fs.realpath(pathOf(context, left), { signal: context.signal }));
-            const rightIdentity = rightStat?.type !== "directory" ? undefined : sameIdentity(rightStat, rightStat) ? rightStat
-                : await host(context, () => context.fs.realpath(pathOf(context, right), { signal: context.signal }));
-            const isLoop = (identity, parents) => identity !== undefined
-                && parents.some(parent => typeof identity === "string" ? parent === identity : typeof parent !== "string" && sameIdentity(identity, parent));
-            const cycle = isLoop(leftIdentity, pair.leftParents) ? left : isLoop(rightIdentity, pair.rightParents) ? right : undefined;
-            if (cycle !== undefined) {
-                await writeDiagnostic(context.stderr, `diff: ${cycle}: recursive directory loop\n`, context.signal);
-                trouble = true;
-                continue;
-            }
-            const leftParents = leftIdentity === undefined ? pair.leftParents : [...pair.leftParents, leftIdentity];
-            const rightParents = rightIdentity === undefined ? pair.rightParents : [...pair.rightParents, rightIdentity];
-            const names = new Map();
-            const key = (name) => options.ignoreFileNameCase ? name.replace(/[A-Z]/gu, letter => letter.toLowerCase()) : name;
-            // Each side may contain all the same names; only their union consumes pairs.
-            const maxEntries = budget.remainingFiles - pending.length;
-            let count = 0;
-            for (const [side, path] of [["left", leftStat ? left : undefined], ["right", rightStat ? right : undefined]]) {
-                if (path === undefined)
-                    continue;
-                const entries = await host(context, () => context.fs.readdir(pathOf(context, path), { signal: context.signal, ...(Number.isFinite(maxEntries) ? { maxEntries } : {}) }));
-                if (entries.length > maxEntries)
-                    throw new ToolError("file/entry limit exceeded");
-                for (const entry of entries) {
-                    budget.step();
-                    if (!entry.name || entry.name === "." || entry.name === ".." || /[\/\\\0\r\n\t]/u.test(entry.name))
-                        throw new ToolError("unsafe directory entry name");
-                    let excluded = false;
-                    const byteName = exclusions.length ? decodeBytes(encodeBytes(entry.name), "latin1") : entry.name;
-                    for (const pattern of exclusions)
-                        if (await pattern.find(byteName, budget)) {
-                            excluded = true;
-                            break;
-                        }
-                    if (excluded)
-                        continue;
-                    const folded = key(entry.name);
-                    let group = names.get(folded);
-                    if (!group) {
-                        group = { left: [], right: [] };
-                        names.set(folded, group);
-                    }
-                    const before = Math.max(group.left.length, group.right.length);
-                    group[side].push(entry.name);
-                    count += Math.max(group.left.length, group.right.length) - before;
-                    if (count > maxEntries)
-                        throw new ToolError("file/entry limit exceeded");
-                }
-            }
-            for (const name of [...names.keys()].sort().reverse()) {
-                if (!pair.nested && options.startingFile !== undefined && name < key(options.startingFile))
-                    continue;
-                const group = names.get(name);
-                group.left.sort();
-                group.right.sort();
-                const rightNames = new Set(group.right);
-                const matches = [];
-                const unmatchedLeft = [];
-                for (const leftName of group.left) {
-                    if (rightNames.delete(leftName))
-                        matches.push({ left: leftName, right: leftName });
-                    else
-                        unmatchedLeft.push(leftName);
-                }
-                const unmatchedRight = [...rightNames];
-                for (let index = 0; index < Math.max(unmatchedLeft.length, unmatchedRight.length); index++) {
-                    const leftName = unmatchedLeft[index], rightName = unmatchedRight[index];
-                    matches.push({ ...(leftName === undefined ? {} : { left: leftName }), ...(rightName === undefined ? {} : { right: rightName }) });
-                }
-                matches.sort((first, second) => {
-                    const unmatched = Number(first.left === undefined || first.right === undefined) - Number(second.left === undefined || second.right === undefined);
-                    const firstName = first.left ?? first.right, secondName = second.left ?? second.right;
-                    return unmatched || (firstName < secondName ? -1 : firstName > secondName ? 1 : 0);
-                });
-                for (const match of matches.reverse()) {
-                    pending.push({ left: childPath(left, match.left ?? match.right), right: childPath(right, match.right ?? match.left),
-                        nested: true, leftParents, rightParents, leftEntry: match.left !== undefined, rightEntry: match.right !== undefined });
-                }
-            }
-            continue;
-        }
-        const read = async (path, stat) => {
-            if (!stat)
-                return "";
-            if (isStdin(path))
-                return stdin ??= await budget.read("-", "latin1");
-            if (!pair.nested && streamType(stat.type))
-                return budget.read(pathOf(context, path), "latin1");
-            return budget.readDiff(pathOf(context, path), "latin1");
-        };
-        const oldBytes = await read(left, leftStat);
-        const newBytes = await read(right, rightStat);
-        const label = (name) => encoding === "latin1" ? decodeBytes(encodeBytes(name), "latin1") : name;
-        const reportSame = () => { if (options.reportSame)
-            append(`Files ${label(options.labels[0] ?? left)} and ${label(options.labels[1] ?? right)} are identical\n`); };
-        if (options.format === "ed" && (options.text || !oldBytes.includes("\0") && !newBytes.includes("\0"))) {
-            for (const [path, text] of [[left, oldBytes], [right, newBytes]]) {
-                if (text && !text.endsWith("\n")) {
-                    await writeDiagnostic(context.stderr, `diff: ${path}: No newline at end of file\n\n`, context.signal);
-                    trouble = true;
-                }
-            }
-        }
-        // Detect binary data before decoding; invalid UTF-8 without NUL is byte text.
-        if (!options.text && oldBytes === newBytes && (options.format !== "side" && options.format !== "ifdef" || oldBytes.includes("\0"))) {
-            reportSame();
-            continue;
-        }
-        if (!options.text && (oldBytes.includes("\0") || newBytes.includes("\0"))) {
-            append(`${options.brief ? "Files" : "Binary files"} ${options.labels[0] ?? left} and ${options.labels[1] ?? right} differ\n`);
-            different = true;
-            continue;
-        }
-        let oldText = oldBytes, newText = newBytes;
-        encoding = "latin1";
-        if (!options.text) {
-            const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
-            try {
-                const oldDecoded = decoder.decode(encodeBytes(oldBytes, "latin1"));
-                const newDecoded = decoder.decode(encodeBytes(newBytes, "latin1"));
-                oldText = oldDecoded;
-                newText = newDecoded;
-                encoding = "utf8";
-            }
-            catch { /* Latin-1 maps each input byte to one code unit without replacement. */ }
-        }
-        if (options.stripTrailingCr) {
-            oldText = oldText.replaceAll("\r\n", "\n");
-            newText = newText.replaceAll("\r\n", "\n");
-        }
-        if (options.format === "ed") {
-            if (oldText && !oldText.endsWith("\n"))
-                oldText += "\n";
-            if (newText && !newText.endsWith("\n"))
-                newText += "\n";
-        }
-        if (oldText === newText && options.format !== "side" && options.format !== "ifdef") {
-            reportSame();
-            continue;
-        }
-        const oldLines = budget.split(oldText);
-        const newLines = budget.split(newText);
-        const oldKeys = await comparisonLines(oldLines, options, budget);
-        const newKeys = await comparisonLines(newLines, options, budget);
-        const same = oldText === newText || await equivalent(oldKeys, newKeys, budget);
-        if (same && options.format !== "side" && options.format !== "ifdef") {
-            reportSame();
-            continue;
-        }
-        if (options.brief && !options.ignoreBlank && options.ignorePatterns.length === 0) {
-            if (!same) {
-                different = true;
-                append(`Files ${label(options.labels[0] ?? left)} and ${label(options.labels[1] ?? right)} differ\n`);
-            }
-            else
-                reportSame();
-            continue;
-        }
-        const changes = await edits(oldLines, newLines, oldKeys, newKeys, budget);
-        if (!same)
-            await ignoreChanges(changes, options, budget);
-        const changed = changes.some(edit => edit.kind !== " " && !edit.ignored);
-        different ||= changed;
-        if (!changed && pair.nested && options.suppressCommon) {
-            reportSame();
-            continue;
-        }
-        if (pair.nested && !options.brief && (changed || options.format === "side")) {
-            append(label(["diff", ...options.optionArgs.map(quoteDiffArgument), quoteDiffName(options.labels[0] ?? left), quoteDiffName(options.labels[1] ?? right)].join(" ")) + "\n");
-        }
-        if (options.brief) {
-            if (changed)
-                append(`Files ${label(options.labels[0] ?? left)} and ${label(options.labels[1] ?? right)} differ\n`);
-        }
-        else if (options.format === "side")
-            await sideBySide(changes, options, budget, append);
-        else if (options.format === "ifdef")
-            await ifdef(changes, label(options.symbol), budget, append);
-        else if (changed) {
-            if (options.format === "normal") {
-                await normal(changes, budget, append, options);
-            }
-            else if (options.format === "ed" || options.format === "rcs")
-                await script(changes, options.format, budget, append);
-            else
-                await contextual(changes, options.format, label(options.labels[0] ?? quoteDiffName(leftStat ? left : "/dev/null")), label(options.labels[1] ?? quoteDiffName(rightStat ? right : "/dev/null")), options.context, budget, append, options, options.functions.length ? async (position) => {
-                    for (let index = position - 1; index >= 0; index--) {
-                        for (const pattern of options.functions)
-                            if (await pattern.find(oldLines[index], budget))
-                                return oldLines[index].replace(/\n$/u, "").slice(0, 40);
-                        budget.step();
-                        {
-                            const c = budget.checkpoint();
-                            if (c)
-                                await c;
-                        }
-                    }
-                    return "";
-                } : undefined);
-        }
-        if (!changed)
-            reportSame();
-    }
-    const output = concatBytes(pieces);
-    if (options.paginate && output.length) {
-        const title = ["diff", ...context.args].join(" ");
-        const argumentValues = createCommandArguments(["-f", "-h", title]);
-        const pages = [];
-        const result = await createPrCommand({ limits: { maxInputBytes: budget.limits.maxOutputBytes, maxOutputBytes: budget.limits.maxOutputBytes, maxWork: Math.max(1, budget.remainingWork) } }).execute({
-            ...context, command: "pr", args: argumentValues.args, argumentValues, stdin: toByteSource(output),
-            stdout: { async write(chunk) { pages.push(chunk.slice()); } },
-        });
-        if (result.exitCode)
-            return 2;
-        await writeBytes(context.stdout, concatBytes(pages), context.signal);
-    }
-    else
-        await writeBytes(context.stdout, output, context.signal);
-    return trouble ? 2 : different ? 1 : 0;
-}
-function globPattern(source, ignoreCase) {
-    source = decodeBytes(encodeBytes(source), "latin1");
-    let result = "^";
-    const oppositeCase = (character) => !ignoreCase ? ""
-        : character >= "A" && character <= "Z" ? character.toLowerCase()
-            : character >= "a" && character <= "z" ? character.toUpperCase() : "";
-    for (let index = 0; index < source.length; index++) {
-        const character = source[index];
-        if (character === "\\" && index + 1 < source.length) {
-            const literal = source[++index];
-            result += oppositeCase(literal) ? `[${literal}${oppositeCase(literal)}]` : `\\${literal}`;
-        }
-        else if (character === "[") {
-            let end = index + 1;
-            const negated = source[end] === "!" || source[end] === "^";
-            if (negated)
-                end++;
-            if (source[end] === "]")
-                end++;
-            while (end < source.length && source[end] !== "]") {
-                if (source[end] === "\\" && end + 1 < source.length)
-                    end += 2;
-                else if (source[end] === "[" && source[end + 1] === ":") {
-                    const classEnd = source.indexOf(":]", end + 2);
-                    if (classEnd < 0)
-                        break;
-                    end = classEnd + 2;
-                }
-                else
-                    end++;
-            }
-            if (source[end] === "]") {
-                // Fold explicit ASCII literals/range endpoints; POSIX classes retain their meaning.
-                let body = "";
-                const literal = (value) => "\\]^-".includes(value) ? `\\${value}` : value;
-                for (let scan = index + 1 + Number(negated); scan < end; scan++) {
-                    if (source[scan] === "[" && source[scan + 1] === ":") {
-                        const closing = source.indexOf(":]", scan + 2) + 1;
-                        body += source.slice(scan, closing + 1);
-                        scan = closing;
-                        continue;
-                    }
-                    if (source[scan] === "\\" && scan + 1 < end)
-                        scan++;
-                    let first = source[scan];
-                    if (ignoreCase && first >= "A" && first <= "Z")
-                        first = first.toLowerCase();
-                    if (source[scan + 1] === "-" && scan + 2 < end) {
-                        let last = source[scan + 2];
-                        if (ignoreCase && last >= "A" && last <= "Z")
-                            last = last.toLowerCase();
-                        for (let code = first.charCodeAt(0); code <= last.charCodeAt(0); code++) {
-                            const value = String.fromCharCode(code);
-                            body += literal(value) + oppositeCase(value);
-                        }
-                        scan += 2;
-                    }
-                    else
-                        body += literal(first) + oppositeCase(first);
-                }
-                result += body ? "[" + (negated ? "^" : "") + body + "]" : negated ? "[\u0000-\u00ff]" : "[^\u0000-\u00ff]";
-                index = end;
-            }
-            else
-                result += "\\[";
-        }
-        else if (character === "*")
-            result += ".*";
-        else if (character === "?")
-            result += ".";
-        else
-            result += oppositeCase(character) ? `[${character}${oppositeCase(character)}]`
-                : ".^$+(){}|]".includes(character) ? `\\${character}` : character;
-    }
-    return new Pattern(result + "$", true, false, "awk");
-}
-async function ignoreChanges(changes, options, budget) {
-    if (!options.ignoreBlank && !options.ignorePatterns.length)
-        return;
-    let scan = 0;
-    while (scan < changes.length) {
-        budget.step();
-        {
-            const c = budget.checkpoint();
-            if (c)
-                await c;
-        }
-        if (changes[scan].kind === " ") {
-            scan++;
-            continue;
-        }
-        const start = scan;
-        let ignored = true;
-        while (scan < changes.length && changes[scan].kind !== " ") {
-            const edit = changes[scan++];
-            const body = edit.line.endsWith("\n") ? edit.line.slice(0, -1) : edit.line;
-            let matches = options.ignoreBlank && (body === "" || options.whitespace !== "exact" && /^[ \t\v\f\r]*$/u.test(body));
-            for (const pattern of options.ignorePatterns)
-                if (await pattern.find(body, budget)) {
-                    matches = true;
-                    break;
-                }
-            ignored &&= matches;
-            budget.step(1 + body.length);
-            {
-                const c = budget.checkpoint();
-                if (c)
-                    await c;
-            }
-        }
-        if (ignored)
-            for (let index = start; index < scan; index++)
-                changes[index] = { ...changes[index], ignored: true };
-    }
-}
-export function diffCommand(options) { return definition("diff", options, run); }
+export * from "../../../safe-bash-command-diff/diff.js";
 //# sourceMappingURL=diff.js.map

package/dist/safe-bash/commands/diff-patch/index.d.ts

@@ -1,8 +1,7 @@
-import type { CommandDefinition, VirtualShellPlugin } from "../../contracts/index.js";
-import type { DiffPatchOptions } from "./shared.js";
-export type { DiffPatchOptions } from "./shared.js";
+import type { CommandDefinition, VirtualShellPlugin } from "../../../safe-bash-contracts/index.js";
+import { type DiffPatchOptions } from "../../../safe-bash-command-diff/index.js";
 export declare function createDiffPatchCommands(options?: DiffPatchOptions): readonly CommandDefinition[];
 export declare function diffPatchCommands(options?: DiffPatchOptions): VirtualShellPlugin;
-export declare function evalSyncDiff(stdinBytes: Uint8Array | undefined, args: readonly string[], readFile?: (path: string) => Uint8Array | undefined): string | undefined;
-export declare function evalSyncPatch(inBytes: Uint8Array | undefined, opArgs: readonly string[], readFileSync?: (filePath: string) => Uint8Array | undefined, writeFileSync?: (filePath: string, bytes: Uint8Array, append: boolean) => boolean): string | undefined;
+export * from "../../../safe-bash-command-diff/index.js";
+export * from "../../../safe-bash-command-patch/index.js";
 //# sourceMappingURL=index.d.ts.map