@poe-platform/safe-bash 0.1.799 → 0.1.801

package/dist/safe-bash/command-chunks/chunk-WVHONVZ4.js

@@ -0,0 +1,594 @@
+import {
+  contextual,
+  normal
+} from "./chunk-Y5INTD6S.js";
+import {
+  flags
+} from "./chunk-UG7SMZFF.js";
+import {
+  expandTabs,
+  ifdef,
+  quoteDiffArgument,
+  quoteDiffName,
+  script,
+  sideBySide
+} from "./chunk-6F4XCVON.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-diff/src/diff.ts
+init_buffer();
+import { createPrCommand } from "../../safe-bash-command-pr/index.js";
+import { basename, createCommandArguments, isFsError, toByteSource, writeBytes } from "../../safe-bash-contracts/index.js";
+import { publicDiagnosticMessage } from "../../safe-bash-contracts/diagnostics.js";
+import { writeDiagnostic } from "../../safe-bash-contracts/escaping.js";
+import { ToolError, definition, host, inspect, sameIdentity } from "../../safe-bash-diff-engine/shared.js";
+import { byteLength, concatBytes, decodeBytes, encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+import { pathOf } from "../../safe-bash-io-engine/internal.js";
+import { Pattern } from "../../safe-bash-regex-engine/text/regex.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());
+    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) : void 0;
+  const ids = /* @__PURE__ */ new Map();
+  const intern = async (keys, count) => {
+    const result2 = 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 === void 0) {
+        id = ids.size;
+        ids.set(key, id);
+      }
+      result2[index] = id;
+      const checkpoint = budget.checkpoint();
+      if (checkpoint) await checkpoint;
+    }
+    return result2;
+  };
+  const oldIds = matrix ? await intern(oldKeys, oldCount) : void 0;
+  const newIds = matrix ? await intern(newKeys, newCount) : void 0;
+  if (matrix) {
+    for (let oldIndex2 = oldCount - 1; oldIndex2 >= 0; oldIndex2--) {
+      budget.step(newCount);
+      const oldId = oldIds[oldIndex2];
+      const rowOffset = oldIndex2 * width;
+      const nextRowOffset = rowOffset + width;
+      for (let newIndex2 = newCount - 1; newIndex2 >= 0; newIndex2--) {
+        const position = rowOffset + newIndex2;
+        const nextPos = nextRowOffset + newIndex2;
+        if (oldId === newIds[newIndex2]) {
+          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");
+    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 void 0;
+      if (!isFsError(error)) throw error;
+      await writeDiagnostic(context.stderr, `diff: ${publicDiagnosticMessage(error, context.onInternalError)}
+`, context.signal);
+      inspectionFailed = trouble = true;
+      return void 0;
+    }
+  };
+  const pairs = options.fromFile !== void 0 ? options.files.map((right) => ({ left: options.fromFile, right })) : options.toFile !== void 0 ? 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 ? void 0 : isStdin(left) ? { type: "file" } : await inspectOperand(left);
+    let rightStat = pair.rightEntry === false ? void 0 : 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 ? void 0 : left, rightStat ? void 0 : right]) {
+        if (path !== void 0) await writeDiagnostic(context.stderr, `diff: ${path}: No such file or directory
+`, context.signal);
+      }
+      trouble = true;
+      continue;
+    }
+    if ((!leftStat || !rightStat) && !treatMissingAsEmpty) {
+      const present = leftStat ? left : right;
+      append(`Only in ${present.slice(0, present.lastIndexOf("/")) || "/"}: ${basename(present)}
+`);
+      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)}
+`);
+      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
+`);
+        different = true;
+      } else if (options.reportSame) append(`Files ${options.labels[0] ?? left} and ${options.labels[1] ?? right} are identical
+`);
+      continue;
+    }
+    if (leftStat?.type === "directory" || rightStat?.type === "directory") {
+      if (pair.nested && !options.recursive) {
+        append(`Common subdirectories: ${left} and ${right}
+`);
+        continue;
+      }
+      const leftIdentity = leftStat?.type !== "directory" ? void 0 : sameIdentity(leftStat, leftStat) ? leftStat : await host(context, () => context.fs.realpath(pathOf(context, left), { signal: context.signal }));
+      const rightIdentity = rightStat?.type !== "directory" ? void 0 : sameIdentity(rightStat, rightStat) ? rightStat : await host(context, () => context.fs.realpath(pathOf(context, right), { signal: context.signal }));
+      const isLoop = (identity, parents) => identity !== void 0 && 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 : void 0;
+      if (cycle !== void 0) {
+        await writeDiagnostic(context.stderr, `diff: ${cycle}: recursive directory loop
+`, context.signal);
+        trouble = true;
+        continue;
+      }
+      const leftParents = leftIdentity === void 0 ? pair.leftParents : [...pair.leftParents, leftIdentity];
+      const rightParents = rightIdentity === void 0 ? pair.rightParents : [...pair.rightParents, rightIdentity];
+      const names = /* @__PURE__ */ new Map();
+      const key = (name) => options.ignoreFileNameCase ? name.replace(/[A-Z]/gu, (letter) => letter.toLowerCase()) : name;
+      const maxEntries = budget.remainingFiles - pending.length;
+      let count = 0;
+      for (const [side, path] of [["left", leftStat ? left : void 0], ["right", rightStat ? right : void 0]]) {
+        if (path === void 0) 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 !== void 0 && 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 === void 0 ? {} : { left: leftName }, ...rightName === void 0 ? {} : { right: rightName } });
+        }
+        matches.sort((first, second) => {
+          const unmatched = Number(first.left === void 0 || first.right === void 0) - Number(second.left === void 0 || second.right === void 0);
+          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 !== void 0,
+            rightEntry: match.right !== void 0
+          });
+        }
+      }
+      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
+`);
+    };
+    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
+
+`, context.signal);
+          trouble = true;
+        }
+      }
+    }
+    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
+`);
+      different = true;
+      continue;
+    }
+    let oldText = oldBytes, newText = newBytes;
+    encoding = "latin1";
+    {
+      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 {
+      }
+    }
+    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
+`);
+      } 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
+`);
+    } 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 "";
+      } : void 0);
+    }
+    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] === "]") {
+        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 ? "[\0-\xFF]" : "[^\0-\xFF]";
+        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 };
+  }
+}
+function diffCommand(options = {}) {
+  return definition("diff", options, run);
+}
+
+export {
+  diffCommand
+};