@poe-platform/safe-bash 0.1.798 → 0.1.800

package/dist/safe-bash/command-chunks/chunk-67QKREJK.js

@@ -0,0 +1,347 @@
+import {
+  decodeHeaderPath,
+  isEpochHeader
+} from "./chunk-DOKKNRRM.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-patch/src/unified.ts
+init_buffer();
+import { ToolError, integer } from "../../safe-bash-diff-engine/shared.js";
+import { byteLength } from "../../safe-bash-io-engine/byte-encoding.js";
+function header(line, prefix) {
+  if (!line.startsWith(prefix)) throw new ToolError(`expected ${prefix.trim()} file header`);
+  const path = decodeHeaderPath(line.slice(prefix.length));
+  if (!path || /[\0\r\n]/u.test(path)) throw new ToolError("unsupported or empty patch filename");
+  return path;
+}
+function startIndex(start, count) {
+  return count === 0 ? start : start - 1;
+}
+async function parseUnified(text, budget) {
+  if (text && !text.endsWith("\n")) throw new ToolError("patch is truncated: missing final LF");
+  return parseUnifiedReader({ lines: budget.split(text).map((line) => line.slice(0, -1)), index: 0 }, budget, false);
+}
+async function parseUnifiedSection(cursor, budget) {
+  return parseUnifiedReader(cursor, budget, true);
+}
+async function parseUnifiedReader(cursor, budget, single) {
+  const physical = cursor.lines;
+  const patches = [];
+  let index = cursor.index;
+  let pendingMetadata = false;
+  while (index < physical.length) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    const line = physical[index];
+    if (line === "") {
+      index++;
+      continue;
+    }
+    if (/^diff (?:--git |-[^ ]+ )/u.test(line) || /^index [0-9a-f]+\.\.[0-9a-f]+(?: 100(?:644|755))?$/u.test(line) || /^(?:new file|deleted file) mode 100(?:644|755)$/u.test(line)) {
+      pendingMetadata = true;
+      index++;
+      continue;
+    }
+    const oldPath = header(line, "--- ");
+    const oldHeader = line.slice(4);
+    const oldEpoch = isEpochHeader(line);
+    const newPath = header(physical[++index] ?? "", "+++ ");
+    const newHeader = physical[index].slice(4);
+    const newEpoch = isEpochHeader(physical[index]);
+    index++;
+    budget.file();
+    const hunks = [];
+    let oldEnded = false;
+    let newEnded = false;
+    while (index < physical.length && physical[index].startsWith("@@")) {
+      budget.hunk();
+      const match = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@( .*)?$/u.exec(physical[index++]);
+      if (!match) throw new ToolError("malformed unified hunk header");
+      const oldStart = integer(match[1], "old start");
+      const oldCount = integer(match[2] ?? "1", "old count");
+      const newStart = integer(match[3], "new start");
+      const newCount = integer(match[4] ?? "1", "new count");
+      for (const value of [oldStart, oldCount, newStart, newCount]) {
+        if (value > budget.limits.maxLines) throw new ToolError("hunk coordinate exceeds line limit");
+      }
+      if (oldCount > 0 && oldStart === 0 || newCount > 0 && newStart === 0 || !oldCount && !newCount) throw new ToolError("invalid zero hunk range");
+      if (oldEnded && oldCount || newEnded && newCount) throw new ToolError("hunk follows an incomplete final line");
+      let oldRead = 0;
+      let newRead = 0;
+      const lines = [];
+      let changed = false;
+      while (oldRead < oldCount || newRead < newCount) {
+        budget.step();
+        {
+          const c = budget.checkpoint();
+          if (c) await c;
+        }
+        const body = physical[index++];
+        const kind = body === "" ? " " : body?.[0];
+        if (body === void 0 || kind !== " " && kind !== "+" && kind !== "-") throw new ToolError("truncated or malformed hunk body");
+        if (kind !== "+" && oldEnded || kind !== "-" && newEnded) throw new ToolError("content follows an incomplete final line");
+        if (kind !== "+") oldRead++;
+        if (kind !== "-") newRead++;
+        if (oldRead > oldCount || newRead > newCount) throw new ToolError("hunk line counts do not match header");
+        const entry = { kind, text: `${body.slice(1)}
+` };
+        lines.push(entry);
+        changed ||= kind !== " ";
+        if (physical[index] === "\") {
+          if (entry.text === "\n") throw new ToolError("empty incomplete line is not a valid text line");
+          index++;
+          entry.text = entry.text.slice(0, -1);
+          if (kind !== "+") oldEnded = true;
+          if (kind !== "-") newEnded = true;
+        }
+      }
+      if (!changed) throw new ToolError("hunk has no changes");
+      hunks.push({ oldStart, oldCount, newStart, newCount, lines, section: match[5] ?? "" });
+    }
+    if (!hunks.length) throw new ToolError("file patch has no hunks");
+    patches.push({ oldPath, newPath, oldEpoch, newEpoch, oldHeader, newHeader, hunks });
+    pendingMetadata = false;
+    if (single) break;
+  }
+  if (pendingMetadata) throw new ToolError("metadata without a file patch");
+  cursor.index = index;
+  return patches;
+}
+function reversePatch(patch) {
+  return {
+    ...patch,
+    oldPath: patch.newPath,
+    newPath: patch.oldPath,
+    oldEpoch: patch.newEpoch,
+    newEpoch: patch.oldEpoch,
+    hunks: patch.hunks.map((hunk) => ({
+      ...hunk,
+      oldStart: hunk.newStart,
+      oldCount: hunk.newCount,
+      newStart: hunk.oldStart,
+      newCount: hunk.oldCount,
+      lines: hunk.lines.map((line) => ({ kind: line.kind === "+" ? "-" : line.kind === "-" ? "+" : " ", text: line.text }))
+    }))
+  };
+}
+async function applyHunks(original, patch, fuzz, budget, ignoreWhitespace = false, application = {}) {
+  const source = budget.split(original);
+  const result = [];
+  let resultBytes = 0;
+  const append = (line) => {
+    resultBytes += byteLength(line);
+    if (resultBytes > budget.limits.maxOutputBytes) throw new ToolError("output byte limit exceeded");
+    result.push(line);
+  };
+  let cursor = 0;
+  let offset = 0;
+  let outputOffset = 0;
+  for (const [hunkIndex, hunk] of patch.hunks.entries()) {
+    budget.step();
+    const oldLines = hunk.lines.filter((line) => line.kind !== "+");
+    let leading = 0;
+    let trailing = 0;
+    while (leading < hunk.lines.length && hunk.lines[leading].kind === " ") leading++;
+    while (trailing < hunk.lines.length - leading && hunk.lines[hunk.lines.length - trailing - 1].kind === " ") trailing++;
+    const expected = startIndex(hunk.oldStart, hunk.oldCount) + offset;
+    let found = -1;
+    let misordered = false;
+    let usedFuzz = 0;
+    const context = Math.max(leading, trailing);
+    const matches = async (position, prefixFuzz, suffixFuzz) => {
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+      if (position < 0 || position > source.length - hunk.oldCount + suffixFuzz) return false;
+      for (let lineIndex = 0; lineIndex < oldLines.length; lineIndex++) {
+        if (lineIndex < prefixFuzz || lineIndex >= oldLines.length - suffixFuzz) continue;
+        const actual = source[position + lineIndex];
+        if (actual === void 0) return false;
+        const expectedLine = oldLines[lineIndex].text;
+        if (ignoreWhitespace) budget.step(actual.length + expectedLine.length);
+        if (!budget.equal(
+          ignoreWhitespace ? actual.replace(/[ \t]+(?=\r?\n|$)/gu, "").replace(/[ \t]+/gu, " ") : actual,
+          ignoreWhitespace ? expectedLine.replace(/[ \t]+(?=\r?\n|$)/gu, "").replace(/[ \t]+/gu, " ") : expectedLine
+        )) return false;
+        {
+          const c = budget.checkpoint();
+          if (c) await c;
+        }
+      }
+      if (position < cursor) misordered = true;
+      return true;
+    };
+    let matchedPrefixFuzz = 0;
+    let matchedSuffixFuzz = 0;
+    for (let tolerance = 0; tolerance <= Math.min(fuzz, context); tolerance++) {
+      if (application.rejectAll) break;
+      usedFuzz = tolerance;
+      const prefixFuzz = tolerance + leading - context;
+      const suffixFuzz = tolerance + trailing - context;
+      if (prefixFuzz < 0 && hunk.oldStart <= 1) {
+        if (await matches(0, 0, suffixFuzz)) {
+          found = 0;
+          matchedPrefixFuzz = 0;
+          matchedSuffixFuzz = suffixFuzz;
+        }
+        if (found >= 0) break;
+        continue;
+      }
+      if (suffixFuzz < 0) {
+        const end = source.length - hunk.oldCount;
+        if (await matches(end, Math.max(0, prefixFuzz), 0)) {
+          found = end;
+          matchedPrefixFuzz = Math.max(0, prefixFuzz);
+          matchedSuffixFuzz = 0;
+        }
+        if (found >= 0) break;
+        continue;
+      }
+      const retained = oldLines.length - Math.max(0, prefixFuzz) - suffixFuzz;
+      if (retained === 0) {
+        if (await matches(expected, Math.max(0, prefixFuzz), suffixFuzz)) {
+          found = expected;
+          matchedPrefixFuzz = Math.max(0, prefixFuzz);
+          matchedSuffixFuzz = suffixFuzz;
+          break;
+        }
+        continue;
+      }
+      const maximum = source.length - hunk.oldCount + suffixFuzz;
+      const positiveLimit = maximum - expected;
+      const negativeLimit = Math.min(expected - cursor, expected);
+      const distanceLimit = Math.max(positiveLimit, negativeLimit);
+      const firstDistance = positiveLimit < 0 ? -positiveLimit : negativeLimit < 0 ? negativeLimit : 0;
+      for (let distance = firstDistance; distance <= distanceLimit; distance++) {
+        if (distance <= positiveLimit && await matches(expected + distance, Math.max(0, prefixFuzz), suffixFuzz)) {
+          found = expected + distance;
+          matchedPrefixFuzz = Math.max(0, prefixFuzz);
+          matchedSuffixFuzz = suffixFuzz;
+          break;
+        }
+        if (distance <= negativeLimit && await matches(expected - distance, Math.max(0, prefixFuzz), suffixFuzz)) {
+          found = expected - distance;
+          matchedPrefixFuzz = Math.max(0, prefixFuzz);
+          matchedSuffixFuzz = suffixFuzz;
+          break;
+        }
+      }
+      if (found >= 0) break;
+    }
+    const matched = found;
+    if (matched >= 0) offset = matched - startIndex(hunk.oldStart, hunk.oldCount);
+    if (misordered) found = -1;
+    application.outcomes?.push({
+      hunk,
+      index: hunkIndex + 1,
+      failed: found < 0,
+      misordered: found < 0 && misordered,
+      line: (matched < 0 ? startIndex(hunk.oldStart, hunk.oldCount) : matched) + 1 + outputOffset,
+      outputOffset,
+      offset: matched - startIndex(hunk.oldStart, hunk.oldCount),
+      fuzz: usedFuzz
+    });
+    if (found < 0 && application.merge && !misordered) {
+      const position = Math.max(cursor, Math.min(source.length, expected));
+      while (cursor < position) append(source[cursor++]);
+      let local = source.slice(cursor, cursor + hunk.oldCount);
+      if (!oldLines.some((line, index) => budget.equal(line.text, local[index] ?? ""))) local = [];
+      const incoming = hunk.lines.filter((line) => line.kind !== "-").map((line) => line.text);
+      const base = oldLines.map((line) => line.text);
+      let prefix = 0;
+      let suffix = 0;
+      while (prefix < Math.min(local.length, incoming.length, base.length) && local[prefix] === incoming[prefix] && local[prefix] === base[prefix]) prefix++;
+      while (suffix < Math.min(local.length, incoming.length, base.length) - prefix && local[local.length - suffix - 1] === incoming[incoming.length - suffix - 1] && local[local.length - suffix - 1] === base[base.length - suffix - 1]) suffix++;
+      budget.step(local.join("").length + incoming.join("").length + base.join("").length);
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+      for (const line of local.slice(0, prefix)) append(line);
+      const mergeStart = result.length + 1;
+      if (local.join("") === incoming.join("")) {
+        const last = application.outcomes?.pop();
+        if (last) application.outcomes.push({ ...last, failed: false, fuzz: 0, offset: position - startIndex(hunk.oldStart, hunk.oldCount) });
+        for (const line of local.slice(prefix, local.length - suffix)) append(line);
+      } else {
+        append("<<<<<<<\n");
+        for (const line of local.slice(prefix, local.length - suffix)) append(line);
+        if (application.merge === "diff3") {
+          append("|||||||\n");
+          for (const line of base.slice(prefix, base.length - suffix)) append(line);
+        }
+        append("=======\n");
+        for (const line of incoming.slice(prefix, incoming.length - suffix)) append(line);
+        append(">>>>>>>\n");
+        const last = application.outcomes?.pop();
+        if (last) application.outcomes.push({ ...last, mergeRange: [mergeStart, result.length] });
+      }
+      for (const line of local.slice(local.length - suffix)) append(line);
+      cursor += local.length;
+      outputOffset = result.length - cursor;
+      continue;
+    }
+    if (found < 0) {
+      if (application.partial) continue;
+      throw new ToolError(`hunk ${hunkIndex + 1} does not match ${patch.oldPath}`, 1);
+    }
+    while (cursor < found + matchedPrefixFuzz) append(source[cursor++]);
+    let removed = [];
+    let added = [];
+    const flush = () => {
+      if (!removed.length && !added.length) return;
+      if (application.ifdef) {
+        append(`#${removed.length ? "ifndef" : "ifdef"} ${application.ifdef}
+`);
+        for (const text2 of removed) append(text2);
+        if (removed.length && added.length) append("#else\n");
+        for (const text2 of added) append(text2);
+        append("#endif\n");
+      } else for (const text2 of added) append(text2);
+      removed = [];
+      added = [];
+    };
+    for (const line of hunk.lines.slice(matchedPrefixFuzz, hunk.lines.length - matchedSuffixFuzz)) {
+      if (line.kind === "+") added.push(line.text);
+      else if (line.kind === " ") {
+        flush();
+        if (cursor < source.length) append(source[cursor++]);
+      } else {
+        removed.push(source[cursor] ?? line.text);
+        cursor++;
+      }
+    }
+    flush();
+    outputOffset = result.length - cursor;
+  }
+  while (cursor < source.length) append(source[cursor++]);
+  for (let index = 0; index < result.length - 1; index++) {
+    budget.step();
+    if (!result[index].endsWith("\n")) {
+      if (++resultBytes > budget.limits.maxOutputBytes) throw new ToolError("output byte limit exceeded");
+      result[index] += "\n";
+    }
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+  }
+  const text = result.join("");
+  budget.output(text);
+  return text;
+}
+
+export {
+  startIndex,
+  parseUnified,
+  parseUnifiedSection,
+  reversePatch,
+  applyHunks
+};

