@poe-platform/safe-bash 0.1.799 → 0.1.801

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

@@ -0,0 +1,327 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-awk/src/awk-values.ts
+init_buffer();
+import { ProgramError } from "../../safe-bash-io-engine/commands/text-programs/shared.js";
+var AwkArray = class {
+  entries = /* @__PURE__ */ new Map();
+};
+var unset = Object.freeze({ kind: "unset" });
+var SMALL_NUMERICS = Array.from({ length: 4098 }, (_, i) => Object.freeze({ kind: "number", number: i - 1 }));
+var SMALL_NUMERIC_STRINGS = Array.from({ length: 4096 }, (_, i) => Object.freeze({ kind: "numeric", text: String(i), number: i }));
+var EMPTY_STRING_SCALAR = Object.freeze({ kind: "string", text: "" });
+var SCALAR_ZERO = SMALL_NUMERICS[1];
+var SCALAR_ONE = SMALL_NUMERICS[2];
+var numeric = (n) => (n | 0) === n && n >= -1 && n <= 4096 && (n !== 0 || !Object.is(n, -0)) ? SMALL_NUMERICS[n + 1] : { kind: "number", number: n };
+var string = (text2) => {
+  if (text2.length === 0) return EMPTY_STRING_SCALAR;
+  if (text2.length <= 16) text2 = String.fromCharCode(...Array.from({ length: text2.length }, (_, i) => text2.charCodeAt(i)));
+  return { kind: "string", text: text2 };
+};
+function inputValue(text2) {
+  const len = text2.length;
+  if (len === 0) return EMPTY_STRING_SCALAR;
+  const first = text2.charCodeAt(0);
+  if (first >= 48 && first <= 57 && len <= 15) {
+    let num = first - 48;
+    let allDigits = true;
+    for (let i = 1; i < len; i++) {
+      const c = text2.charCodeAt(i);
+      if (c < 48 || c > 57) {
+        allDigits = false;
+        break;
+      }
+      num = num * 10 + (c - 48);
+    }
+    if (allDigits) {
+      if (num < 4096 && (len === 1 || first !== 48)) return SMALL_NUMERIC_STRINGS[num];
+      return { kind: "numeric", text: text2, number: num };
+    }
+  }
+  if (first > 57 || first < 48 && first !== 32 && first !== 9 && first !== 10 && first !== 13 && first !== 43 && first !== 45 && first !== 46) {
+    return string(text2);
+  }
+  return /^[ \t\r\n]*[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?[ \t\r\n]*$/u.test(text2) ? { kind: "numeric", text: text2, number: Number(text2) } : string(text2);
+}
+function inputValueFromSlice(record, start, end) {
+  const len = end - start;
+  if (len <= 0) return EMPTY_STRING_SCALAR;
+  const first = record.charCodeAt(start);
+  if (first >= 48 && first <= 57 && len <= 15) {
+    let num = first - 48;
+    let allDigits = true;
+    for (let i = start + 1; i < end; i++) {
+      const c = record.charCodeAt(i);
+      if (c < 48 || c > 57) {
+        allDigits = false;
+        break;
+      }
+      num = num * 10 + (c - 48);
+    }
+    if (allDigits) {
+      if (num < 4096 && (len === 1 || first !== 48)) return SMALL_NUMERIC_STRINGS[num];
+      return { kind: "numeric", text: record.slice(start, end), number: num };
+    }
+  }
+  if (first > 57 || first < 48 && first !== 32 && first !== 9 && first !== 10 && first !== 13 && first !== 43 && first !== 45 && first !== 46) {
+    return string(record.slice(start, end));
+  }
+  return inputValue(record.slice(start, end));
+}
+function scalar(value) {
+  if (value instanceof AwkArray) throw new ProgramError("array used in scalar context");
+  return value;
+}
+function number(value) {
+  if (value.kind === "unset") return 0;
+  if (value.kind === "number" || value.kind === "numeric") return value.number;
+  const prefix = /^[ \t\r\n]*[+-]?(?:0[xX][0-9a-fA-F]+|(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?)/u.exec(value.text)?.[0];
+  if (prefix === void 0) return 0;
+  if (prefix.includes("x") || prefix.includes("X")) {
+    const trimmed = prefix.trimStart();
+    const sign = trimmed[0] === "-" ? -1 : 1;
+    const digits = trimmed.slice(trimmed[0] === "+" || trimmed[0] === "-" ? 3 : 2);
+    return sign * Number.parseInt(digits, 16);
+  }
+  return Number(prefix);
+}
+function truth(value) {
+  return value.kind === "unset" ? false : value.kind === "number" || value.kind === "numeric" ? value.number !== 0 : value.text !== "";
+}
+function general(value, precision, alternate) {
+  precision = Math.max(1, precision);
+  if (value === 0) return alternate ? 0 .toFixed(precision - 1) : "0";
+  const rounded = Number(value.toPrecision(precision));
+  const exponent = Math.floor(Math.log10(Math.abs(rounded)));
+  let result = exponent < -4 || exponent >= precision ? rounded.toExponential(precision - 1) : rounded.toFixed(Math.max(0, precision - exponent - 1));
+  if (!alternate) result = result.replace(/(\.[0-9]*?)0+(?=e|$)/u, "$1").replace(/\.(?=e|$)/u, "");
+  return result;
+}
+function preciseFloat(value, precision, conversion, alternate, admit) {
+  const buffer = new ArrayBuffer(8);
+  const view = new DataView(buffer);
+  view.setFloat64(0, Math.abs(value));
+  const bits = view.getBigUint64(0);
+  const exponentBits = Number(bits >> 52n & 2047n);
+  let mantissa = bits & (1n << 52n) - 1n;
+  if (exponentBits) mantissa += 1n << 52n;
+  const power = (exponentBits || 1) - 1023 - 52;
+  const digits = (power >= 0 ? mantissa << BigInt(power) : mantissa * 5n ** BigInt(-power)).toString();
+  const point = digits.length + Math.min(0, power);
+  const negative = value < 0 ? "-" : "";
+  if (conversion.toLowerCase() === "f") {
+    admit(Math.max(1, value === 0 ? 1 : point) + precision + 1 + negative.length);
+    const count = point + precision;
+    let scaled = count >= digits.length ? digits.padEnd(count, "0") : count <= 0 ? "0" : digits.slice(0, count);
+    if (count >= 0 && count < digits.length && Number(digits[count]) >= 5) scaled = (BigInt(scaled) + 1n).toString();
+    scaled = scaled.padStart(precision + 1, "0");
+    return negative + scaled.slice(0, -precision) + "." + scaled.slice(-precision);
+  }
+  const significant = conversion.toLowerCase() === "g" ? precision : precision + 1;
+  const exact = digits.replace(/^0+/u, "") || "0";
+  const exponent = value === 0 ? 0 : point - 1;
+  let rounded = exact.slice(0, significant);
+  if (exact.length > significant && Number(exact[significant]) >= 5) rounded = (BigInt(rounded) + 1n).toString();
+  const exponential = conversion.toLowerCase() === "e" || exponent < -4 || exponent >= significant;
+  const padded = conversion.toLowerCase() !== "g" || alternate;
+  if (padded) {
+    admit(negative.length + (exponential ? significant + 3 + Math.max(2, String(Math.abs(exponent)).length) : significant + 1 + Math.max(0, -exponent)));
+    rounded = rounded.padEnd(significant, "0");
+  } else rounded = rounded.replace(/0+$/u, "") || "0";
+  let result;
+  if (exponential) {
+    result = rounded[0] + "." + rounded.slice(1) + "e" + (exponent < 0 ? "-" : "+") + Math.abs(exponent);
+  } else {
+    const decimalPoint = exponent + 1;
+    result = decimalPoint <= 0 ? "0." + "0".repeat(-decimalPoint) + rounded : rounded.slice(0, decimalPoint).padEnd(decimalPoint, "0") + "." + rounded.slice(decimalPoint);
+  }
+  if (conversion.toLowerCase() === "g" && !alternate) result = result.replace(/(\.[0-9]*?)0+(?=e|$)/u, "$1").replace(/\.(?=e|$)/u, "");
+  return negative + result;
+}
+function scanFormat(format, offset) {
+  let cursor = offset + 1;
+  const flagsStart = cursor;
+  while (cursor < format.length && "-+ #0".includes(format[cursor])) cursor++;
+  const flags = format.slice(flagsStart, cursor);
+  const amount = () => {
+    const start = cursor;
+    if (format[cursor] === "*") cursor++;
+    else while (cursor < format.length && format[cursor] >= "0" && format[cursor] <= "9") cursor++;
+    return format.slice(start, cursor);
+  };
+  const width = amount();
+  let precision;
+  if (format[cursor] === ".") {
+    cursor++;
+    precision = amount();
+  }
+  const conversion = format[cursor];
+  if (conversion === void 0 || !"csdiuoxXfFeEgG".includes(conversion)) {
+    throw new ProgramError(`unsupported format near '${format.slice(offset)}'`);
+  }
+  return { end: cursor + 1, flags, width, precision, conversion };
+}
+function validateFormat(format) {
+  for (let offset = 0; offset < format.length; ) {
+    if (format[offset] !== "%") {
+      offset++;
+      continue;
+    }
+    if (format[offset + 1] === "%") {
+      offset += 2;
+      continue;
+    }
+    const match = scanFormat(format, offset);
+    offset = match.end;
+    if (match.width !== "*" && !Number.isSafeInteger(Number(match.width ?? 0)) || match.precision !== "*" && !Number.isSafeInteger(Number(match.precision ?? 0))) throw new ProgramError("excessive format width or precision");
+  }
+}
+function formatted(format, values, text2, budget) {
+  budget?.step(format.length);
+  let result = "";
+  let argument = 0;
+  const limit = budget?.maxBufferBytes ?? Infinity;
+  const admit = (length) => {
+    budget?.step(0);
+    if (length > limit - result.length) throw new ProgramError("text buffer limit exceeded");
+    budget?.step(length);
+  };
+  const amountOf = (value) => {
+    budget?.step(value.kind === "string" ? value.text.length : 0);
+    return number(value);
+  };
+  const take = () => {
+    const value = values[argument++];
+    if (value === void 0) throw new ProgramError("not enough arguments for format");
+    return value;
+  };
+  for (let offset = 0; offset < format.length; ) {
+    if (format[offset] !== "%") {
+      admit(1);
+      result += format[offset++];
+      continue;
+    }
+    if (format[offset + 1] === "%") {
+      admit(1);
+      result += "%";
+      offset += 2;
+      continue;
+    }
+    const match = scanFormat(format, offset);
+    offset = match.end;
+    let flags = match.flags;
+    let width = match.width === "*" ? Math.trunc(amountOf(take())) : Number(match.width ?? 0);
+    let precision = match.precision === void 0 ? void 0 : match.precision === "*" ? Math.trunc(amountOf(take())) : Number(match.precision || 0);
+    if (width < 0) {
+      flags += "-";
+      width = -width;
+    }
+    if (precision !== void 0 && precision < 0) precision = void 0;
+    const conversion = match.conversion;
+    if (!Number.isSafeInteger(width) || precision !== void 0 && !Number.isSafeInteger(precision)) throw new ProgramError("excessive format width or precision");
+    const value = take();
+    let part;
+    if (conversion === "s") {
+      const source = text2(value);
+      admit(Math.min(source.length, precision ?? source.length));
+      part = source.slice(0, precision);
+    } else if (conversion === "c") {
+      admit(1);
+      part = value.kind === "string" ? value.text[0] ?? "\0" : String.fromCharCode(Math.trunc(amountOf(value)) & 255);
+    } else {
+      const amount = amountOf(value);
+      if (!Number.isFinite(amount)) throw new ProgramError("cannot format a non-finite number");
+      budget?.step(1 + (/[fFeEgG]/u.test(conversion) ? precision ?? 6 : 0));
+      if (/[fFeEgG]/u.test(conversion) && (precision ?? 6) > 100) {
+        part = preciseFloat(amount, precision, conversion, flags.includes("#"), admit);
+      } else if (conversion === "f" || conversion === "F") part = amount.toFixed(precision ?? 6);
+      else if (conversion === "e" || conversion === "E") part = amount.toExponential(precision ?? 6);
+      else if (conversion === "g" || conversion === "G") part = general(amount, precision ?? 6, flags.includes("#"));
+      else {
+        const radix = conversion === "o" ? 8 : conversion === "x" || conversion === "X" ? 16 : 10;
+        const integer = BigInt(Math.trunc(amount));
+        part = (/[uoxX]/u.test(conversion) ? BigInt.asUintN(32, integer) : integer).toString(radix);
+        if (precision !== void 0) {
+          const negative = part.startsWith("-");
+          admit(amount === 0 && precision === 0 ? 0 : Math.max(part.length, precision + Number(negative)));
+          part = amount === 0 && precision === 0 ? "" : negative ? `-${part.slice(1).padStart(precision, "0")}` : part.padStart(precision, "0");
+        }
+        if (flags.includes("#") && amount !== 0) {
+          const prefix = radix === 16 ? "0x" : radix === 8 ? "0" : "";
+          admit(prefix.length + part.length);
+          part = prefix + part;
+        }
+      }
+      admit(part.length);
+      part = part.replace(/e([+-])([0-9])$/u, "e$10$2");
+      if (/[XFEG]/u.test(conversion)) {
+        admit(part.length);
+        part = part.toUpperCase();
+      }
+      if (amount >= 0 && !/[uoxX]/u.test(conversion)) {
+        const prefix = flags.includes("+") ? "+" : flags.includes(" ") ? " " : "";
+        admit(prefix.length + part.length);
+        part = prefix + part;
+      }
+      if (flags.includes("#") && /[fFeE]/u.test(conversion)) {
+        budget?.step(part.length);
+        if (!part.includes(".")) {
+          admit(part.length + 1);
+          part = part.replace(/([eE]|$)/u, ".$1");
+        }
+      }
+    }
+    admit(Math.max(part.length, width));
+    if (flags.includes("-")) part = part.padEnd(width, " ");
+    else if (flags.includes("0") && /[diuoxXfFeEgG]/u.test(conversion) && (precision === void 0 || /[fFeEgG]/u.test(conversion))) {
+      const prefix = /^(?:[+ -]|0[xX])/u.exec(part)?.[0] ?? "";
+      part = prefix + part.slice(prefix.length).padStart(Math.max(0, width - prefix.length), "0");
+    } else part = part.padStart(width, " ");
+    admit(part.length);
+    result += part;
+  }
+  return result;
+}
+function text(value, format = "%.6g", budget) {
+  if (value.kind === "unset") return "";
+  if (value.kind !== "number") return value.text;
+  if (Number.isInteger(value.number) && Math.abs(value.number) < 1e21) {
+    budget?.step(0);
+    const n = value.number;
+    const result = (n | 0) === n && n >= 0 && n < 4096 ? SMALL_NUMERIC_STRINGS[n].text : String(n);
+    budget?.check(result);
+    budget?.step(result.length);
+    return result;
+  }
+  return formatted(format, [value], (argument) => String(number(argument)), budget);
+}
+function compare(left, right, format, budget) {
+  if (left.kind !== "string" && right.kind !== "string") {
+    const first2 = number(left);
+    const second2 = number(right);
+    return first2 < second2 ? -1 : first2 > second2 ? 1 : 0;
+  }
+  const first = text(left, format, budget);
+  const second = text(right, format, budget);
+  return first < second ? -1 : first > second ? 1 : 0;
+}
+
+export {
+  AwkArray,
+  unset,
+  SCALAR_ZERO,
+  SCALAR_ONE,
+  numeric,
+  string,
+  inputValue,
+  inputValueFromSlice,
+  scalar,
+  number,
+  truth,
+  validateFormat,
+  formatted,
+  text,
+  compare
+};

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
+};