@poe-platform/safe-bash 0.1.756 → 0.1.757

package/dist/safe-bash/chunks/chunk-ISCZG7WA.js

@@ -1,2648 +0,0 @@
-import {
-  __reExport,
-  init_platform
-} from "./chunk-ZG7GWQ5P.js";
-
-// packages/safe-bash-io-engine/src/internal.ts
-init_platform();
-import { builtInDirectContextExecutors } from "../../safe-bash-contracts/runtime-control.js";
-
-// packages/safe-bash-query-engine/src/path.ts
-var path_exports = {};
-init_platform();
-__reExport(path_exports, path_star);
-import * as path_star from "../../safe-bash-contracts/path.js";
-
-// packages/safe-bash-io-engine/src/internal.ts
-import { UsageError, publicDiagnosticMessage } from "../../safe-bash-contracts/diagnostics.js";
-import { assertCommandRequirements } from "../../safe-bash-contracts/command-requirements.js";
-import { writeDiagnostic as writeDiagnostic2 } from "../../safe-bash-contracts/escaping.js";
-
-// packages/safe-bash-io-engine/src/portable-requirements.ts
-init_platform();
-var inputRequirements = [
-  { id: "stdin", description: "Read standard input", capabilities: [] },
-  { id: "file", description: "Read file operands", capabilities: [], anyOf: [["streamingRead"], ["read"]] }
-];
-var textOutputRequirements = [
-  ...inputRequirements,
-  { id: "output", description: "Write or truncate an output file", capabilities: [], anyOf: [["streamingWrite"], ["write"]], mutates: true }
-];
-var pwdRequirements = [
-  { id: "logical", description: "Print the logical working directory", capabilities: [] },
-  { id: "physical", description: "Resolve the physical working directory (-P)", capabilities: ["realpath"] }
-];
-var predicateRequirements = [
-  { id: "expression", description: "Evaluate strings and integers", capabilities: [] },
-  { id: "metadata", description: "Inspect file metadata", capabilities: ["stat"] },
-  { id: "access", description: "Inspect path access permissions", capabilities: ["access"] }
-];
-
-// packages/safe-bash-io-engine/src/record-buffer.ts
-init_platform();
-import { FsError } from "../../safe-bash-contracts/index.js";
-var segmentSize = 4096;
-var RecordBuffer = class {
-  constructor(capacity, finalizationCapacity = capacity * 2) {
-    this.capacity = capacity;
-    this.finalizationCapacity = finalizationCapacity;
-  }
-  capacity;
-  finalizationCapacity;
-  #segments = [];
-  #size = 0;
-  #allocated = 0;
-  get size() {
-    return this.#size;
-  }
-  #admit(length) {
-    if (length > this.capacity - this.#size) {
-      throw new FsError("EFBIG", { message: "line buffer limit exceeded" });
-    }
-  }
-  append(bytes, start = 0, end = bytes.length) {
-    this.#admit(end - start);
-    let offset = start;
-    while (offset < end) {
-      let segment = this.#segments.at(-1);
-      const used = this.#size % segmentSize;
-      if (!segment || used === 0) {
-        segment = new Uint8Array(Math.min(segmentSize, this.capacity - this.#allocated));
-        this.#segments.push(segment);
-        this.#allocated += segment.length;
-      }
-      const length = Math.min(end - offset, segment.length - used);
-      segment.set(bytes.subarray(offset, offset + length), used);
-      this.#size += length;
-      offset += length;
-    }
-  }
-  finish(admit, bytes, start = 0, end = bytes?.length ?? 0) {
-    const tailLength = end - start;
-    this.#admit(tailLength);
-    const size = this.#size + tailLength;
-    admit?.(size);
-    if (size > this.finalizationCapacity - this.#allocated) {
-      throw new FsError("EFBIG", { message: "line finalization buffer limit exceeded" });
-    }
-    if (this.#size === 0) {
-      const result2 = new Uint8Array(tailLength);
-      if (bytes && tailLength > 0) result2.set(bytes.subarray(start, end));
-      return result2;
-    }
-    const result = new Uint8Array(size);
-    let offset = 0;
-    for (const segment of this.#segments) {
-      const length = Math.min(segment.length, this.#size - offset);
-      result.set(segment.subarray(0, length), offset);
-      offset += length;
-    }
-    if (bytes && tailLength > 0) result.set(bytes.subarray(start, end), offset);
-    this.clear();
-    return result;
-  }
-  clear() {
-    if (this.#segments.length) this.#segments.length = 0;
-    this.#size = 0;
-    this.#allocated = 0;
-  }
-};
-
-// packages/safe-bash-io-engine/src/gnu-information.ts
-init_platform();
-import { writeBytes } from "../../safe-bash-contracts/index.js";
-var information = {
-  cat: { usage: "[OPTION]... [FILE]...", description: "Concatenate input files.", options: ["-n, --number", "-b, --number-nonblank", "-s, --squeeze-blank", "-E, --show-ends", "-T, --show-tabs", "-v, --show-nonprinting", "-A, --show-all"], versionOnly: true },
-  du: { usage: "[OPTION]... [FILE]...", description: "Report virtual file allocation.", options: ["-a, --all", "-s, --summarize", "-c, --total", "-h, --human-readable", "-B, --block-size=SIZE", "-b, --bytes", "--apparent-size", "-d, --max-depth=NUM", "-X, --exclude-from=FILE", "--exclude=PATTERN", "-t, --threshold=SIZE"], versionOnly: true },
-  base32: { usage: "[OPTION]... [FILE]", description: "Encode or decode Base32 data.", options: ["-d, --decode", "-i, --ignore-garbage", "-w, --wrap=COLS"] },
-  base64: { usage: "[OPTION]... [FILE]", description: "Encode or decode Base64 data.", options: ["-d, --decode", "-i, --ignore-garbage", "-w, --wrap=COLS"] },
-  basename: { usage: "[OPTION]... NAME... [SUFFIX]", description: "Remove directory components and an optional suffix from names.", options: ["-a, --multiple", "-s, --suffix=SUFFIX", "-z, --zero"] },
-  dirname: { usage: "[OPTION]... NAME...", description: "Print the directory component of each name.", options: ["-z, --zero"] },
-  chmod: { usage: "[OPTION]... MODE FILE...", description: "Change virtual file permissions, subject to filesystem capabilities.", options: ["-R, --recursive", "-v, --verbose", "-c, --changes", "-f, --silent, --quiet", "--reference=FILE"] },
-  cksum: { usage: "[OPTION]... [FILE]...", description: "Compute checksums of files or standard input.", options: ["-a, --algorithm=TYPE", "-b, --binary", "-z, --zero", "--tag", "--untagged", "--raw", "--base64"] },
-  comm: { usage: "[OPTION]... FILE1 FILE2", description: "Compare sorted files in the C/POSIX byte locale.", options: ["-1", "-2", "-3", "--output-delimiter=STR", "--check-order", "--nocheck-order"] },
-  cp: { usage: "[OPTION]... SOURCE... DEST", description: "Copy virtual files, subject to filesystem capabilities.", options: ["-a, --archive", "-r, -R, --recursive", "-f, --force", "-i, --interactive", "-n, --no-clobber", "-v, --verbose", "-t, --target-directory=DIR", "-T, --no-target-directory", "-S, --suffix=SUFFIX"] },
-  cut: { usage: "[OPTION]... [FILE]...", description: "Select bytes, characters or fields from each input line.", options: ["-b, --bytes=LIST", "-c, --characters=LIST", "-f, --fields=LIST", "-d, --delimiter=CHAR", "-s, --only-delimited", "-z, --zero-terminated", "--output-delimiter=STR", "--complement"] },
-  env: { usage: "[OPTION]... [NAME=VALUE]... [COMMAND [ARG]...]", description: "Print the environment or run a registered command with a modified environment.", options: ["-i, --ignore-environment", "-u, --unset=NAME", "-C, --chdir=DIR", "-S, --split-string=STR", "-0, --null"], stopAtOperand: true },
-  expand: { usage: "[OPTION]... [FILE]...", description: "Convert tabs to spaces.", options: ["-i, --initial", "-t, --tabs=LIST"] },
-  fold: { usage: "[OPTION]... [FILE]...", description: "Wrap input lines to a selected width.", options: ["-b, --bytes", "-s, --spaces", "-w, --width=COLS"] },
-  head: { usage: "[OPTION]... [FILE]...", description: "Print the first ten lines by default, or a selected line/byte count.", options: ["-n, --lines=NUM", "-c, --bytes=NUM", "-q, --quiet, --silent", "-v, --verbose", "-z, --zero-terminated"] },
-  tail: { usage: "[OPTION]... [FILE]...", description: "Print the last ten lines by default, or a selected line/byte count.", options: ["-n, --lines=NUM", "-c, --bytes=NUM", "-q, --quiet, --silent", "-v, --verbose", "-z, --zero-terminated"] },
-  join: { usage: "[OPTION]... FILE1 FILE2", description: "Join sorted files on a common field in the C/POSIX byte locale.", options: ["-1=FIELD", "-2=FIELD", "-j=FIELD", "-t=CHAR", "-a=FILENUM", "-v=FILENUM", "-e=STR", "-o=FORMAT", "-i", "--check-order", "--nocheck-order"] },
-  ln: { usage: "[OPTION]... TARGET... LINK_NAME", description: "Create virtual hard or symbolic links when supported by the filesystem.", options: ["-s, --symbolic", "-r, --relative", "-f, --force", "-i, --interactive", "-n, --no-dereference", "-v, --verbose", "-t, --target-directory=DIR", "-T, --no-target-directory", "-S, --suffix=SUFFIX"] },
-  ls: { usage: "[OPTION]... [FILE]...", description: "List virtual directory entries.", options: ["-a, --all", "-A, --almost-all", "-l", "-1", "-d, --directory", "-F, --classify", "-r, --reverse", "-R, --recursive", "-L, --dereference", "-h, --human-readable"] },
-  mkdir: { usage: "[OPTION]... DIRECTORY...", description: "Create virtual directories.", options: ["-p, --parents", "-m, --mode=MODE", "-v, --verbose"] },
-  mktemp: { usage: "[OPTION]... [TEMPLATE]", description: "Create a temporary virtual file or directory.", options: ["-d, --directory", "-q, --quiet", "-u, --dry-run", "-p=DIR", "--tmpdir[=DIR]", "--suffix=SUFFIX"] },
-  mv: { usage: "[OPTION]... SOURCE... DEST", description: "Move virtual files, subject to filesystem capabilities.", options: ["-f, --force", "-i, --interactive", "-n, --no-clobber", "-u, --update", "-v, --verbose", "-t, --target-directory=DIR", "-T, --no-target-directory", "-S, --suffix=SUFFIX"] },
-  nl: { usage: "[OPTION]... [FILE]...", description: "Number input lines by section and numbering style.", options: ["-b, --body-numbering=STYLE", "-h, --header-numbering=STYLE", "-f, --footer-numbering=STYLE", "-v, --starting-line-number=NUM", "-i, --line-increment=NUM", "-s, --number-separator=STR", "-w, --number-width=NUM", "-n, --number-format=FORMAT", "-d, --section-delimiter=STR", "-l, --join-blank-lines=NUM", "-p, --no-renumber"] },
-  od: { usage: "[OPTION]... [FILE]...", description: "Print input bytes in selected numeric formats.", options: ["-A, --address-radix=RADIX", "-j, --skip-bytes=NUM", "-N, --read-bytes=NUM", "-t, --format=TYPE, --type=TYPE", "-w, --width=NUM", "--endian=ORDER", "-v, --output-duplicates"] },
-  paste: { usage: "[OPTION]... [FILE]...", description: "Merge corresponding or serial input lines.", options: ["-s, --serial", "-d, --delimiters=LIST", "-z, --zero-terminated"] },
-  readlink: { usage: "[OPTION]... FILE...", description: "Print symbolic link targets or canonical virtual paths.", options: ["-f, --canonicalize", "-e, --canonicalize-existing", "-m, --canonicalize-missing", "-n, --no-newline", "-z, --zero"] },
-  realpath: { usage: "[OPTION]... FILE...", description: "Print canonical virtual paths.", options: ["-e, --canonicalize-existing", "-m, --canonicalize-missing", "-s, --strip, --no-symlinks", "-z, --zero"] },
-  rm: { usage: "[OPTION]... FILE...", description: "Remove virtual files and directories.", options: ["-r, -R, --recursive", "-f, --force", "-d, --dir", "-v, --verbose", "-i", "-I"] },
-  rmdir: { usage: "[OPTION]... DIRECTORY...", description: "Remove empty virtual directories.", options: ["-p, --parents", "-v, --verbose", "--ignore-fail-on-non-empty"] },
-  seq: { usage: "[OPTION]... [FIRST [INCREMENT]] LAST", description: "Print a numeric sequence.", options: ["-s, --separator=STR", "-f, --format=FORMAT", "-w, --equal-width"] },
-  sort: { usage: "[OPTION]... [FILE]...", description: "Sort input records using the supported byte-oriented ordering modes.", options: ["-n, --numeric-sort", "-g, --general-numeric-sort", "-h, --human-numeric-sort", "-V, --version-sort", "-r, --reverse", "-f, --ignore-case", "-u, --unique", "-s, --stable", "-m, --merge", "-k, --key=KEY", "-t, --field-separator=CHAR", "-o, --output=FILE", "--sort=MODE", "-z, --zero-terminated"] },
-  split: { usage: "[OPTION]... [FILE [PREFIX]]", description: "Split input into virtual output files.", options: ["-l, --lines=NUM", "-b, --bytes=SIZE", "-C, --line-bytes=SIZE", "-a, --suffix-length=NUM", "--additional-suffix=SUFFIX"] },
-  stat: { usage: "[OPTION]... FILE...", description: "Display virtual file metadata supplied by the filesystem.", options: ["-L, --dereference", "-c, --format=FORMAT", "--printf=FORMAT", "-t, --terse"] },
-  tac: { usage: "[OPTION]... [FILE]...", description: "Print input records in reverse order.", options: ["-b, --before", "-r, --regex", "-s, --separator=STR"] },
-  tee: { usage: "[OPTION]... [FILE]...", description: "Copy standard input to standard output and virtual files.", options: ["-a, --append", "-i, --ignore-interrupts", "--output-error=MODE"] },
-  touch: { usage: "[OPTION]... FILE...", description: "Update virtual file timestamps, creating missing files by default.", options: ["-a", "-m", "-c, --no-create", "-h, --no-dereference", "-r, --reference=FILE", "-d, --date=STR", "-t=STAMP"] },
-  tr: { usage: "[OPTION]... STRING1 [STRING2]", description: "Translate, delete or squeeze input bytes.", options: ["-d, --delete", "-s, --squeeze-repeats", "-c, -C, --complement", "-t, --truncate-set1"] },
-  unexpand: { usage: "[OPTION]... [FILE]...", description: "Convert spaces to tabs.", options: ["-a, --all", "-t, --tabs=LIST", "--first-only"] },
-  uniq: { usage: "[OPTION]... [INPUT [OUTPUT]]", description: "Filter adjacent repeated input records.", options: ["-c, --count", "-d, --repeated", "-u, --unique", "-i, --ignore-case", "-f, --skip-fields=NUM", "-s, --skip-chars=NUM", "-w, --check-chars=NUM", "-z, --zero-terminated"] },
-  wc: { usage: "[OPTION]... [FILE]...", description: "Count input lines, words, bytes, characters or display width.", options: ["-l, --lines", "-w, --words", "-c, --bytes", "-m, --chars", "-L, --max-line-length"] },
-  pwd: { usage: "[OPTION]...", description: "Print the full filename of the current working directory.", options: ["-L, --logical", "-P, --physical"] },
-  true: { usage: "[ignored command line arguments]", description: "Exit with a status code indicating success.", options: [] },
-  false: { usage: "[ignored command line arguments]", description: "Exit with a status code indicating failure.", options: [] },
-  echo: { usage: "[SHORT-OPTION]... [STRING]...", description: "Echo the STRING(s) to standard output.", options: ["-n", "-e", "-E"] },
-  "[": { usage: "EXPRESSION ]", description: "Evaluate conditional expression.", options: [] }
-};
-var checksumInformation = {
-  usage: "[OPTION]... [FILE]...",
-  description: "Compute or verify file digests.",
-  options: ["-b, --binary", "-c, --check", "-t, --text", "-z, --zero", "--tag", "--quiet", "--status", "--strict", "--warn", "--ignore-missing"]
-};
-function gnuInformationSync(name, args, externalInvocation = false) {
-  if (!args.includes("--help") && !args.includes("--version")) return void 0;
-  if ((name === "true" || name === "false" || name === "echo" || name === "[" || name === "pwd") && (args.length !== 1 || !externalInvocation)) return void 0;
-  const info = information[name] ?? (["md5sum", "sha1sum", "sha224sum", "sha256sum", "sha384sum", "sha512sum"].includes(name) ? checksumInformation : void 0);
-  if (!info) return void 0;
-  const flags = /* @__PURE__ */ new Map();
-  for (const option of info.options) {
-    const takesValue = option.includes("[=") ? "optional" : option.includes("=") ? "required" : "none";
-    for (const spelling of option.split(", ")) flags.set(spelling.split("=")[0].split("[")[0], takesValue);
-  }
-  for (let index = 0; index < args.length; index++) {
-    const arg = args[index];
-    if (arg === "--") break;
-    if (arg === "--help" || arg === "--version") {
-      if (arg === "--help" && info.versionOnly) return void 0;
-      return arg === "--version" ? `${name} (safe-bash virtual implementation)
-` : `Usage: ${name} ${info.usage}
-${info.description}
-
-Common supported options (additional behavior is documented in the package):
-${info.options.map((option) => `  ${option.split(", ").map((spelling) => spelling.startsWith("--") ? spelling : spelling.replace("=", " ")).join(", ")}`).join("\n")}
-  --help     display this help and exit
-  --version  display implementation information and exit
-
-This is the safe-bash virtual implementation; filesystem operations require backend capabilities.
-`;
-    }
-    if (!arg.startsWith("-") || arg === "-") {
-      if (info.stopAtOperand) break;
-      continue;
-    }
-    if (arg.startsWith("--")) {
-      const equal = arg.indexOf("=");
-      const spelling = equal < 0 ? arg : arg.slice(0, equal);
-      if (!flags.has(spelling)) return void 0;
-      if (flags.get(spelling) === "required" && equal < 0) index++;
-      else if (flags.get(spelling) === "none" && equal >= 0) return void 0;
-    } else {
-      for (let offset = 1; offset < arg.length; offset++) {
-        const spelling = `-${arg[offset]}`;
-        if (!flags.has(spelling)) return void 0;
-        if (flags.get(spelling) === "required") {
-          if (offset + 1 === arg.length) index++;
-          break;
-        }
-      }
-    }
-  }
-  return void 0;
-}
-function gnuInformation(name, context) {
-  if (!context.args.includes("--help") && !context.args.includes("--version")) return void 0;
-  return gnuInformationSlow(name, context);
-}
-async function gnuInformationSlow(name, context) {
-  if ((name === "true" || name === "false" || name === "echo" || name === "[") && (context.args.length !== 1 || !context.externalInvocation)) return void 0;
-  const info = information[name] ?? (["md5sum", "sha1sum", "sha224sum", "sha256sum", "sha384sum", "sha512sum"].includes(name) ? checksumInformation : void 0);
-  if (!info) return void 0;
-  const flags = /* @__PURE__ */ new Map();
-  for (const option of info.options) {
-    const takesValue = option.includes("[=") ? "optional" : option.includes("=") ? "required" : "none";
-    for (const spelling of option.split(", ")) flags.set(spelling.split("=")[0].split("[")[0], takesValue);
-  }
-  for (let index = 0; index < context.args.length; index++) {
-    const arg = context.args[index];
-    if (arg === "--") break;
-    if (arg === "--help" || arg === "--version") {
-      if (arg === "--help" && info.versionOnly) return void 0;
-      const text = arg === "--version" ? `${name} (safe-bash virtual implementation)
-` : `Usage: ${name} ${info.usage}
-${info.description}
-
-Common supported options (additional behavior is documented in the package):
-${info.options.map((option) => `  ${option.split(", ").map((spelling) => spelling.startsWith("--") ? spelling : spelling.replace("=", " ")).join(", ")}`).join("\n")}
-  --help     display this help and exit
-  --version  display implementation information and exit
-
-This is the safe-bash virtual implementation; filesystem operations require backend capabilities.
-`;
-      await writeBytes(context.stdout, new TextEncoder().encode(text), context.signal);
-      return { exitCode: 0 };
-    }
-    if (!arg.startsWith("-") || arg === "-") {
-      if (info.stopAtOperand) break;
-      continue;
-    }
-    if (arg.startsWith("--")) {
-      const equal = arg.indexOf("=");
-      const spelling = equal < 0 ? arg : arg.slice(0, equal);
-      if (!flags.has(spelling)) return void 0;
-      if (flags.get(spelling) === "required" && equal < 0) index++;
-      else if (flags.get(spelling) === "none" && equal >= 0) return void 0;
-    } else {
-      for (let offset = 1; offset < arg.length; offset++) {
-        const spelling = `-${arg[offset]}`;
-        if (!flags.has(spelling)) return void 0;
-        if (flags.get(spelling) === "required") {
-          if (offset + 1 === arg.length) index++;
-          break;
-        }
-      }
-    }
-  }
-  return void 0;
-}
-
-// packages/safe-bash-io-engine/src/internal.ts
-import { getRuntimeBackingFileSystem } from "../../safe-bash-contracts/runtime-control.js";
-import {
-  FsError as FsError3,
-  readBytes,
-  toByteSource,
-  writeBytes as writeBytes3
-} from "../../safe-bash-contracts/index.js";
-import { builtInDirectContextExecutors as builtInDirectContextExecutors2 } from "../../safe-bash-contracts/runtime-control.js";
-import { isDefaultCommandOptions, registerDefaultExecutor, registerDefaultExecutors } from "../../safe-bash-contracts/command.js";
-import { UsageError as UsageError2 } from "../../safe-bash-contracts/diagnostics.js";
-
-// packages/safe-bash-io-engine/src/commands/touch-times.ts
-init_platform();
-import { PublicDiagnostic } from "../../safe-bash-contracts/diagnostics.js";
-
-// packages/safe-bash-calendar-engine/src/time-env/calendar.ts
-init_platform();
-
-// packages/safe-bash-calendar-engine/src/time-env/shared.ts
-init_platform();
-
-// packages/safe-bash-byte-engine/src/index.ts
-init_platform();
-var encoder = new TextEncoder();
-function utf8ByteLength(value2) {
-  let size = 0;
-  for (let i = 0; i < value2.length; i++) {
-    const code = value2.charCodeAt(i);
-    if (code < 128) size++;
-    else if (code < 2048) size += 2;
-    else if (code >= 55296 && code <= 56319 && i + 1 < value2.length && value2.charCodeAt(i + 1) >= 56320 && value2.charCodeAt(i + 1) <= 57343) {
-      size += 4;
-      i++;
-    } else size += 3;
-  }
-  return size;
-}
-function bytesFrom(value2, offset, length) {
-  if (typeof value2 === "string") {
-    if (offset === "latin1") {
-      const bytes = new Uint8Array(value2.length);
-      for (let i = 0; i < value2.length; i++) bytes[i] = value2.charCodeAt(i) & 255;
-      return bytes;
-    }
-    if (offset === "utf16le") {
-      const bytes = new Uint8Array(value2.length * 2);
-      for (let i = 0; i < value2.length; i++) {
-        const unit = value2.charCodeAt(i);
-        bytes[i * 2] = unit & 255;
-        bytes[i * 2 + 1] = unit >>> 8;
-      }
-      return bytes;
-    }
-    return encoder.encode(value2);
-  }
-  if (Array.isArray(value2)) return Uint8Array.from(value2);
-  if (value2 instanceof Uint8Array) return new Uint8Array(value2);
-  return new Uint8Array(value2, typeof offset === "number" ? offset : void 0, length);
-}
-function concatBytes(parts, size = parts.reduce((sum, part) => sum + part.length, 0)) {
-  const out = new Uint8Array(size);
-  let offset = 0;
-  for (const part of parts) {
-    const length = Math.min(part.length, size - offset);
-    out.set(part.subarray(0, length), offset);
-    offset += length;
-    if (offset === size) break;
-  }
-  return out;
-}
-function compareBytes(left, right) {
-  for (let i = 0; i < Math.min(left.length, right.length); i++) if (left[i] !== right[i]) return left[i] < right[i] ? -1 : 1;
-  return left.length === right.length ? 0 : left.length < right.length ? -1 : 1;
-}
-function filledBytes(size, value2 = 0) {
-  return new Uint8Array(size).fill(value2);
-}
-function latin1Text(bytes) {
-  let result = "";
-  for (const byte of bytes) result += String.fromCharCode(byte);
-  return result;
-}
-function equalBytes(left, right) {
-  if (left.length !== right.length) return false;
-  for (let i = 0; i < left.length; i++) if (left[i] !== right[i]) return false;
-  return true;
-}
-function base64Text(bytes) {
-  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-  let out = "";
-  for (let i = 0; i < bytes.length; i += 3) {
-    const a = bytes[i], b = bytes[i + 1] ?? 0, c = bytes[i + 2] ?? 0;
-    out += alphabet[a >>> 2] + alphabet[(a & 3) << 4 | b >>> 4] + (i + 1 < bytes.length ? alphabet[(b & 15) << 2 | c >>> 6] : "=") + (i + 2 < bytes.length ? alphabet[c & 63] : "=");
-  }
-  return out;
-}
-
-// packages/safe-bash-calendar-engine/src/time-env/shared.ts
-import { writeDiagnostic } from "../../safe-bash-contracts/escaping.js";
-import { FsError as FsError2, writeBytes as writeBytes2 } from "../../safe-bash-contracts/index.js";
-var defaultSleepScheduler = {
-  now: () => performance.now(),
-  setTimeout: (callback, milliseconds) => setTimeout(callback, milliseconds),
-  clearTimeout: (handle) => clearTimeout(handle)
-};
-function settings(options2) {
-  const limits = {
-    maxArguments: Infinity,
-    maxArgumentBytes: Infinity,
-    maxOutputBytes: Infinity,
-    maxEnvironmentEntries: Infinity,
-    maxFormatWidth: Infinity,
-    ...options2.limits
-  };
-  for (const [name, value2] of Object.entries(limits)) {
-    if (value2 !== Infinity && (!Number.isSafeInteger(value2) || value2 < 1)) throw new RangeError(`Invalid time-env limit: ${name}`);
-  }
-  const maxTimerMilliseconds = options2.maxTimerMilliseconds ?? 2147483647;
-  if (maxTimerMilliseconds !== Infinity && (!Number.isInteger(maxTimerMilliseconds) || maxTimerMilliseconds < 1 || maxTimerMilliseconds > 2147483647)) {
-    throw new RangeError("maxTimerMilliseconds must be between 1 and 2147483647 or Infinity");
-  }
-  const scheduler = options2.scheduler ?? defaultSleepScheduler;
-  if (typeof scheduler.now !== "function" || typeof scheduler.setTimeout !== "function" || typeof scheduler.clearTimeout !== "function") {
-    throw new TypeError("Invalid sleep scheduler");
-  }
-  if (options2.clock !== void 0 && typeof options2.clock !== "function") throw new TypeError("Invalid date clock");
-  return {
-    clock: options2.clock ?? Date.now,
-    defaultTimeZone: options2.defaultTimeZone ?? "UTC",
-    scheduler,
-    maxTimerMilliseconds,
-    limits
-  };
-}
-var CommandFailure = class extends Error {
-  constructor(message, exitCode = 1) {
-    super(message);
-    this.exitCode = exitCode;
-  }
-  exitCode;
-};
-function checkSize(size, maximum, label) {
-  if (size > maximum) throw new FsError2("EFBIG", { message: `time-env ${label} limit exceeded` });
-}
-async function emit(context, value2, limits) {
-  checkSize(utf8ByteLength(value2), limits.maxOutputBytes, "output");
-  const bytes = new TextEncoder().encode(value2);
-  for (let offset = 0; offset < bytes.length; offset += 16384) {
-    await writeBytes2(context.stdout, bytes.slice(offset, offset + 16384), context.signal);
-  }
-}
-var timeEnvExecutorSettings = /* @__PURE__ */ new WeakMap();
-function command(name, configuration, execute) {
-  const def = { name, async execute(context) {
-    context.signal.throwIfAborted();
-    checkSize(context.args.length, configuration.limits.maxArguments, "argument count");
-    let size = 0;
-    for (const argument of context.args) {
-      size += utf8ByteLength(argument);
-      checkSize(size, configuration.limits.maxArgumentBytes, "argument");
-    }
-    try {
-      return { exitCode: await execute(context) };
-    } catch (error) {
-      context.signal.throwIfAborted();
-      if (!(error instanceof CommandFailure)) throw error;
-      await writeDiagnostic(context.stderr, `${name}: ${error.message}
-`, context.signal);
-      return { exitCode: error.exitCode };
-    }
-  } };
-  timeEnvExecutorSettings.set(def.execute, configuration);
-  return def;
-}
-function ownEnvironment(context, name) {
-  return Object.hasOwn(context.env, name) ? context.env[name] : void 0;
-}
-
-// packages/safe-bash-calendar-engine/src/time-env/calendar.ts
-var nanosecondsPerSecond = 1000000000n;
-var maximumNanoseconds = 8640000000000000000000n;
-var monthNames = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
-var weekdayNames = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
-function floorDivide(value2, divisor) {
-  const quotient = value2 / divisor;
-  return value2 < 0n && value2 % divisor !== 0n ? quotient - 1n : quotient;
-}
-function boundedInstant(value2) {
-  if (value2 < -maximumNanoseconds || value2 > maximumNanoseconds) throw new CommandFailure("date is outside the supported range");
-  return value2;
-}
-function millisecondsInstant(value2) {
-  if (!Number.isFinite(value2) || Math.abs(value2) > 864e13) throw new CommandFailure("invalid clock or modification time");
-  const match = /^(-?)(\d+)(?:\.(\d+))?(?:e([+-]?\d+))?$/.exec(value2.toString());
-  const fraction = match[3] ?? "";
-  const coefficient = BigInt(`${match[2]}${fraction}`) * (match[1] ? -1n : 1n);
-  const scale = Number(match[4] ?? 0) - fraction.length + 6;
-  return boundedInstant(scale >= 0 ? coefficient * 10n ** BigInt(scale) : floorDivide(coefficient, 10n ** BigInt(-scale)));
-}
-function utcMilliseconds(fields) {
-  const date = /* @__PURE__ */ new Date(0);
-  date.setUTCFullYear(fields.year, fields.month - 1, fields.day);
-  date.setUTCHours(fields.hour, fields.minute, fields.second, 0);
-  const value2 = date.getTime();
-  if (!Number.isFinite(value2)) throw new CommandFailure("date is outside the supported range");
-  return value2;
-}
-function utcFields(milliseconds) {
-  const date = new Date(milliseconds);
-  return {
-    year: date.getUTCFullYear(),
-    month: date.getUTCMonth() + 1,
-    day: date.getUTCDate(),
-    hour: date.getUTCHours(),
-    minute: date.getUTCMinutes(),
-    second: date.getUTCSeconds()
-  };
-}
-function sameFields(left, right) {
-  return left.year === right.year && left.month === right.month && left.day === right.day && left.hour === right.hour && left.minute === right.minute && left.second === right.second;
-}
-function checkCalendar(fields, restrictYear = true) {
-  if (restrictYear && (fields.year < -9999 || fields.year > 9999) || fields.month < 1 || fields.month > 12 || fields.day < 1 || fields.day > 31 || fields.hour < 0 || fields.hour > 23 || fields.minute < 0 || fields.minute > 59 || fields.second < 0 || fields.second > 59 || !sameFields(fields, utcFields(utcMilliseconds(fields)))) throw new CommandFailure("invalid calendar date or time");
-}
-function signedOffset(text) {
-  const match = /^([+-])(\d{2})(?::?(\d{2}))?(?::(\d{2}))?$/.exec(text);
-  if (!match) throw new CommandFailure(`unsupported UTC offset: ${text}`);
-  const hours = Number(match[2]), minutes = Number(match[3] ?? 0), seconds = Number(match[4] ?? 0);
-  if (hours > 23 || minutes > 59 || seconds > 59) throw new CommandFailure(`invalid UTC offset: ${text}`);
-  return (match[1] === "-" ? -1 : 1) * (hours * 3600 + minutes * 60 + seconds);
-}
-var TimeZone = class {
-  fixedOffset;
-  formatter;
-  label;
-  constructor(input2, numericOffset = false) {
-    const name = input2.startsWith(":") ? input2.slice(1) : input2;
-    this.label = name.startsWith("GMT") || name === "Etc/GMT" ? "GMT" : "UTC";
-    if (numericOffset) this.fixedOffset = signedOffset(name);
-    else if (["", "UTC", "UTC0", "GMT", "GMT0", "Etc/UTC", "Etc/GMT", "Z"].includes(name)) this.fixedOffset = 0;
-    else {
-      const fixed = /^(UTC|GMT)([+-])(\d{1,2})(?::(\d{2}))?(?::(\d{2}))?$/.exec(name);
-      if (fixed) this.fixedOffset = -signedOffset(`${fixed[2]}${fixed[3].padStart(2, "0")}:${fixed[4] ?? "00"}:${fixed[5] ?? "00"}`);
-      else {
-        if (!/^[A-Za-z_+-][A-Za-z0-9_+.-]*(?:\/[A-Za-z0-9_+.-]+)*$/.test(name)) throw new CommandFailure(`unsupported virtual TZ: ${input2}`);
-        try {
-          this.formatter = new Intl.DateTimeFormat("en-US-u-ca-gregory-nu-latn", {
-            timeZone: name,
-            year: "numeric",
-            month: "2-digit",
-            day: "2-digit",
-            hour: "2-digit",
-            minute: "2-digit",
-            second: "2-digit",
-            era: "short",
-            hourCycle: "h23",
-            timeZoneName: "short"
-          });
-        } catch {
-          throw new CommandFailure(`unsupported virtual TZ: ${input2}`);
-        }
-      }
-    }
-  }
-  fields(instant) {
-    return this.observedFields(instant, true);
-  }
-  observedFields(instant, restrictYear) {
-    boundedInstant(instant);
-    const seconds = floorDivide(instant, nanosecondsPerSecond);
-    const milliseconds = Number(seconds * 1000n);
-    let fields, offset, zone;
-    if (this.fixedOffset !== void 0) {
-      fields = utcFields(milliseconds + this.fixedOffset * 1e3);
-      offset = this.fixedOffset;
-      zone = this.label;
-    } else {
-      const parts = Object.fromEntries(this.formatter.formatToParts(new Date(milliseconds)).map((part) => [part.type, part.value]));
-      const year = Number(parts.year);
-      fields = {
-        year: parts.era === "BC" ? 1 - year : year,
-        month: Number(parts.month),
-        day: Number(parts.day),
-        hour: Number(parts.hour),
-        minute: Number(parts.minute),
-        second: Number(parts.second)
-      };
-      offset = (utcMilliseconds(fields) - milliseconds) / 1e3;
-      zone = parts.timeZoneName;
-    }
-    checkCalendar(fields, restrictYear);
-    return { ...fields, offset, zone };
-  }
-  instant(fields, fraction = 0n) {
-    checkCalendar(fields);
-    const wall = utcMilliseconds(fields);
-    if (this.fixedOffset !== void 0) return boundedInstant(BigInt(wall) * 1000000n - BigInt(this.fixedOffset) * nanosecondsPerSecond + fraction);
-    const offsets = /* @__PURE__ */ new Set();
-    for (const days of [-2, -1, 0, 1, 2]) offsets.add(this.observedFields(BigInt(wall + days * 864e5) * 1000000n, false).offset);
-    const candidates = [];
-    for (const offset of offsets) {
-      const candidate = BigInt(wall) * 1000000n - BigInt(offset) * nanosecondsPerSecond + fraction;
-      if (sameFields(this.observedFields(candidate, false), fields)) candidates.push(candidate);
-    }
-    if (candidates.length === 0) throw new CommandFailure("nonexistent local time in virtual TZ");
-    if (candidates.length !== 1) throw new CommandFailure("ambiguous local time; specify an explicit UTC offset");
-    return boundedInstant(candidates[0]);
-  }
-};
-function decimalEpoch(text) {
-  const match = /^@([+-]?)(\d+)(?:[.,](\d+))?$/.exec(text);
-  if (!match) return void 0;
-  if (match[2].replace(/^0+/, "").length > 13) throw new CommandFailure("date is outside the supported range");
-  const magnitude = BigInt(match[2]) * nanosecondsPerSecond + BigInt((match[3] ?? "").slice(0, 9).padEnd(9, "0"));
-  return boundedInstant(match[1] === "-" ? -magnitude : magnitude);
-}
-function parsedZone(text, fallback) {
-  if (text === void 0) return fallback;
-  return /^[+-]/.test(text) ? new TimeZone(text, true) : new TimeZone(text.toUpperCase());
-}
-function parseDate(text, zone, now) {
-  const value2 = text.trim();
-  if (value2 === "") {
-    const fields = zone.fields(now());
-    return zone.instant({ ...fields, hour: 0, minute: 0, second: 0 }, 0n);
-  }
-  const epoch = decimalEpoch(value2);
-  if (epoch !== void 0) return epoch;
-  if (value2 === "now") return now();
-  if (["today", "yesterday", "tomorrow"].includes(value2)) {
-    const current = now();
-    if (value2 === "today") return current;
-    const fields = zone.fields(current);
-    const changed = utcFields(utcMilliseconds(fields) + (value2 === "yesterday" ? -864e5 : 864e5));
-    return zone.instant(changed, current - floorDivide(current, nanosecondsPerSecond) * nanosecondsPerSecond);
-  }
-  const relative = /^(?:(.*?)\s+)?([+-]?\s*\d+)\s+(seconds?|minutes?|hours?|days?|weeks?|months?|years?)(?:\s+(ago))?$/.exec(value2);
-  if (relative) {
-    const rawAmount = relative[2].replace(/\s+/g, "");
-    if (rawAmount.replace(/^[+-]?0*/, "").length > 13) throw new CommandFailure("relative date is outside the supported range");
-    const base = relative[1] === void 0 || relative[1] === "now" ? { instant: now(), zone } : parseAbsoluteDate(relative[1], zone);
-    const amount = BigInt(rawAmount) * (relative[4] ? -1n : 1n);
-    const unit = relative[3];
-    if (["second", "minute", "hour"].some((name) => unit.startsWith(name))) {
-      const scale = unit.startsWith("hour") ? 3600n : unit.startsWith("minute") ? 60n : 1n;
-      return boundedInstant(base.instant + amount * scale * nanosecondsPerSecond);
-    }
-    const fields = base.zone.fields(base.instant);
-    const changed = unit.startsWith("year") ? { ...fields, year: fields.year + Number(amount) } : unit.startsWith("month") ? { ...fields, month: fields.month + Number(amount) } : { ...fields, day: fields.day + Number(amount) * (unit.startsWith("week") ? 7 : 1) };
-    const normalized = utcFields(utcMilliseconds(changed));
-    return base.zone.instant(normalized, base.instant - floorDivide(base.instant, nanosecondsPerSecond) * nanosecondsPerSecond);
-  }
-  return parseAbsoluteDate(value2, zone).instant;
-}
-function parseAbsoluteDate(value2, zone) {
-  const epoch = decimalEpoch(value2);
-  if (epoch !== void 0) return { instant: epoch, zone };
-  const iso = /^(?:(\d{4})-(\d{1,2})-(\d{1,2})|(\d{4})(\d{2})(\d{2}))(?:[Tt ](\d{2}):(\d{2})(?::(\d{2})(?:[.,](\d+))?)?)?(?:\s*(Z|UTC|GMT|[+-]\d{2}(?::?\d{2})?(?::\d{2})?))?$/i.exec(value2);
-  if (iso) {
-    const fields = {
-      year: Number(iso[1] ?? iso[4]),
-      month: Number(iso[2] ?? iso[5]),
-      day: Number(iso[3] ?? iso[6]),
-      hour: Number(iso[7] ?? 0),
-      minute: Number(iso[8] ?? 0),
-      second: Number(iso[9] ?? 0)
-    };
-    const sourceZone = parsedZone(iso[11], zone);
-    return { instant: sourceZone.instant(fields, BigInt((iso[10] ?? "").slice(0, 9).padEnd(9, "0"))), zone: sourceZone };
-  }
-  const rfc = /^(?:(Sun|Mon|Tue|Wed|Thu|Fri|Sat),\s+)?(\d{1,2})\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+(\d{4})\s+(\d{2}):(\d{2}):(\d{2})\s+(GMT|UTC|[+-]\d{4})$/.exec(value2);
-  if (rfc) {
-    const fields = {
-      year: Number(rfc[4]),
-      month: monthNames.findIndex((name) => name.startsWith(rfc[3])) + 1,
-      day: Number(rfc[2]),
-      hour: Number(rfc[5]),
-      minute: Number(rfc[6]),
-      second: Number(rfc[7])
-    };
-    if (rfc[1] && !weekdayNames[new Date(utcMilliseconds(fields)).getUTCDay()].startsWith(rfc[1])) throw new CommandFailure("weekday does not match calendar date");
-    const sourceZone = parsedZone(rfc[8], zone);
-    return { instant: sourceZone.instant(fields), zone: sourceZone };
-  }
-  throw new CommandFailure(`unsupported or invalid date: ${value2}`);
-}
-
-// packages/safe-bash-io-engine/src/commands/touch-times.ts
-function touchTimes(date, timestamp, timezone, base) {
-  try {
-    const zone = new TimeZone(timezone);
-    if (timestamp !== void 0) {
-      const parts = timestamp.split(".");
-      const digits = parts[0];
-      if (parts.length > 2 || ![8, 10, 12].includes(digits.length) || [...digits].some((character) => character < "0" || character > "9") || parts[1] !== void 0 && (parts[1].length !== 2 || [...parts[1]].some((character) => character < "0" || character > "9"))) {
-        throw new CommandFailure(`invalid date format '${timestamp}'`);
-      }
-      const prefix = digits.slice(0, -8);
-      const year = prefix.length === 4 ? Number(prefix) : prefix.length === 2 ? Number(prefix) + (Number(prefix) >= 69 ? 1900 : 2e3) : zone.fields(millisecondsInstant(base.mtimeMs)).year;
-      const fields = digits.slice(-8);
-      const second = Number(parts[1] ?? 0);
-      const instant = zone.instant({
-        year,
-        month: Number(fields.slice(0, 2)),
-        day: Number(fields.slice(2, 4)),
-        hour: Number(fields.slice(4, 6)),
-        minute: Number(fields.slice(6, 8)),
-        second: second === 60 ? 59 : second
-      });
-      const milliseconds = Number(instant / 1000000n) + (second === 60 ? 1e3 : 0);
-      return { atimeMs: milliseconds, mtimeMs: milliseconds };
-    }
-    if (date === void 0) return base;
-    const access = parseDate(date, zone, () => millisecondsInstant(base.atimeMs));
-    const modify = parseDate(date, zone, () => millisecondsInstant(base.mtimeMs));
-    return {
-      atimeMs: Number(access / 1000000n) + Number(access % 1000000n) / 1e6,
-      mtimeMs: Number(modify / 1000000n) + Number(modify % 1000000n) / 1e6
-    };
-  } catch (error) {
-    if (error instanceof CommandFailure) throw new PublicDiagnostic(error.message);
-    throw error;
-  }
-}
-
-// packages/safe-bash-io-engine/src/internal.ts
-var syncResolved = /* @__PURE__ */ Symbol.for("safe-bash.syncResolved");
-var sharedSmallOutputBuf = new Uint8Array(64);
-var sharedSmallOutputViews = Array.from({ length: 65 }, (_, i) => sharedSmallOutputBuf.subarray(0, i));
-var resolvedVoid = Object.defineProperty(
-  Promise.resolve(),
-  syncResolved,
-  { value: true }
-);
-var RESOLVED_EXIT_ZERO = Object.defineProperty(
-  Promise.resolve({ exitCode: 0 }),
-  syncResolved,
-  { value: true }
-);
-var RESOLVED_EXIT_ONE = Object.defineProperty(
-  Promise.resolve({ exitCode: 1 }),
-  syncResolved,
-  { value: true }
-);
-async function handleDefineError(context, error, failureCode, usageFailureCode) {
-  context.signal.throwIfAborted();
-  await diagnostic(context, error);
-  return { exitCode: error instanceof UsageError ? usageFailureCode : failureCode };
-}
-var encoder2 = new TextEncoder();
-var decoder = new TextDecoder();
-var bufferLimit = Infinity;
-var syncCommandEvaluators = {};
-var specificationsCache = /* @__PURE__ */ new Map();
-function options(args, short, long = {}, stopAtOperand = false, onOperand, onValue, onOption) {
-  const flags = /* @__PURE__ */ new Set();
-  const values = /* @__PURE__ */ new Map();
-  const operands = [];
-  let specifications = specificationsCache.get(short);
-  if (!specifications) {
-    const built = /* @__PURE__ */ new Map();
-    for (let index = 0; index < short.length; index++) {
-      const key = short[index];
-      built.set(key, short[index + 1] === ":");
-      if (short[index + 1] === ":") index++;
-    }
-    specifications = built;
-    specificationsCache.set(short, specifications);
-  }
-  let ended = false;
-  for (let index = 0; index < args.length; index++) {
-    const argument = args[index];
-    if (ended || argument === "-" || !argument.startsWith("-")) {
-      operands.push(argument);
-      onOperand?.(index);
-      if (stopAtOperand) ended = true;
-      continue;
-    }
-    if (argument === "--") {
-      ended = true;
-      continue;
-    }
-    if (argument.startsWith("--")) {
-      const equals = argument.indexOf("=");
-      const name = argument.slice(2, equals < 0 ? void 0 : equals);
-      const alias = long[name];
-      const longValue = typeof alias === "string" && alias.endsWith(":");
-      const key = alias === false ? name : longValue ? alias.slice(0, -1) : alias;
-      if (!key || alias !== false && !longValue && !specifications.has(key)) throw new UsageError(`unrecognized option '${argument}'`);
-      if (longValue || specifications.get(key)) {
-        const value2 = equals >= 0 ? argument.slice(equals + 1) : args[++index];
-        if (value2 === void 0) throw new UsageError(`option '--${name}' requires an argument`);
-        onValue?.(key, index, equals >= 0 ? equals + 1 : 0);
-        const list = values.get(key);
-        if (list) list.push(value2);
-        else values.set(key, [value2]);
-      } else if (equals >= 0) throw new UsageError(`option '--${name}' does not take an argument`);
-      flags.add(key);
-      onOption?.(key, values.get(key)?.at(-1));
-      continue;
-    }
-    for (let offset = 1; offset < argument.length; offset++) {
-      const key = argument[offset];
-      if (!specifications.has(key)) throw new UsageError(`invalid option -- '${key}'`);
-      if (specifications.get(key)) {
-        const value2 = argument.slice(offset + 1) || args[++index];
-        if (value2 === void 0) throw new UsageError(`option requires an argument -- '${key}'`);
-        onValue?.(key, index, offset + 1 < argument.length ? offset + 1 : 0);
-        const list = values.get(key);
-        if (list) list.push(value2);
-        else values.set(key, [value2]);
-        offset = argument.length;
-      }
-      flags.add(key);
-      onOption?.(key, values.get(key)?.at(-1));
-    }
-  }
-  return { flags, values, operands };
-}
-function value(parsed, key) {
-  return parsed.values.get(key)?.at(-1);
-}
-function integer(text, minimum = 0) {
-  if (!/^[+]?[0-9]+$/u.test(text)) throw new UsageError(`invalid number '${text}'`);
-  const number = Number(text);
-  if (!Number.isSafeInteger(number) || number < minimum) throw new UsageError(`invalid number '${text}'`);
-  return number;
-}
-function requireOperands(operands, minimum = 1, maximum = Infinity) {
-  if (operands.length < minimum) throw new UsageError("missing operand");
-  if (operands.length > maximum) throw new UsageError(`extra operand '${operands[maximum]}'`);
-}
-function codeOf(error) {
-  return error instanceof Error && "code" in error ? String(error.code) : void 0;
-}
-var EXIT_ZERO_RESULT = { exitCode: 0 };
-var EXIT_ONE_RESULT = { exitCode: 1 };
-var EXIT_TWO_RESULT = { exitCode: 2 };
-var RETURN_EXIT_ZERO = () => EXIT_ZERO_RESULT;
-var RETURN_EXIT_ONE = () => EXIT_ONE_RESULT;
-var RETURN_EXIT_TWO = () => EXIT_TWO_RESULT;
-function outputRange(context, src, len) {
-  context.signal.throwIfAborted();
-  const stdout = context.stdout;
-  if (!stdout.isPipeStage) {
-    if (typeof stdout.writeRangeSync === "function" && stdout.writeRangeSync(src, len) !== false) {
-      return resolvedVoid;
-    }
-    if (typeof stdout.writeSync === "function" && stdout.writeSync(src.subarray(0, len)) !== false) {
-      return resolvedVoid;
-    }
-  }
-  return writeBytes3(context.stdout, stdout.isPipeStage ? src.subarray(0, len) : src.slice(0, len), context.signal);
-}
-function output(context, text) {
-  context.signal.throwIfAborted();
-  const stdout = context.stdout;
-  if (typeof text === "string" && !stdout.isPipeStage) {
-    const len = text.length;
-    if (len <= 64 && (typeof stdout.writeRangeSync === "function" || typeof stdout.writeSync === "function")) {
-      let ascii = true;
-      for (let i = 0; i < len; i++) {
-        const code = text.charCodeAt(i);
-        if (code >= 128) {
-          ascii = false;
-          break;
-        }
-        sharedSmallOutputBuf[i] = code;
-      }
-      if (ascii) {
-        const ok = typeof stdout.writeRangeSync === "function" ? stdout.writeRangeSync(sharedSmallOutputBuf, len) : stdout.writeSync(sharedSmallOutputViews[len]);
-        if (ok !== false) return resolvedVoid;
-      }
-    }
-  }
-  const bytes = typeof text === "string" ? encoder2.encode(text) : text;
-  if (!stdout.isPipeStage && typeof stdout.writeSync === "function" && stdout.writeSync(bytes) !== false) {
-    return resolvedVoid;
-  }
-  return writeBytes3(context.stdout, bytes, context.signal);
-}
-async function diagnostic(context, error) {
-  context.signal.throwIfAborted();
-  await writeDiagnostic2(context.stderr, `${context.command}: ${publicDiagnosticMessage(error, context.onInternalError)}
-`, context.signal);
-}
-function finishDefineInfoAsync(infoPromise, handler, context, failureCode, usageFailureCode) {
-  return infoPromise.then(
-    (info) => info ?? handler(context)
-  ).catch((error) => handleDefineError(context, error, failureCode, usageFailureCode));
-}
-function finishDefineResAsync(res, context, failureCode, usageFailureCode) {
-  return Promise.resolve(res).catch((error) => handleDefineError(context, error, failureCode, usageFailureCode));
-}
-function define(name, handler, failureCode = 1, usageFailureCode = 2) {
-  const definition = {
-    name,
-    execute(context) {
-      try {
-        context.signal.throwIfAborted();
-        const infoPromise = gnuInformation(name, context);
-        if (infoPromise) {
-          return finishDefineInfoAsync(infoPromise, handler, context, failureCode, usageFailureCode);
-        }
-        const res = handler(context);
-        if (res === RESOLVED_EXIT_ZERO || res === RESOLVED_EXIT_ONE || Boolean(res && typeof res === "object" && res[syncResolved])) {
-          return res;
-        }
-        return finishDefineResAsync(res, context, failureCode, usageFailureCode);
-      } catch (error) {
-        return handleDefineError(context, error, failureCode, usageFailureCode);
-      }
-    }
-  };
-  builtInDirectContextExecutors.add(definition.execute);
-  return definition;
-}
-async function eachOperand(context, operands, operation) {
-  let exitCode = 0;
-  for (const operand of operands) {
-    context.signal.throwIfAborted();
-    try {
-      await operation(operand);
-    } catch (error) {
-      await diagnostic(context, error);
-      exitCode = 1;
-    }
-  }
-  return { exitCode };
-}
-function input(context, name = "-") {
-  if (name === "-") {
-    if (!context.signal.aborted && context.stdin.abortSignal === context.signal) {
-      return context.stdin;
-    }
-    return readBytes(context.stdin, context.signal);
-  }
-  const backing = getRuntimeBackingFileSystem(context.fs);
-  if (!context.signal.aborted && backing !== void 0 && backing.capabilitiesFor === void 0 && context.fs.readStream && context.fs.capabilities.streamingRead !== false && context.fs.capabilities.read !== false && Object.getPrototypeOf(backing)?.constructor?.name === "MemoryFileSystem" && !Object.prototype.hasOwnProperty.call(backing, "readStream")) {
-    const resolvedPath = (0, path_exports.pathOf)(context, name);
-    if (resolvedPath !== "/dev" && !resolvedPath.startsWith("/dev/")) {
-      return context.fs.readStream(resolvedPath, { signal: context.signal });
-    }
-  }
-  return inputFileSlow(context, name);
-}
-function inputFileSlow(context, name) {
-  return readBytes({ [Symbol.asyncIterator]() {
-    context.signal.throwIfAborted();
-    const resolvedPath = (0, path_exports.pathOf)(context, name);
-    const backing = getRuntimeBackingFileSystem(context.fs);
-    const skipCapsFor = !context.fs.capabilitiesFor || backing?.capabilitiesFor === void 0 && resolvedPath !== "/dev" && !resolvedPath.startsWith("/dev/");
-    if (skipCapsFor && context.fs.readStream && context.fs.capabilities.streamingRead !== false) {
-      assertCommandRequirements(context, inputRequirements, FILE_REQUIREMENT_MODES);
-      if (backing !== void 0 && backing.capabilitiesFor === void 0 && Object.getPrototypeOf(backing)?.constructor?.name === "MemoryFileSystem" && !Object.prototype.hasOwnProperty.call(backing, "readStream")) {
-        return context.fs.readStream(resolvedPath, { signal: context.signal })[Symbol.asyncIterator]();
-      }
-      let iterator;
-      let closing;
-      let finished = false;
-      let readFailure;
-      const close = () => closing ??= Promise.resolve().then(async () => {
-        if (!finished) {
-          finished = true;
-          try {
-            await iterator?.return?.();
-          } catch (error) {
-            if (context.signal.aborted && Object.is(error, context.signal.reason)) return;
-            if (!readFailure || !Object.is(error, readFailure.reason)) throw error;
-          }
-        }
-      });
-      context.registerCleanup?.(close);
-      try {
-        context.signal.throwIfAborted();
-        iterator = context.fs.readStream(resolvedPath, { signal: context.signal })[Symbol.asyncIterator]();
-        if (context.signal.aborted) {
-          void close().catch(() => {
-          });
-          context.signal.throwIfAborted();
-        }
-      } catch (error) {
-        return fileInputSource(context, name, { [Symbol.asyncIterator]: () => ({ async next() {
-          throw error;
-        } }) });
-      }
-      const source = { [Symbol.asyncIterator]: () => ({
-        tryNextSync() {
-          if (finished || closing) return { done: true, value: void 0 };
-          try {
-            const result = iterator.tryNextSync?.();
-            if (result?.done) finished = true;
-            return result;
-          } catch (reason) {
-            readFailure = { reason };
-            throw reason;
-          }
-        },
-        async next() {
-          if (finished || closing) return { done: true, value: void 0 };
-          try {
-            const result = await iterator.next();
-            if (result.done) finished = true;
-            return result;
-          } catch (reason) {
-            readFailure = { reason };
-            throw reason;
-          }
-        },
-        async return() {
-          await close();
-          return { done: true, value: void 0 };
-        }
-      }) };
-      const reader = readBytes(source, context.signal);
-      let fallback;
-      let emitted = false;
-      return {
-        abortSignal: context.signal,
-        tryNextSync() {
-          if (fallback) return void 0;
-          const result = reader.tryNextSync();
-          if (result && !result.done && result.value.byteLength) emitted = true;
-          return result;
-        },
-        async next() {
-          if (fallback) return fallback.next();
-          try {
-            const result = await reader.next();
-            if (!result.done && result.value.byteLength) emitted = true;
-            return result;
-          } catch (error) {
-            context.signal.throwIfAborted();
-            if (emitted || !(error instanceof FsError3) || error.code !== "ENOTSUP") throw error;
-            fallback = fileInputSource(context, name, false);
-            return fallback.next();
-          }
-        },
-        return: (value2) => (fallback ?? reader).return(value2),
-        throw: (error) => (fallback ?? reader).throw(error)
-      };
-    }
-    return fileInputSource(context, name);
-  } }, context.signal);
-}
-async function* fileInputSource(context, name, stream) {
-  context.signal.throwIfAborted();
-  await assertInputRequirements(context, [name]);
-  const path = (0, path_exports.pathOf)(context, name);
-  const capabilities = await context.fs.capabilitiesFor?.(path, { signal: context.signal }) ?? context.fs.capabilities;
-  if (stream !== false && context.fs.readStream && capabilities.streamingRead !== false) {
-    let emitted = false;
-    let reading = true;
-    try {
-      for await (const chunk of readBytes(stream ?? context.fs.readStream(path, { signal: context.signal }), context.signal)) {
-        reading = false;
-        if (chunk.byteLength) emitted = true;
-        yield chunk;
-        reading = true;
-      }
-      return;
-    } catch (error) {
-      context.signal.throwIfAborted();
-      if (!reading || emitted || !(error instanceof FsError3) || error.code !== "ENOTSUP") throw error;
-    }
-  }
-  if (capabilities.read === false) throw new FsError3("ENOTSUP", { syscall: "readFile", path });
-  yield* readBytes({
-    async *[Symbol.asyncIterator]() {
-      const bytes = await context.fs.readFile(path, { signal: context.signal });
-      context.signal.throwIfAborted();
-      if (bytes.byteLength > bufferLimit) throw new FsError3("EFBIG", { syscall: "readFile", path });
-      yield bytes;
-    }
-  }, context.signal);
-}
-var FILE_REQUIREMENT_MODES = ["file"];
-var STDIN_REQUIREMENT_MODES = ["stdin"];
-function assertInputRequirements(context, names) {
-  let hasFile = false;
-  for (let i = 0; i < names.length; i++) {
-    if (names[i] !== "-") {
-      hasFile = true;
-      break;
-    }
-  }
-  assertCommandRequirements(context, inputRequirements, hasFile ? FILE_REQUIREMENT_MODES : STDIN_REQUIREMENT_MODES);
-  if (!hasFile || !context.fs.capabilitiesFor) return;
-  if (getRuntimeBackingFileSystem(context.fs)?.capabilitiesFor === void 0) {
-    let hasDev = false;
-    for (let i = 0; i < names.length; i++) {
-      const name = names[i];
-      if (name === "-") continue;
-      const p = (0, path_exports.pathOf)(context, name);
-      if (p === "/dev" || p.startsWith("/dev/")) {
-        hasDev = true;
-        break;
-      }
-    }
-    if (!hasDev) return;
-  }
-  return assertInputRequirementsAsync(context, names);
-}
-async function assertInputRequirementsAsync(context, names) {
-  if (!context.fs.capabilitiesFor) return;
-  for (const name of names) {
-    if (name === "-") continue;
-    try {
-      const capabilities = await context.fs.capabilitiesFor((0, path_exports.pathOf)(context, name), { signal: context.signal });
-      assertCommandRequirements(context, inputRequirements, ["file"], capabilities);
-    } catch (error) {
-      context.signal.throwIfAborted();
-      if (codeOf(error) === "ENOTSUP" || codeOf(error) === "EROFS") throw error;
-    }
-  }
-}
-function concatenate(chunks, size = chunks.reduce((sum, chunk) => sum + chunk.length, 0)) {
-  const result = new Uint8Array(size);
-  let offset = 0;
-  for (const chunk of chunks) {
-    result.set(chunk, offset);
-    offset += chunk.length;
-  }
-  return result;
-}
-async function* lines(source, separator = 10, admit) {
-  const pending = new RecordBuffer(bufferLimit);
-  try {
-    for await (const chunk of source) {
-      let start = 0;
-      while (start < chunk.length) {
-        const offset = chunk.indexOf(separator, start);
-        if (offset < 0) break;
-        yield { bytes: pending.finish(admit, chunk, start, offset), terminated: true };
-        start = offset + 1;
-      }
-      pending.append(chunk, start);
-    }
-    if (pending.size) yield { bytes: pending.finish(admit), terminated: false };
-  } finally {
-    pending.clear();
-  }
-}
-function emptyInput() {
-  return toByteSource("");
-}
-function replaceArgument(source, pattern, replacement) {
-  if (typeof source === "string") return source.split(pattern).join(replacement);
-  const needle = encoder2.encode(pattern);
-  if (!needle.length) throw new UsageError("replacement string cannot be empty");
-  const substituted = encoder2.encode(replacement);
-  const chunks = [];
-  let start = 0;
-  for (let offset = 0; offset <= source.length - needle.length; ) {
-    if (needle.every((byte, index) => source[offset + index] === byte)) {
-      chunks.push(source.subarray(start, offset), substituted);
-      offset += needle.length;
-      start = offset;
-    } else offset++;
-  }
-  chunks.push(source.subarray(start));
-  return concatenate(chunks);
-}
-function escapeBytes(text, zeroOctal = false, bareOctal = false, unicode) {
-  if (unicode && typeof text === "string") text = encoder2.encode(text);
-  if (typeof text === "string") {
-    const chunks = [];
-    const control2 = { a: 7, b: 8, e: 27, E: 27, f: 12, n: 10, r: 13, t: 9, v: 11, "\\": 92 };
-    for (let index = 0; index < text.length; ) {
-      if (text[index] !== "\\" || index + 1 === text.length) {
-        const character = String.fromCodePoint(text.codePointAt(index));
-        chunks.push(encoder2.encode(character));
-        index += character.length;
-        continue;
-      }
-      const next = text[index + 1];
-      if (next === "c") return { bytes: concatenate(chunks), stop: true };
-      if (control2[next] !== void 0) {
-        chunks.push(Uint8Array.of(control2[next]));
-        index += 2;
-        continue;
-      }
-      const rest = text.slice(index + 1);
-      const octal = zeroOctal ? (bareOctal ? /^(?:0([0-7]{0,3})|([1-7][0-7]{0,2}))/u : /^0([0-7]{0,3})/u).exec(rest) : /^([0-7]{1,3})/u.exec(rest);
-      if (octal) {
-        chunks.push(Uint8Array.of(parseInt(octal[1] || octal[2] || "0", 8) & 255));
-        index += 1 + octal[0].length;
-        continue;
-      }
-      const hexadecimal = /^x([0-9a-fA-F]{1,2})/u.exec(rest);
-      if (hexadecimal) {
-        chunks.push(Uint8Array.of(parseInt(hexadecimal[1], 16)));
-        index += 1 + hexadecimal[0].length;
-        continue;
-      }
-      chunks.push(encoder2.encode(`\\${next}`));
-      index += 2;
-    }
-    return { bytes: concatenate(chunks), stop: false };
-  }
-  const source = text;
-  const bytes = new Uint8Array(source.length * (unicode && !unicode.utf8 ? 3 : 1));
-  const control = { 97: 7, 98: 8, 101: 27, 69: 27, 102: 12, 110: 10, 114: 13, 116: 9, 118: 11, 92: 92 };
-  let size = 0;
-  for (let index = 0; index < source.length; ) {
-    if (source[index] !== 92 || index + 1 === source.length) {
-      bytes[size++] = source[index++];
-      continue;
-    }
-    const next = source[index + 1];
-    if (next === 99) return { bytes: bytes.subarray(0, size), stop: true };
-    if (control[next] !== void 0) {
-      bytes[size++] = control[next];
-      index += 2;
-      continue;
-    }
-    if (zeroOctal ? next === 48 || bareOctal && next >= 49 && next <= 55 : next >= 48 && next <= 55) {
-      let offset = index + (zeroOctal && next === 48 ? 2 : 1);
-      const end = Math.min(source.length, offset + 3);
-      let value2 = 0;
-      while (offset < end && source[offset] >= 48 && source[offset] <= 55) value2 = value2 * 8 + source[offset++] - 48;
-      bytes[size++] = value2 & 255;
-      index = offset;
-      continue;
-    }
-    if (unicode && (next === 117 || next === 85)) {
-      const digits = next === 117 ? 4 : 8;
-      let offset = index + 2;
-      const end = Math.min(source.length, offset + digits);
-      let value2 = 0;
-      while (offset < end) {
-        const digit = source[offset];
-        const number = digit >= 48 && digit <= 57 ? digit - 48 : digit >= 65 && digit <= 70 ? digit - 55 : digit >= 97 && digit <= 102 ? digit - 87 : -1;
-        if (number < 0) break;
-        value2 = value2 * 16 + number;
-        offset++;
-      }
-      if (offset === index + 2) unicode.missingDigit(String.fromCharCode(next));
-      else {
-        if (value2 < 2147483648) {
-          if (!unicode.utf8 && value2 > 127) {
-            const literal = encoder2.encode(`\\${value2 <= 65535 ? "u" : "U"}${value2.toString(16).toUpperCase().padStart(value2 <= 65535 ? 4 : 8, "0")}`);
-            bytes.set(literal, size);
-            size += literal.length;
-          } else if (value2 < 128) bytes[size++] = value2;
-          else {
-            const length = value2 < 2048 ? 2 : value2 < 65536 ? 3 : value2 < 2097152 ? 4 : value2 < 67108864 ? 5 : 6;
-            for (let position = length - 1; position > 0; position--) {
-              bytes[size + position] = 128 | value2 & 63;
-              value2 = Math.floor(value2 / 64);
-            }
-            bytes[size] = 255 << 8 - length & 255 | value2;
-            size += length;
-          }
-        }
-        index = offset;
-        continue;
-      }
-    }
-    if (next === 120) {
-      let offset = index + 2;
-      const end = Math.min(source.length, offset + 2);
-      let value2 = 0;
-      while (offset < end) {
-        const digit = source[offset];
-        const number = digit >= 48 && digit <= 57 ? digit - 48 : digit >= 65 && digit <= 70 ? digit - 55 : digit >= 97 && digit <= 102 ? digit - 87 : -1;
-        if (number < 0) break;
-        value2 = value2 * 16 + number;
-        offset++;
-      }
-      if (offset > index + 2) {
-        bytes[size++] = value2;
-        index = offset;
-        continue;
-      }
-      unicode?.missingDigit("x");
-    }
-    bytes[size++] = 92;
-    bytes[size++] = next;
-    index += 2;
-  }
-  return { bytes: bytes.subarray(0, size), stop: false };
-}
-function evalSyncTee(inBytes, opArgs, writeFileSync) {
-  const gnuInfo = gnuInformationSync("tee", opArgs);
-  if (gnuInfo !== void 0) return gnuInfo;
-  let append = false;
-  let ended = false;
-  const operands = [];
-  for (let i = 0; i < opArgs.length; i++) {
-    const a = opArgs[i];
-    if (ended || !a.startsWith("-") || a === "-") {
-      if (a === "-") return void 0;
-      operands.push(a);
-      continue;
-    }
-    if (a === "--") {
-      ended = true;
-      continue;
-    }
-    if (a === "-a" || a === "--append") {
-      append = true;
-      continue;
-    }
-    if (a === "-i" || a === "--ignore-interrupts" || a === "-p" || a === "--output-error" || a === "--output-error=warn" || a === "--output-error=warn-nopipe") continue;
-    if (a.startsWith("-") && !a.startsWith("--")) {
-      for (let j = 1; j < a.length; j++) {
-        const ch = a[j];
-        if (ch === "a") append = true;
-        else if (ch === "i" || ch === "p") continue;
-        else return void 0;
-      }
-      continue;
-    }
-    return void 0;
-  }
-  const data = inBytes ?? new Uint8Array(0);
-  if (data.includes(0)) return void 0;
-  for (const op of operands) {
-    if (!writeFileSync || !writeFileSync(op, data, append)) return void 0;
-  }
-  return decoder.decode(data);
-}
-function evalSyncTouch(opArgs, statTypeSync, readFileSync, writeFileSync, utimesNodeSync, tz = "UTC") {
-  const gnuInfo = gnuInformationSync("touch", opArgs);
-  if (gnuInfo !== void 0) return gnuInfo;
-  let noCreate = false;
-  let flagA = false;
-  let flagM = false;
-  let dateStr;
-  let stampStr;
-  let refPath;
-  let ended = false;
-  const operands = [];
-  for (let i = 0; i < opArgs.length; i++) {
-    const a = opArgs[i];
-    if (ended || !a.startsWith("-") || a === "-") {
-      if (a === "-") return void 0;
-      operands.push(a);
-      continue;
-    }
-    if (a === "--") {
-      ended = true;
-      continue;
-    }
-    if (a === "-c" || a === "--no-create") {
-      noCreate = true;
-      continue;
-    }
-    if (a === "-a") {
-      flagA = true;
-      continue;
-    }
-    if (a === "-m") {
-      flagM = true;
-      continue;
-    }
-    if (a === "-f" || a === "-h" || a === "--no-dereference") continue;
-    if (a === "-d" || a === "--date" || a.startsWith("--date=")) {
-      const val = a.startsWith("--date=") ? a.slice(7) : opArgs[++i];
-      if (val === void 0) return void 0;
-      dateStr = val;
-      continue;
-    }
-    if (a === "-t") {
-      const val = opArgs[++i];
-      if (!val) return void 0;
-      stampStr = val;
-      continue;
-    }
-    if (a === "-r" || a === "--reference" || a.startsWith("--reference=")) {
-      const val = a.startsWith("--reference=") ? a.slice(12) : opArgs[++i];
-      if (!val) return void 0;
-      refPath = val;
-      continue;
-    }
-    if (a === "--time" || a.startsWith("--time=")) {
-      const val = a.startsWith("--time=") ? a.slice(7) : opArgs[++i];
-      if (val === "atime" || val === "access" || val === "use") {
-        flagA = true;
-        continue;
-      }
-      if (val === "mtime" || val === "modify") {
-        flagM = true;
-        continue;
-      }
-      return void 0;
-    }
-    if (a.startsWith("-") && !a.startsWith("--")) {
-      for (let j = 1; j < a.length; j++) {
-        const ch = a[j];
-        if (ch === "c") noCreate = true;
-        else if (ch === "a") flagA = true;
-        else if (ch === "m") flagM = true;
-        else if (ch === "f" || ch === "h") continue;
-        else if (ch === "d" || ch === "t" || ch === "r") {
-          const rest = a.slice(j + 1) || opArgs[++i];
-          if (rest === void 0) return void 0;
-          if (ch === "d") dateStr = rest;
-          else if (ch === "t") stampStr = rest;
-          else refPath = rest;
-          break;
-        } else return void 0;
-      }
-      continue;
-    }
-    return void 0;
-  }
-  if (operands.length === 0 || !statTypeSync || !readFileSync || !writeFileSync) return void 0;
-  if ((stampStr !== void 0 ? 1 : 0) + (refPath !== void 0 ? 1 : 0) > 1) return void 0;
-  if (stampStr !== void 0 && dateStr !== void 0) return void 0;
-  let refTimes;
-  if (refPath !== void 0) {
-    if (!utimesNodeSync || !utimesNodeSync(refPath, (st) => {
-      refTimes = { atimeMs: st.atimeMs, mtimeMs: st.mtimeMs };
-      return {};
-    }) || !refTimes) {
-      return void 0;
-    }
-  }
-  const updateAccess = flagA || !flagM;
-  const updateModify = flagM || !flagA;
-  let parsedTimes;
-  try {
-    if (dateStr !== void 0 || stampStr !== void 0 || refTimes !== void 0) {
-      if (!utimesNodeSync) return void 0;
-      const base = refTimes ?? { atimeMs: Date.now(), mtimeMs: Date.now() };
-      parsedTimes = touchTimes(dateStr, stampStr, tz, base);
-    }
-  } catch {
-    return void 0;
-  }
-  for (const f of operands) {
-    const st = statTypeSync(f);
-    if (st === "missing") {
-      if (noCreate) continue;
-      if (!writeFileSync(f, new Uint8Array(0), false)) return void 0;
-      if (utimesNodeSync && parsedTimes) {
-        if (!utimesNodeSync(f, () => ({
-          ...updateAccess ? { atimeMs: parsedTimes.atimeMs } : {},
-          ...updateModify ? { mtimeMs: parsedTimes.mtimeMs } : {}
-        }))) return void 0;
-      }
-    } else if (st === "file" || st === "directory") {
-      if (utimesNodeSync) {
-        const now = Date.now();
-        const target = parsedTimes ?? { atimeMs: now, mtimeMs: now };
-        if (!utimesNodeSync(f, () => ({
-          ...updateAccess ? { atimeMs: target.atimeMs } : {},
-          ...updateModify ? { mtimeMs: target.mtimeMs } : {}
-        }))) return void 0;
-      } else if (st === "file") {
-        const cur = readFileSync(f);
-        if (!cur || !writeFileSync(f, cur, false)) return void 0;
-      } else {
-        return void 0;
-      }
-    } else {
-      return void 0;
-    }
-  }
-  return "";
-}
-function evalSyncCp(opArgs, statTypeSync, readFileSync, writeFileSync, statModeSync, umask = 18) {
-  const gnuInfo = gnuInformationSync("cp", opArgs);
-  if (gnuInfo !== void 0) return gnuInfo;
-  let verbose = false;
-  let noTargetDir = false;
-  let noClobber = false;
-  let preserve = false;
-  let targetDir;
-  let ended = false;
-  const operands = [];
-  for (let i = 0; i < opArgs.length; i++) {
-    const a = opArgs[i];
-    if (ended || !a.startsWith("-") || a === "-") {
-      operands.push(a);
-      continue;
-    }
-    if (a === "--") {
-      ended = true;
-      continue;
-    }
-    if (a === "-v" || a === "--verbose") {
-      verbose = true;
-      continue;
-    }
-    if (a === "-f" || a === "--force") continue;
-    if (a === "-n" || a === "--no-clobber") {
-      noClobber = true;
-      continue;
-    }
-    if (a === "-p" || a === "--preserve") {
-      preserve = true;
-      continue;
-    }
-    if (a === "-T" || a === "--no-target-directory") {
-      noTargetDir = true;
-      continue;
-    }
-    if (a === "-t" || a === "--target-directory" || a.startsWith("--target-directory=")) {
-      const td = a.startsWith("--target-directory=") ? a.slice(19) : opArgs[++i];
-      if (!td) return void 0;
-      targetDir = td;
-      continue;
-    }
-    if (a.startsWith("-") && !a.startsWith("--")) {
-      for (let j = 1; j < a.length; j++) {
-        const ch = a[j];
-        if (ch === "v") verbose = true;
-        else if (ch === "f") continue;
-        else if (ch === "n") noClobber = true;
-        else if (ch === "p") preserve = true;
-        else if (ch === "T") noTargetDir = true;
-        else if (ch === "t") {
-          const rest = a.slice(j + 1) || opArgs[++i];
-          if (!rest) return void 0;
-          targetDir = rest;
-          break;
-        } else return void 0;
-      }
-      continue;
-    }
-    return void 0;
-  }
-  if (!statTypeSync || !readFileSync || !writeFileSync || noTargetDir && targetDir !== void 0) return void 0;
-  let sources;
-  let destBase;
-  let intoDir = false;
-  if (targetDir !== void 0) {
-    if (operands.length === 0 || statTypeSync(targetDir) !== "directory") return void 0;
-    sources = operands;
-    destBase = targetDir;
-    intoDir = true;
-  } else {
-    if (operands.length < 2) return void 0;
-    destBase = operands[operands.length - 1];
-    sources = operands.slice(0, -1);
-    const dstSt = statTypeSync(destBase);
-    if (dstSt === "directory") {
-      if (noTargetDir) return void 0;
-      intoDir = true;
-    } else if (operands.length > 2) {
-      return void 0;
-    }
-  }
-  let out = "";
-  for (const src of sources) {
-    if (statTypeSync(src) !== "file") return void 0;
-    let dst = destBase;
-    if (intoDir) {
-      const base = src.replace(/\/+$/, "").split("/").pop() || "";
-      if (!base) return void 0;
-      dst = `${destBase.replace(/\/+$/, "")}/${base}`;
-    }
-    if (src === dst) return void 0;
-    const finalSt = statTypeSync(dst);
-    if (finalSt !== "missing" && finalSt !== "file") return void 0;
-    if (finalSt === "file" && noClobber) continue;
-    const srcMode = statModeSync ? statModeSync(src) : void 0;
-    const createMode = preserve ? (srcMode ?? 438) & 511 : (srcMode ?? 438) & 511 & ~umask;
-    const bytes = readFileSync(src);
-    if (!bytes || !writeFileSync(dst, bytes, false, createMode)) return void 0;
-    if (verbose) out += `'${src}' -> '${dst}'
-`;
-  }
-  return out;
-}
-function evalSyncMv(opArgs, statTypeSync, readFileSync, writeFileSync, rmSync, statModeSync) {
-  const gnuInfo = gnuInformationSync("mv", opArgs);
-  if (gnuInfo !== void 0) return gnuInfo;
-  let verbose = false;
-  let noTargetDir = false;
-  let noClobber = false;
-  let targetDir;
-  let ended = false;
-  const operands = [];
-  for (let i = 0; i < opArgs.length; i++) {
-    const a = opArgs[i];
-    if (ended || !a.startsWith("-") || a === "-") {
-      operands.push(a);
-      continue;
-    }
-    if (a === "--") {
-      ended = true;
-      continue;
-    }
-    if (a === "-v" || a === "--verbose") {
-      verbose = true;
-      continue;
-    }
-    if (a === "-f" || a === "--force") continue;
-    if (a === "-n" || a === "--no-clobber") {
-      noClobber = true;
-      continue;
-    }
-    if (a === "-T" || a === "--no-target-directory") {
-      noTargetDir = true;
-      continue;
-    }
-    if (a === "-t" || a === "--target-directory" || a.startsWith("--target-directory=")) {
-      const td = a.startsWith("--target-directory=") ? a.slice(19) : opArgs[++i];
-      if (!td) return void 0;
-      targetDir = td;
-      continue;
-    }
-    if (a.startsWith("-") && !a.startsWith("--")) {
-      for (let j = 1; j < a.length; j++) {
-        const ch = a[j];
-        if (ch === "v") verbose = true;
-        else if (ch === "f") continue;
-        else if (ch === "n") noClobber = true;
-        else if (ch === "T") noTargetDir = true;
-        else if (ch === "t") {
-          const rest = a.slice(j + 1) || opArgs[++i];
-          if (!rest) return void 0;
-          targetDir = rest;
-          break;
-        } else return void 0;
-      }
-      continue;
-    }
-    return void 0;
-  }
-  if (!statTypeSync || !readFileSync || !writeFileSync || !rmSync || noTargetDir && targetDir !== void 0) return void 0;
-  let sources;
-  let destBase;
-  let intoDir = false;
-  if (targetDir !== void 0) {
-    if (operands.length === 0 || statTypeSync(targetDir) !== "directory") return void 0;
-    sources = operands;
-    destBase = targetDir;
-    intoDir = true;
-  } else {
-    if (operands.length < 2) return void 0;
-    destBase = operands[operands.length - 1];
-    sources = operands.slice(0, -1);
-    const dstSt = statTypeSync(destBase);
-    if (dstSt === "directory") {
-      if (noTargetDir) return void 0;
-      intoDir = true;
-    } else if (operands.length > 2) {
-      return void 0;
-    }
-  }
-  let out = "";
-  for (const src of sources) {
-    if (statTypeSync(src) !== "file") return void 0;
-    let dst = destBase;
-    if (intoDir) {
-      const base = src.replace(/\/+$/, "").split("/").pop() || "";
-      if (!base) return void 0;
-      dst = `${destBase.replace(/\/+$/, "")}/${base}`;
-    }
-    if (src === dst) return void 0;
-    const finalSt = statTypeSync(dst);
-    if (finalSt !== "missing" && finalSt !== "file") return void 0;
-    if (finalSt === "file" && noClobber) continue;
-    const srcMode = statModeSync ? statModeSync(src) : void 0;
-    const bytes = readFileSync(src);
-    if (!bytes) return void 0;
-    if (finalSt === "file" && !rmSync(dst)) return void 0;
-    if (!writeFileSync(dst, bytes, false, srcMode) || !rmSync(src)) return void 0;
-    if (verbose) out += `renamed '${src}' -> '${dst}'
-`;
-  }
-  return out;
-}
-function evalSyncRmdir(opArgs, statTypeSync, listDirSync, rmSync) {
-  const gnuInfo = gnuInformationSync("rmdir", opArgs);
-  if (gnuInfo !== void 0) return gnuInfo;
-  let verbose = false;
-  let parents = false;
-  let ignoreNonEmpty = false;
-  let ended = false;
-  const operands = [];
-  for (let i = 0; i < opArgs.length; i++) {
-    const a = opArgs[i];
-    if (ended || !a.startsWith("-") || a === "-") {
-      operands.push(a);
-      continue;
-    }
-    if (a === "--") {
-      ended = true;
-      continue;
-    }
-    if (a === "-v" || a === "--verbose") {
-      verbose = true;
-      continue;
-    }
-    if (a === "-p" || a === "--parents") {
-      parents = true;
-      continue;
-    }
-    if (a === "--ignore-fail-on-non-empty") {
-      ignoreNonEmpty = true;
-      continue;
-    }
-    if (a.startsWith("-") && !a.startsWith("--")) {
-      for (let j = 1; j < a.length; j++) {
-        const ch = a[j];
-        if (ch === "v") verbose = true;
-        else if (ch === "p") parents = true;
-        else return void 0;
-      }
-      continue;
-    }
-    return void 0;
-  }
-  if (operands.length === 0 || !statTypeSync || !listDirSync || !rmSync) return void 0;
-  const plan = [];
-  for (const rawDir of operands) {
-    const chain = [];
-    let cur = rawDir;
-    while (true) {
-      if (cur === "/" || cur === "." || cur === ".." || cur.endsWith("/.") || cur.endsWith("/..")) return void 0;
-      if (statTypeSync(cur) !== "directory") return void 0;
-      const entries = listDirSync(cur);
-      if (!entries) return void 0;
-      const count = "size" in entries ? entries.size : entries.length;
-      const expectedCount = chain.length === 0 ? 0 : 1;
-      if (count !== expectedCount) {
-        if (ignoreNonEmpty) break;
-        return void 0;
-      }
-      chain.push(cur);
-      if (!parents) break;
-      const trimmed = cur.replace(/\/+$/, "");
-      const slash = trimmed.lastIndexOf("/");
-      if (slash <= 0) break;
-      cur = trimmed.slice(0, slash);
-    }
-    plan.push(chain);
-  }
-  let out = "";
-  for (const chain of plan) {
-    for (const cur of chain) {
-      if (!rmSync(cur)) return void 0;
-      if (verbose) out += `rmdir: removing directory, '${cur}'
-`;
-    }
-  }
-  return out;
-}
-function evalSyncSleep(opArgs) {
-  const gnuInfo = gnuInformationSync("sleep", opArgs);
-  if (gnuInfo !== void 0) return gnuInfo;
-  if (opArgs.length === 0) return void 0;
-  let count = 0;
-  for (const a of opArgs) {
-    if (a === "--") continue;
-    if (!/^\+?0+(\.0+)?[smhd]?$/u.test(a)) return void 0;
-    count++;
-  }
-  return count > 0 ? "" : void 0;
-}
-syncCommandEvaluators.evalSyncTee = evalSyncTee;
-syncCommandEvaluators.evalSyncTouch = evalSyncTouch;
-syncCommandEvaluators.evalSyncCp = evalSyncCp;
-syncCommandEvaluators.evalSyncMv = evalSyncMv;
-syncCommandEvaluators.evalSyncRmdir = evalSyncRmdir;
-syncCommandEvaluators.evalSyncSleep = evalSyncSleep;
-function evalSyncMkdir(opArgs, umask, statTypeSync, mkdirSync) {
-  const gnuInfo = gnuInformationSync("mkdir", opArgs);
-  if (gnuInfo !== void 0) return gnuInfo;
-  if (!statTypeSync || !mkdirSync) return void 0;
-  let parents = false;
-  let verbose = false;
-  let modeSpec;
-  let ended = false;
-  const operands = [];
-  for (let i = 0; i < opArgs.length; i++) {
-    const a = opArgs[i];
-    if (ended || !a.startsWith("-") || a === "-") {
-      operands.push(a);
-      continue;
-    }
-    if (a === "--") {
-      ended = true;
-      continue;
-    }
-    if (a === "-p" || a === "--parents") {
-      parents = true;
-      continue;
-    }
-    if (a === "-v" || a === "--verbose") {
-      verbose = true;
-      continue;
-    }
-    if (a === "-m" || a === "--mode") {
-      modeSpec = opArgs[++i];
-      if (modeSpec === void 0) return void 0;
-      continue;
-    }
-    if (a.startsWith("--mode=")) {
-      modeSpec = a.slice(7);
-      continue;
-    }
-    if (a.startsWith("-m") && a.length > 2) {
-      modeSpec = a.slice(2);
-      continue;
-    }
-    if (a.startsWith("-") && !a.startsWith("--")) {
-      for (let j = 1; j < a.length; j++) {
-        const ch = a[j];
-        if (ch === "p") parents = true;
-        else if (ch === "v") verbose = true;
-        else if (ch === "m") {
-          const rest = a.slice(j + 1);
-          modeSpec = rest || opArgs[++i];
-          if (modeSpec === void 0) return void 0;
-          break;
-        } else return void 0;
-      }
-      continue;
-    }
-    return void 0;
-  }
-  if (operands.length === 0) return void 0;
-  let mode = 511 & ~umask;
-  if (modeSpec !== void 0) {
-    if (/^[0-7]{1,4}$/.test(modeSpec)) {
-      mode = Number.parseInt(modeSpec, 8);
-    } else {
-      let cur = mode;
-      for (const clause of modeSpec.split(",")) {
-        const m = /^([ugoa]*)((?:[+=-][rwxXstugo]*)+)$/.exec(clause);
-        if (!m) return void 0;
-        const who = m[1];
-        const all = !who || who.includes("a");
-        const uMask = (all || who.includes("u") ? 2496 : 0) | (all || who.includes("g") ? 1080 : 0) | (all || who.includes("o") ? 519 : 0);
-        for (const opMatch of m[2].matchAll(/([+=-])([rwxXstugo]*)/g)) {
-          const op = opMatch[1];
-          const perms = opMatch[2];
-          let bits = 0;
-          for (const ch of perms) {
-            if (ch === "r") bits |= 292;
-            else if (ch === "w") bits |= 146;
-            else if (ch === "x" || ch === "X") bits |= 73;
-            else if (ch === "s") bits |= 3072;
-            else if (ch === "t") bits |= 512;
-            else return void 0;
-          }
-          const masked = bits & (who ? uMask : 3584 | 511 & ~umask);
-          if (op === "+") cur |= masked;
-          else if (op === "-") cur &= ~masked;
-          else cur = cur & ~uMask | bits & uMask;
-        }
-      }
-      mode = cur & 4095;
-    }
-  }
-  for (const dir of operands) {
-    const st = statTypeSync(dir);
-    if (parents) {
-      if (st !== "missing" && st !== "directory") return void 0;
-    } else {
-      if (st !== "missing") return void 0;
-    }
-  }
-  let out = "";
-  for (const dir of operands) {
-    if (parents && verbose) {
-      const parts = dir.split("/").filter(Boolean);
-      let cur = dir.startsWith("/") ? "" : ".";
-      for (let idx = 0; idx < parts.length; idx++) {
-        const part = parts[idx];
-        cur = cur === "" ? "/" + part : cur === "." ? part : cur + "/" + part;
-        const st2 = statTypeSync(cur);
-        if (st2 === "directory") continue;
-        if (st2 !== "missing") return void 0;
-        const stepMode = idx === parts.length - 1 ? mode : 511 & ~umask;
-        if (!mkdirSync(cur, false, stepMode)) return void 0;
-        out += `mkdir: created directory '${cur}'
-`;
-      }
-      continue;
-    }
-    const st = statTypeSync(dir);
-    if (parents && st === "directory") continue;
-    if (!mkdirSync(dir, parents, mode)) return void 0;
-    if (verbose) out += `mkdir: created directory '${dir}'
-`;
-  }
-  return out;
-}
-function evalSyncRm(opArgs, statTypeSync, listDirSync, rmSync) {
-  const gnuInfo = gnuInformationSync("rm", opArgs);
-  if (gnuInfo !== void 0) return gnuInfo;
-  if (!statTypeSync || !listDirSync || !rmSync) return void 0;
-  let force = false;
-  let recursive = false;
-  let dirFlag = false;
-  let verbose = false;
-  let ended = false;
-  const operands = [];
-  for (let i = 0; i < opArgs.length; i++) {
-    const a = opArgs[i];
-    if (ended || !a.startsWith("-") || a === "-") {
-      operands.push(a);
-      continue;
-    }
-    if (a === "--") {
-      ended = true;
-      continue;
-    }
-    if (a === "-f" || a === "--force") {
-      force = true;
-      continue;
-    }
-    if (a === "-r" || a === "-R" || a === "--recursive") {
-      recursive = true;
-      continue;
-    }
-    if (a === "-d" || a === "--dir") {
-      dirFlag = true;
-      continue;
-    }
-    if (a === "-v" || a === "--verbose") {
-      verbose = true;
-      continue;
-    }
-    if (a.startsWith("-") && !a.startsWith("--")) {
-      for (let j = 1; j < a.length; j++) {
-        const ch = a[j];
-        if (ch === "f") force = true;
-        else if (ch === "r" || ch === "R") recursive = true;
-        else if (ch === "d") dirFlag = true;
-        else if (ch === "v") verbose = true;
-        else return void 0;
-      }
-      continue;
-    }
-    return void 0;
-  }
-  if (operands.length === 0) return force ? "" : void 0;
-  for (const f of operands) {
-    if (f === "/" || f === "." || f === ".." || f.endsWith("/.") || f.endsWith("/..")) return void 0;
-    const st = statTypeSync(f);
-    if (st === "missing") {
-      if (!force) return void 0;
-    } else if (st === "directory") {
-      const entries = listDirSync(f);
-      const count = entries ? "size" in entries ? entries.size : entries.length : 1;
-      if (!recursive) {
-        if (!dirFlag || count > 0) return void 0;
-      }
-    } else if (st !== "file" && st !== "symlink") {
-      return void 0;
-    }
-  }
-  const collectRmVerbose = (p) => {
-    let chunk = "";
-    const st = statTypeSync(p);
-    if (st === "directory" && recursive) {
-      const entries = listDirSync(p);
-      const names = entries ? Array.isArray(entries) ? entries : [...entries.keys()] : [];
-      for (const name of names) {
-        chunk += collectRmVerbose(p.endsWith("/") ? `${p}${name}` : `${p}/${name}`);
-      }
-    }
-    chunk += `removed '${p}'
-`;
-    return chunk;
-  };
-  let out = "";
-  for (const f of operands) {
-    const st = statTypeSync(f);
-    if (st === "missing") continue;
-    const verboseLines = verbose ? collectRmVerbose(f) : "";
-    if (!rmSync(f)) return void 0;
-    if (verbose) out += verboseLines;
-  }
-  return out;
-}
-syncCommandEvaluators.evalSyncMkdir = evalSyncMkdir;
-syncCommandEvaluators.evalSyncRm = evalSyncRm;
-function evalSyncLn(opArgs, statTypeSync, rmSync, linkSync) {
-  const gnuInfo = gnuInformationSync("ln", opArgs);
-  if (gnuInfo !== void 0) return gnuInfo;
-  if (!statTypeSync || !rmSync || !linkSync) return void 0;
-  let symbolic = false;
-  let relative = false;
-  let force = false;
-  let verbose = false;
-  let noDeref = false;
-  let noTargetDir = false;
-  let targetDir;
-  let ended = false;
-  const operands = [];
-  for (let i = 0; i < opArgs.length; i++) {
-    const a = opArgs[i];
-    if (ended || !a.startsWith("-") || a === "-") {
-      operands.push(a);
-      continue;
-    }
-    if (a === "--") {
-      ended = true;
-      continue;
-    }
-    if (a === "-s" || a === "--symbolic") {
-      symbolic = true;
-      continue;
-    }
-    if (a === "-r" || a === "--relative") {
-      relative = true;
-      continue;
-    }
-    if (a === "-f" || a === "--force") {
-      force = true;
-      continue;
-    }
-    if (a === "-v" || a === "--verbose") {
-      verbose = true;
-      continue;
-    }
-    if (a === "-n" || a === "--no-dereference") {
-      noDeref = true;
-      continue;
-    }
-    if (a === "-T" || a === "--no-target-directory") {
-      noTargetDir = true;
-      continue;
-    }
-    if (a === "-t" || a === "--target-directory" || a.startsWith("--target-directory=")) {
-      const td = a.startsWith("--target-directory=") ? a.slice(19) : opArgs[++i];
-      if (!td) return void 0;
-      targetDir = td;
-      continue;
-    }
-    if (a.startsWith("-") && !a.startsWith("--")) {
-      for (let j = 1; j < a.length; j++) {
-        const ch = a[j];
-        if (ch === "s") symbolic = true;
-        else if (ch === "r") relative = true;
-        else if (ch === "f") force = true;
-        else if (ch === "v") verbose = true;
-        else if (ch === "n") noDeref = true;
-        else if (ch === "T") noTargetDir = true;
-        else if (ch === "t") {
-          const rest = a.slice(j + 1) || opArgs[++i];
-          if (!rest) return void 0;
-          targetDir = rest;
-          break;
-        } else return void 0;
-      }
-      continue;
-    }
-    return void 0;
-  }
-  if (noTargetDir && targetDir !== void 0 || relative && !symbolic) return void 0;
-  const normRel = (p) => {
-    const outParts = [];
-    for (const seg of p.split("/")) {
-      if (!seg || seg === ".") continue;
-      if (seg === "..") {
-        if (outParts.length > 0 && outParts[outParts.length - 1] !== "..") outParts.pop();
-        else if (!p.startsWith("/")) outParts.push("..");
-      } else outParts.push(seg);
-    }
-    return outParts;
-  };
-  const computeRelTarget = (srcPath, dstPath) => {
-    if (srcPath.startsWith("/") !== dstPath.startsWith("/")) return void 0;
-    const dstDir = dstPath.includes("/") ? dstPath.slice(0, dstPath.lastIndexOf("/")) || "/" : ".";
-    const fromParts = normRel(dstDir);
-    const toParts = normRel(srcPath);
-    if (fromParts.includes("..") || toParts.includes("..")) return void 0;
-    let common = 0;
-    while (common < fromParts.length && common < toParts.length && fromParts[common] === toParts[common]) common++;
-    const up = Array.from({ length: fromParts.length - common }, () => "..");
-    const rel = [...up, ...toParts.slice(common)].join("/");
-    return rel || ".";
-  };
-  const pairs = [];
-  if (targetDir !== void 0) {
-    if (operands.length === 0 || statTypeSync(targetDir) !== "directory") return void 0;
-    for (const s of operands) {
-      const base = s.replace(/\/+$/, "").split("/").pop() || "";
-      if (!base) return void 0;
-      pairs.push([s, `${targetDir.replace(/\/+$/, "")}/${base}`]);
-    }
-  } else if (operands.length === 1) {
-    if (noTargetDir) return void 0;
-    const s = operands[0];
-    const base = s.replace(/\/+$/, "").split("/").pop() || "";
-    if (!base) return void 0;
-    pairs.push([s, `./${base}`]);
-  } else if (operands.length >= 2) {
-    const last = operands[operands.length - 1];
-    const dstSt = statTypeSync(last);
-    if (!noDeref && dstSt === "directory") {
-      if (noTargetDir) return void 0;
-      for (let idx = 0; idx < operands.length - 1; idx++) {
-        const s = operands[idx];
-        const base = s.replace(/\/+$/, "").split("/").pop() || "";
-        if (!base) return void 0;
-        pairs.push([s, `${last.replace(/\/+$/, "")}/${base}`]);
-      }
-    } else if (operands.length === 2) {
-      pairs.push([operands[0], last]);
-    } else {
-      return void 0;
-    }
-  } else {
-    return void 0;
-  }
-  let out = "";
-  for (const [src, dst] of pairs) {
-    if (!symbolic && statTypeSync(src) !== "file") return void 0;
-    if (src === dst) return void 0;
-    let linkTarget = src;
-    if (relative) {
-      const rel = computeRelTarget(src, dst);
-      if (!rel) return void 0;
-      linkTarget = rel;
-    }
-    const finalSt = statTypeSync(dst);
-    if (finalSt === "file" || finalSt === "symlink") {
-      if (!force) return void 0;
-      if (!rmSync(dst)) return void 0;
-    } else if (finalSt !== "missing") {
-      return void 0;
-    }
-    if (!linkSync(linkTarget, dst, symbolic)) return void 0;
-    if (verbose) out += `'${dst}' ${symbolic ? "->" : "=>"} '${linkTarget}'
-`;
-  }
-  return out;
-}
-syncCommandEvaluators.evalSyncLn = evalSyncLn;
-function evalSyncCat(inBytes, opArgs, readFileSync) {
-  const gnuInfo = gnuInformationSync("cat", opArgs);
-  if (gnuInfo !== void 0) return gnuInfo;
-  let flagN = false;
-  let flagB = false;
-  let flagS = false;
-  let flagE = false;
-  let flagT = false;
-  let flagV = false;
-  let ended = false;
-  const operands = [];
-  for (let i = 0; i < opArgs.length; i++) {
-    const a = opArgs[i];
-    if (ended || !a.startsWith("-") || a === "-") {
-      operands.push(a);
-      continue;
-    }
-    if (a === "--") {
-      ended = true;
-      continue;
-    }
-    if (a === "--number") {
-      flagN = true;
-      continue;
-    }
-    if (a === "--number-nonblank") {
-      flagB = true;
-      continue;
-    }
-    if (a === "--squeeze-blank") {
-      flagS = true;
-      continue;
-    }
-    if (a === "--show-ends") {
-      flagE = true;
-      continue;
-    }
-    if (a === "--show-tabs") {
-      flagT = true;
-      continue;
-    }
-    if (a === "--show-nonprinting") {
-      flagV = true;
-      continue;
-    }
-    if (a === "--show-all") {
-      flagV = true;
-      flagE = true;
-      flagT = true;
-      continue;
-    }
-    if (a.startsWith("-") && !a.startsWith("--")) {
-      for (let j = 1; j < a.length; j++) {
-        const ch = a[j];
-        if (ch === "n") flagN = true;
-        else if (ch === "b") flagB = true;
-        else if (ch === "s") flagS = true;
-        else if (ch === "E") flagE = true;
-        else if (ch === "T") flagT = true;
-        else if (ch === "v") flagV = true;
-        else if (ch === "A") {
-          flagV = true;
-          flagE = true;
-          flagT = true;
-        } else if (ch === "e") {
-          flagV = true;
-          flagE = true;
-        } else if (ch === "t") {
-          flagV = true;
-          flagT = true;
-        } else if (ch === "u") continue;
-        else return void 0;
-      }
-      continue;
-    }
-    return void 0;
-  }
-  const chunks = [];
-  let totalIn = 0;
-  if (operands.length === 0) {
-    if (inBytes === void 0) return void 0;
-    chunks.push(inBytes);
-    totalIn += inBytes.byteLength;
-  } else {
-    for (const op of operands) {
-      if (op === "-") {
-        if (inBytes === void 0) return void 0;
-        chunks.push(inBytes);
-        totalIn += inBytes.byteLength;
-      } else {
-        if (!readFileSync) return void 0;
-        const b = readFileSync(op);
-        if (!b) return void 0;
-        chunks.push(b);
-        totalIn += b.byteLength;
-      }
-      if (totalIn > 16384) return void 0;
-    }
-  }
-  if (!flagN && !flagB && !flagS && !flagE && !flagT && !flagV) {
-    for (const c of chunks) {
-      if (c.includes(0)) return void 0;
-    }
-    if (chunks.length === 1) return decoder.decode(chunks[0]);
-    const merged = new Uint8Array(totalIn);
-    let off = 0;
-    for (const c of chunks) {
-      merged.set(c, off);
-      off += c.byteLength;
-    }
-    return decoder.decode(merged);
-  }
-  let lineStart = true;
-  let blankCount = 0;
-  let num = 1;
-  let pendingCr = false;
-  const showEndsOnlyCr = flagE && !flagV;
-  const out = [];
-  for (const chunk of chunks) {
-    for (let i = 0; i < chunk.byteLength; i++) {
-      const byte = chunk[i];
-      if (pendingCr) {
-        pendingCr = false;
-        if (byte === 10) {
-          out.push(94, 77);
-        } else {
-          out.push(13);
-        }
-      }
-      if (lineStart && byte === 10 && flagS && blankCount > 0) continue;
-      if (lineStart && (flagB ? byte !== 10 : flagN)) {
-        const digits = String(num++);
-        const pad = Math.max(0, 6 - digits.length);
-        for (let k = 0; k < pad; k++) out.push(32);
-        for (let k = 0; k < digits.length; k++) out.push(digits.charCodeAt(k));
-        out.push(9);
-      }
-      if (byte === 10) {
-        if (flagE) out.push(36);
-        out.push(10);
-        blankCount = lineStart ? blankCount + 1 : 0;
-        lineStart = true;
-      } else {
-        lineStart = false;
-        blankCount = 0;
-        if (byte === 13 && showEndsOnlyCr) {
-          pendingCr = true;
-        } else if (byte === 9) {
-          if (flagT) out.push(94, 73);
-          else out.push(9);
-        } else if (flagV) {
-          let visible = byte;
-          if (visible >= 128) {
-            out.push(77, 45);
-            visible -= 128;
-          }
-          if (visible < 32) out.push(94, visible + 64);
-          else if (visible === 127) out.push(94, 63);
-          else out.push(visible);
-        } else {
-          if (byte === 0) return void 0;
-          out.push(byte);
-        }
-      }
-    }
-  }
-  if (pendingCr) out.push(13);
-  return decoder.decode(Uint8Array.from(out));
-}
-function evalSyncHeadTail(name, inBytes, opArgs, readFileSync) {
-  const gnuInfo = gnuInformationSync(name, opArgs);
-  if (gnuInfo !== void 0) return gnuInfo;
-  let mode = "n";
-  let countStr = "10";
-  let headerMode = "default";
-  let zeroTerminated = false;
-  let ended = false;
-  const operands = [];
-  for (let i = 0; i < opArgs.length; i++) {
-    const a = opArgs[i];
-    if (ended || !a.startsWith("-") && !(name === "tail" && i === 0 && /^\+[0-9]+$/.test(a)) || a === "-") {
-      operands.push(a);
-      continue;
-    }
-    if (a === "--") {
-      ended = true;
-      continue;
-    }
-    if (a === "-q" || a === "--quiet" || a === "--silent") {
-      headerMode = "q";
-      continue;
-    }
-    if (a === "-v" || a === "--verbose") {
-      headerMode = "v";
-      continue;
-    }
-    if (a === "-z" || a === "--zero-terminated") {
-      zeroTerminated = true;
-      continue;
-    }
-    if (a === "-n" || a === "--lines") {
-      if (i + 1 >= opArgs.length) return void 0;
-      mode = "n";
-      countStr = opArgs[++i];
-      continue;
-    }
-    if (a === "-c" || a === "--bytes") {
-      if (i + 1 >= opArgs.length) return void 0;
-      mode = "c";
-      countStr = opArgs[++i];
-      continue;
-    }
-    if (a.startsWith("--lines=")) {
-      mode = "n";
-      countStr = a.slice(8);
-      continue;
-    }
-    if (a.startsWith("--bytes=")) {
-      mode = "c";
-      countStr = a.slice(8);
-      continue;
-    }
-    if (/^-[0-9]+$/.test(a) || name === "tail" && i === 0 && /^\+[0-9]+$/.test(a)) {
-      mode = "n";
-      countStr = a.startsWith("-") ? a.slice(1) : a;
-      continue;
-    }
-    if (a.startsWith("-") && !a.startsWith("--")) {
-      for (let j = 1; j < a.length; j++) {
-        const ch = a[j];
-        if (ch === "q") headerMode = "q";
-        else if (ch === "v") headerMode = "v";
-        else if (ch === "z") zeroTerminated = true;
-        else if (ch === "n" || ch === "c") {
-          mode = ch;
-          const rest = a.slice(j + 1) || opArgs[++i];
-          if (!rest) return void 0;
-          countStr = rest;
-          break;
-        } else return void 0;
-      }
-      continue;
-    }
-    return void 0;
-  }
-  const mCount = /^([+-]?)([0-9]{1,6})(b|kB|K|MB|M)?$/.exec(countStr);
-  if (!mCount) return void 0;
-  const mult = mCount[3] === "b" ? 512 : mCount[3] === "kB" ? 1e3 : mCount[3] === "K" ? 1024 : mCount[3] === "MB" ? 1e6 : mCount[3] === "M" ? 1048576 : 1;
-  const count = Number(mCount[2]) * mult;
-  const isPlus = countStr.startsWith("+");
-  const isMinus = countStr.startsWith("-");
-  if (name === "head" && isPlus) return void 0;
-  if (name === "tail" && isMinus && mode === "c") return void 0;
-  const targets = operands.length > 0 ? operands : ["-"];
-  const showHeaders = headerMode === "v" || headerMode !== "q" && targets.length > 1;
-  let out = "";
-  for (let idx = 0; idx < targets.length; idx++) {
-    const t = targets[idx];
-    let bytes;
-    if (t === "-") {
-      if (inBytes === void 0) return void 0;
-      bytes = inBytes;
-    } else {
-      if (!readFileSync) return void 0;
-      bytes = readFileSync(t);
-    }
-    if (!bytes || !zeroTerminated && bytes.includes(0)) return void 0;
-    const text = decoder.decode(bytes);
-    if (showHeaders) {
-      out += `${idx > 0 ? "\n" : ""}==> ${t === "-" ? "standard input" : t} <==
-`;
-    }
-    if (mode === "c") {
-      if (name === "head") {
-        out += isMinus ? count === 0 ? text : decoder.decode(bytes.subarray(0, Math.max(0, bytes.byteLength - count))) : decoder.decode(bytes.subarray(0, count));
-      } else {
-        out += isPlus ? decoder.decode(bytes.subarray(Math.max(0, count - 1))) : count === 0 ? "" : decoder.decode(bytes.subarray(Math.max(0, bytes.byteLength - count)));
-      }
-    } else {
-      const termCode = zeroTerminated ? 0 : 10;
-      const lines2 = [];
-      let start = 0;
-      for (let k = 0; k < text.length; k++) {
-        if (text.charCodeAt(k) === termCode) {
-          lines2.push(text.slice(start, k + 1));
-          start = k + 1;
-        }
-      }
-      if (start < text.length) lines2.push(text.slice(start));
-      let selected;
-      if (name === "head") {
-        selected = isMinus ? count === 0 ? lines2 : lines2.slice(0, Math.max(0, lines2.length - count)) : lines2.slice(0, count);
-      } else {
-        selected = isPlus ? lines2.slice(Math.max(0, count - 1)) : count === 0 ? [] : lines2.slice(-count);
-      }
-      out += selected.join("");
-    }
-  }
-  return out;
-}
-syncCommandEvaluators.evalSyncCat = evalSyncCat;
-syncCommandEvaluators.evalSyncHeadTail = evalSyncHeadTail;
-function evalSyncWc(inBytes, opArgs, singleByte, readFileSync) {
-  const gnuInfo = gnuInformationSync("wc", opArgs);
-  if (gnuInfo !== void 0) return gnuInfo;
-  const flags = /* @__PURE__ */ new Set();
-  let totalMode = "auto";
-  let hasFiles0From = false;
-  let ended = false;
-  const operands = [];
-  for (let i = 0; i < opArgs.length; i++) {
-    const a = opArgs[i];
-    if (ended || !a.startsWith("-") || a === "-") {
-      operands.push(a);
-      continue;
-    }
-    if (a === "--") {
-      ended = true;
-      continue;
-    }
-    if (a === "--lines") {
-      flags.add("l");
-      continue;
-    }
-    if (a === "--words") {
-      flags.add("w");
-      continue;
-    }
-    if (a === "--chars") {
-      flags.add("m");
-      continue;
-    }
-    if (a === "--bytes") {
-      flags.add("c");
-      continue;
-    }
-    if (a === "--max-line-length") {
-      flags.add("L");
-      continue;
-    }
-    if (a === "--total") {
-      if (i + 1 >= opArgs.length) return void 0;
-      totalMode = opArgs[++i];
-      continue;
-    }
-    if (a.startsWith("--total=")) {
-      totalMode = a.slice(8);
-      continue;
-    }
-    if (a === "--files0-from" || a.startsWith("--files0-from=")) {
-      hasFiles0From = true;
-      const f0 = a === "--files0-from" ? opArgs[++i] : a.slice(14);
-      if (!f0) return void 0;
-      const fBytes = f0 === "-" ? inBytes : readFileSync?.(f0);
-      if (!fBytes || fBytes.byteLength > 16384) return void 0;
-      const fText = decoder.decode(fBytes);
-      const parts = fText.endsWith("\0") ? fText.slice(0, -1).split("\0") : fText.length === 0 ? [] : fText.split("\0");
-      for (const p of parts) {
-        if (!p) return void 0;
-        operands.push(p);
-      }
-      continue;
-    }
-    if (a.startsWith("-") && !a.startsWith("--")) {
-      for (let j = 1; j < a.length; j++) {
-        const ch = a[j];
-        if (ch === "l" || ch === "w" || ch === "m" || ch === "c" || ch === "L") {
-          flags.add(ch);
-        } else {
-          return void 0;
-        }
-      }
-      continue;
-    }
-    return void 0;
-  }
-  if (!["auto", "always", "only", "never"].includes(totalMode)) return void 0;
-  if (flags.size === 0) {
-    flags.add("l");
-    flags.add("w");
-    flags.add("c");
-  }
-  const selected = ["l", "w", "m", "c", "L"].filter((f) => flags.has(f));
-  if (hasFiles0From && operands.length === 0) return "";
-  const names = operands.length > 0 ? operands : ["-"];
-  const buffers = [];
-  let totalBytesAll = 0;
-  for (const name of names) {
-    let b;
-    if (name === "-") {
-      if (inBytes === void 0) return void 0;
-      b = inBytes;
-    } else {
-      if (!readFileSync) return void 0;
-      b = readFileSync(name);
-      if (!b) return void 0;
-    }
-    totalBytesAll += b.byteLength;
-    if (totalBytesAll > 65536) return void 0;
-    if (!singleByte && (flags.has("w") || flags.has("L")) && b.some((byte) => byte >= 128)) {
-      return void 0;
-    }
-    buffers.push(b);
-  }
-  let width = 1;
-  if (totalMode !== "only" && (names.length > 1 || selected.length > 1)) {
-    let totalSize = 0;
-    for (let i = 0; i < names.length; i++) {
-      if (names[i] === "-") {
-        width = Math.max(width, 7);
-      } else {
-        totalSize += buffers[i].byteLength;
-      }
-    }
-    width = Math.max(width, String(totalSize).length);
-  }
-  const totals = { l: 0, w: 0, m: 0, c: 0, L: 0 };
-  const rows = [];
-  const formatRow = (counts, label) => selected.map((f) => String(counts[f]).padStart(width)).join(" ") + (label === void 0 ? "" : ` ${label}`) + "\n";
-  for (let idx = 0; idx < names.length; idx++) {
-    const name = names[idx];
-    const buf = buffers[idx];
-    let l = 0;
-    let w = 0;
-    let m = 0;
-    const c = buf.byteLength;
-    let maxL = 0;
-    let columns = 0;
-    let inWord = false;
-    for (let i = 0; i < buf.byteLength; i++) {
-      const byte = buf[i];
-      if (byte === 10) {
-        l++;
-        inWord = false;
-        if (columns > maxL) maxL = columns;
-        columns = 0;
-      } else if (byte === 32 || byte >= 9 && byte <= 13) {
-        inWord = false;
-        if (byte === 9) columns += 8 - (columns & 7);
-        else if (byte === 13 || byte === 12) {
-          if (columns > maxL) maxL = columns;
-          columns = 0;
-        } else if (byte === 32) {
-          columns++;
-        }
-      } else if (byte >= 33 && byte < 127) {
-        if (!inWord) {
-          w++;
-          inWord = true;
-        }
-        columns++;
-      }
-    }
-    if (columns > maxL) maxL = columns;
-    if (singleByte) {
-      m = c;
-    } else if (flags.has("m")) {
-      m = Array.from(decoder.decode(buf)).length;
-    }
-    const counts = { l, w, m, c, L: maxL };
-    totals.l += l;
-    totals.w += w;
-    totals.m += m;
-    totals.c += c;
-    totals.L = Math.max(totals.L, maxL);
-    if (totalMode !== "only") {
-      rows.push(formatRow(counts, operands.length > 0 ? name : void 0));
-    }
-  }
-  if (totalMode === "only") {
-    rows.push(formatRow(totals));
-  } else if (totalMode === "always" || totalMode === "auto" && names.length > 1) {
-    rows.push(formatRow(totals, "total"));
-  }
-  return rows.join("");
-}
-syncCommandEvaluators.evalSyncWc = evalSyncWc;
-
-export {
-  path_exports,
-  inputRequirements,
-  textOutputRequirements,
-  pwdRequirements,
-  predicateRequirements,
-  RecordBuffer,
-  gnuInformationSync,
-  gnuInformation,
-  utf8ByteLength,
-  bytesFrom,
-  concatBytes,
-  compareBytes,
-  filledBytes,
-  latin1Text,
-  equalBytes,
-  base64Text,
-  defaultSleepScheduler,
-  settings,
-  CommandFailure,
-  checkSize,
-  emit,
-  timeEnvExecutorSettings,
-  command,
-  ownEnvironment,
-  nanosecondsPerSecond,
-  monthNames,
-  weekdayNames,
-  floorDivide,
-  millisecondsInstant,
-  utcMilliseconds,
-  TimeZone,
-  parseDate,
-  touchTimes,
-  RESOLVED_EXIT_ZERO,
-  RESOLVED_EXIT_ONE,
-  encoder2 as encoder,
-  decoder,
-  bufferLimit,
-  syncCommandEvaluators,
-  options,
-  value,
-  integer,
-  requireOperands,
-  codeOf,
-  RETURN_EXIT_ZERO,
-  RETURN_EXIT_ONE,
-  RETURN_EXIT_TWO,
-  outputRange,
-  output,
-  diagnostic,
-  define,
-  eachOperand,
-  input,
-  assertInputRequirements,
-  concatenate,
-  lines,
-  emptyInput,
-  replaceArgument,
-  escapeBytes,
-  builtInDirectContextExecutors2 as builtInDirectContextExecutors,
-  isDefaultCommandOptions,
-  registerDefaultExecutor,
-  registerDefaultExecutors,
-  UsageError2 as UsageError
-};
-//# sourceMappingURL=chunk-ISCZG7WA.js.map