package/dist/safe-bash/command-chunks/chunk-6EPHJGGF.js

@@ -0,0 +1,23 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-zip/src/sync.ts
+init_buffer();
+import { zipExtendedHelp, zipHelp, zipLicense, zipVersion } from "../../safe-bash-zip-engine/zip/help.js";
+import { DEFAULT_ARCHIVE_LIMITS } from "../../safe-bash-io-engine/commands/archive/internal.js";
+function evalSyncZip(args) {
+  if (args.length === 1) {
+    const a = args[0];
+    if (a === "-h" || a === "--help" || a === "-?") return zipHelp;
+    if (a === "-h2" || a === "--more-help") return zipExtendedHelp;
+    if (a === "-v" || a === "--version") return zipVersion;
+    if (a === "-L" || a === "--license") return zipLicense;
+  }
+  return void 0;
+}
+
+export {
+  evalSyncZip,
+  DEFAULT_ARCHIVE_LIMITS
+};

package/dist/safe-bash/command-chunks/chunk-6F4XCVON.js

@@ -0,0 +1,266 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-diff/src/diff-output.ts
+init_buffer();
+import { ToolError } from "../../safe-bash-diff-engine/shared.js";
+import { encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+function colorText(text, code, options) {
+  if (!options?.color) return text;
+  const newline = text.endsWith("\n");
+  return `\x1B[${code}m${newline ? text.slice(0, -1) : text}\x1B[0m${newline ? "\n" : ""}`;
+}
+function quoteDiffName(name) {
+  let needsQuotes = !name;
+  for (const character of name) {
+    if (character <= " " || character > "\x7F" || character === '"' || character === "\\") {
+      needsQuotes = true;
+      break;
+    }
+  }
+  if (!needsQuotes) return name;
+  const escapes = { 7: "\\a", 8: "\\b", 9: "\\t", 10: "\\n", 11: "\\v", 12: "\\f", 13: "\\r", 34: '\\"', 92: "\\\\" };
+  let quoted = '"';
+  for (const byte of encodeBytes(name)) {
+    quoted += escapes[byte] ?? (byte >= 32 && byte <= 127 ? String.fromCharCode(byte) : `\\${byte.toString(8).padStart(3, "0")}`);
+  }
+  return quoted + '"';
+}
+function quoteDiffArgument(argument) {
+  let needsQuotes = !argument || argument === "{" || argument === "}" || argument.startsWith("#") || argument.startsWith("~");
+  let doubleQuotes = argument.includes("'");
+  for (const character of argument) {
+    needsQuotes ||= " 	\n\r!\"$&'()*;<=>?[\\^`|".includes(character);
+    doubleQuotes &&= " %'+,-./0123456789:@ABCDEFGHIJKLMNOPQRSTUVWXYZ]_abcdefghijklmnopqrstuvwxyz".includes(character);
+  }
+  if (!needsQuotes) return argument;
+  if (doubleQuotes) return `"${argument}"`;
+  return `'${argument.replaceAll("'", "'\\''")}'`;
+}
+function expandTabs(line) {
+  let column = 0;
+  let result = "";
+  for (const character of line) {
+    if (character === "	") {
+      const count = 8 - column % 8;
+      result += " ".repeat(count);
+      column += count;
+    } else {
+      result += character;
+      if (character === "\r") column = 0;
+      else if (character === "\b") column = Math.max(0, column - 1);
+      else column++;
+    }
+  }
+  return result;
+}
+function clipped(line, width, expand) {
+  let column = 0, text = "";
+  for (const character of line) {
+    if (character === "\n") break;
+    const next = character === "	" ? column + 8 - column % 8 : column + 1;
+    if (next > width) break;
+    text += character === "	" && expand ? " ".repeat(next - column) : character;
+    column = next;
+  }
+  return { text, column };
+}
+function padding(column, target, expand) {
+  let result = "";
+  if (!expand) while (column + 8 - column % 8 <= target) {
+    result += "	";
+    column += 8 - column % 8;
+  }
+  return result + " ".repeat(Math.max(0, target - column));
+}
+async function sideBySide(changes, options, budget, append) {
+  let half = Math.max(0, Math.floor((options.width - 3) / 2));
+  let rightStart = options.width - half;
+  if (!options.expand) {
+    rightStart = Math.floor((options.width + 11) / 16) * 8;
+    half = Math.max(0, Math.min(rightStart - 3, options.width - rightStart));
+    if (half === 0) rightStart = options.width;
+  }
+  const markerColumn = Math.max(0, Math.floor((half + rightStart - 1) / 2));
+  const row = (left, right, marker) => {
+    if (marker === " " && options.suppressCommon) return;
+    if (options.width > budget.limits.maxOutputBytes) throw new ToolError("output byte limit exceeded");
+    const first = clipped(left ?? "", half, options.expand);
+    let text = first.text;
+    if (marker === " " && options.leftColumn) {
+      append(text + padding(first.column, markerColumn, options.expand) + "(" + (left?.endsWith("\n") ? "\n" : ""));
+      return;
+    }
+    if (marker !== " ") text += padding(first.column, markerColumn, options.expand) + marker;
+    if (right !== void 0 && right.length > 0 && right !== "\n") {
+      const column = marker === " " ? first.column : markerColumn + 1;
+      const second = clipped(right, half, options.expand);
+      text += padding(column, rightStart, options.expand) + second.text;
+    }
+    text += left?.endsWith("\n") || right?.endsWith("\n") ? "\n" : "";
+    append(options.color && (marker === "<" || marker === ">") ? `\x1B[${marker === "<" ? 31 : 32}m${text}\x1B[0m` : text);
+  };
+  let scan = 0;
+  while (scan < changes.length) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    const edit = changes[scan];
+    if (edit.kind === " " || edit.ignored) {
+      const old2 = [], next2 = [];
+      while (scan < changes.length && (changes[scan].kind === " " || changes[scan].ignored)) {
+        const item = changes[scan++];
+        if (item.kind !== "+") old2.push(item.line);
+        if (item.kind !== "-") next2.push(item.newLine ?? item.line);
+        budget.step(1 + item.line.length);
+        {
+          const c = budget.checkpoint();
+          if (c) await c;
+        }
+      }
+      for (let index = 0; index < Math.max(old2.length, next2.length); index++) {
+        row(old2[index], next2[index], old2[index] === void 0 ? ")" : next2[index] === void 0 ? "(" : " ");
+        budget.step();
+        {
+          const c = budget.checkpoint();
+          if (c) await c;
+        }
+      }
+      continue;
+    }
+    budget.hunk();
+    const old = [], next = [];
+    while (scan < changes.length && changes[scan].kind !== " ") {
+      const item = changes[scan++];
+      (item.kind === "-" ? old : next).push(item.line);
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+    for (let index = 0; index < Math.max(old.length, next.length); index++) {
+      const left = old[index], right = next[index];
+      row(left, right, left === void 0 ? ">" : right === void 0 ? "<" : !left.endsWith("\n") && right.endsWith("\n") ? "\\" : left.endsWith("\n") && !right.endsWith("\n") ? "/" : "|");
+      budget.step(1 + (left?.length ?? 0) + (right?.length ?? 0));
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+  }
+}
+async function script(changes, format, budget, append) {
+  const groups = [];
+  let scan = 0, position = 0;
+  while (scan < changes.length) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    if (changes[scan].kind === " ") {
+      position++;
+      scan++;
+      continue;
+    }
+    const group = { position, old: [], next: [] };
+    while (scan < changes.length && changes[scan].kind !== " ") {
+      const edit = changes[scan++];
+      (edit.kind === "-" ? group.old : group.next).push(edit.line);
+      if (edit.kind === "-") position++;
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+    budget.hunk();
+    if (!changes[scan - 1].ignored) groups.push(group);
+  }
+  if (format === "ed") groups.reverse();
+  for (const group of groups) {
+    if (format === "rcs") {
+      if (group.old.length) append(`d${group.position + 1} ${group.old.length}
+`);
+      if (group.next.length) append(`a${group.position + group.old.length} ${group.next.length}
+${group.next.join("")}`);
+    } else {
+      const start = group.position + 1, end = group.position + group.old.length;
+      const range = group.old.length > 1 ? `${start},${end}` : `${start}`;
+      append(`${group.old.length ? range : group.position}${group.old.length ? group.next.length ? "c" : "d" : "a"}
+`);
+      if (group.next.length) {
+        let inserted = 0;
+        for (const line of group.next) {
+          inserted++;
+          if (line === ".\n") {
+            append("..\n.\ns/.//\n");
+            if (inserted < group.next.length) append("a\n");
+          } else append(line);
+          budget.step(1 + line.length);
+          {
+            const c = budget.checkpoint();
+            if (c) await c;
+          }
+        }
+        if (group.next.at(-1) !== ".\n") append(".\n");
+      }
+    }
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+  }
+}
+async function ifdef(changes, symbol, budget, append) {
+  let scan = 0;
+  while (scan < changes.length) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    if (changes[scan].kind === " ") {
+      append(changes[scan++].line);
+      continue;
+    }
+    const old = [], next = [];
+    while (scan < changes.length && changes[scan].kind !== " ") {
+      const edit = changes[scan++];
+      (edit.kind === "-" ? old : next).push(edit.line);
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+    budget.hunk();
+    if (changes[scan - 1].ignored) {
+      append(old.join(""));
+      continue;
+    }
+    append(`#if${old.length ? "n" : ""}def ${symbol}
+`);
+    if (old.length) append(old.join(""));
+    if (old.length && next.length) append(`#else /* ${symbol} */
+`);
+    if (next.length) append(next.join(""));
+    append(`#endif /* ${old.length && !next.length ? "! " : ""}${symbol} */
+`);
+  }
+}
+
+export {
+  colorText,
+  quoteDiffName,
+  quoteDiffArgument,
+  expandTabs,
+  sideBySide,
+  script,
+  ifdef
+};