@poe-platform/safe-bash 0.1.535 → 0.1.537

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

@@ -0,0 +1,1236 @@
+import {
+  createOutputOperation
+} from "./chunk-PPVCI2F2.js";
+import {
+  FsError,
+  PublicDiagnostic,
+  getCommandArguments,
+  init_platform,
+  publicDiagnosticMessage,
+  resolvePath,
+  shellValueByteLength,
+  shellValueBytes,
+  yieldTurn
+} from "./chunk-L2GZSOSJ.js";
+
+// packages/safe-bash/src/commands/pr/index.ts
+init_platform();
+
+// packages/safe-bash/src/commands/pr/command.ts
+init_platform();
+
+// packages/safe-bash/src/commands/pr/internal.ts
+init_platform();
+function settings(options) {
+  const limits = {
+    maxArguments: 4096,
+    maxArgumentBytes: 65536,
+    maxFiles: 128,
+    maxColumns: 128,
+    maxPageLines: 65536,
+    maxPageWidth: 65536,
+    maxPages: 65536,
+    maxInputBytes: 33554432,
+    maxBufferedBytes: 16777216,
+    maxLineBytes: 1048576,
+    maxLines: 1048576,
+    maxOutputBytes: 67108864,
+    maxDiagnosticBytes: 65536,
+    maxWork: 134217728,
+    maxEmptyChunks: 4096,
+    ...options.limits
+  };
+  for (const [name, value] of Object.entries(limits)) {
+    if (!Number.isSafeInteger(value) || value < 1) throw new RangeError(`Invalid pr limit: ${name}`);
+  }
+  if (options.clock !== void 0 && typeof options.clock !== "function") throw new TypeError("pr clock must be a function");
+  return Object.freeze(limits);
+}
+var PrError = class extends PublicDiagnostic {
+  constructor(message, usage = false) {
+    super(message);
+    this.usage = usage;
+  }
+  usage;
+};
+var PrReadError = class extends PrError {
+};
+function raw(value) {
+  let text = "";
+  for (const byte of value) text += String.fromCharCode(byte);
+  return text;
+}
+function bytes(value) {
+  return Uint8Array.from(value, (character) => character.charCodeAt(0));
+}
+function pathText(value) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes(value));
+  } catch {
+    throw new PrError("filesystem paths must be valid UTF-8");
+  }
+}
+function quote(value) {
+  const escapes = { "\x07": "\\a", "\b": "\\b", "\f": "\\f", "\n": "\\n", "\r": "\\r", "	": "\\t", "\v": "\\v", "\\": "\\\\", "'": "\\'" };
+  let result = "'";
+  for (const character of value) {
+    const code = character.charCodeAt(0);
+    result += escapes[character] ?? (code >= 32 && code < 127 ? character : `\\${code.toString(8).padStart(3, "0")}`);
+  }
+  return `${result}'`;
+}
+function fileQuote(value) {
+  let safe = value.length > 0, escaped = false;
+  for (const character of value) {
+    const code = character.charCodeAt(0);
+    if (!(character >= "a" && character <= "z" || character >= "A" && character <= "Z" || character >= "0" && character <= "9" || "_./-".includes(character))) safe = false;
+    if (code < 32 || code >= 127) escaped = true;
+  }
+  if (safe) return value;
+  if (!escaped) {
+    if (value.includes("'") && !["$", "`", "\\", '"'].some((character) => value.includes(character))) return `"${value}"`;
+    return `'${value.split("'").join("'\\''")}'`;
+  }
+  let result = "'", inEscape = false;
+  for (const character of value) {
+    const code = character.charCodeAt(0);
+    if (code < 32 || code >= 127) {
+      if (!inEscape) {
+        result += "'$'";
+        inEscape = true;
+      }
+      result += quote(character).slice(1, -1);
+    } else {
+      if (inEscape) {
+        result += "''";
+        inEscape = false;
+      }
+      result += character === "'" ? "'\\''" : character;
+    }
+  }
+  return `${result}'`;
+}
+var Budget = class {
+  constructor(context, limits, signal) {
+    this.context = context;
+    this.limits = limits;
+    this.signal = signal;
+  }
+  context;
+  limits;
+  signal;
+  work = 0;
+  checkpoint = 0;
+  retained = 0;
+  input = 0;
+  lines = 0;
+  pages = 0;
+  output = 0;
+  diagnostics = 0;
+  check(value, maximum, label) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > maximum) throw new PrError(`${label} limit exceeded`);
+  }
+  charge(amount = 1) {
+    this.signal.throwIfAborted();
+    this.work += amount;
+    this.check(this.work, this.limits.maxWork, "work");
+  }
+  async checkpointWork() {
+    this.signal.throwIfAborted();
+    if (this.work - this.checkpoint >= 4096) {
+      this.checkpoint = this.work;
+      await yieldTurn(this.signal);
+    }
+  }
+  retain(amount) {
+    this.check(this.retained + amount, this.limits.maxBufferedBytes, "buffered bytes");
+    this.retained += amount;
+  }
+  admitString(length) {
+    this.signal.throwIfAborted();
+    this.check(length, this.limits.maxWork - this.work, "work");
+    this.check(this.retained + length * 2, this.limits.maxBufferedBytes, "buffered bytes");
+  }
+  inputBytes(amount) {
+    this.input += amount;
+    this.check(this.input, this.limits.maxInputBytes, "input bytes");
+  }
+  line() {
+    this.check(++this.lines, this.limits.maxLines, "input lines");
+  }
+  page() {
+    this.check(++this.pages, this.limits.maxPages, "pages");
+    this.charge();
+  }
+  emitted(amount, diagnostic) {
+    if (diagnostic) {
+      this.diagnostics += amount;
+      this.check(this.diagnostics, this.limits.maxDiagnosticBytes, "diagnostic bytes");
+    } else {
+      this.output += amount;
+      this.check(this.output, this.limits.maxOutputBytes, "output bytes");
+    }
+    if (!diagnostic) this.charge(amount);
+  }
+  arguments() {
+    this.check(this.context.args.length, this.limits.maxArguments, "argument count");
+    let total = 0;
+    for (const argument of this.context.args) {
+      total += argument.length;
+      this.check(total, this.limits.maxArgumentBytes, "argument bytes");
+      for (let offset = 0; offset < argument.length; offset++) {
+        const unit = argument.charCodeAt(offset);
+        if (unit >= 55296 && unit <= 56319) {
+          const next = argument.charCodeAt(++offset);
+          if (!(next >= 56320 && next <= 57343)) throw new PrError("arguments must contain well-formed Unicode");
+        } else if (unit >= 56320 && unit <= 57343) throw new PrError("arguments must contain well-formed Unicode");
+      }
+    }
+    total = 0;
+    return getCommandArguments(this.context).values.map((argument) => {
+      total += shellValueByteLength(argument);
+      this.check(total, this.limits.maxArgumentBytes, "argument bytes");
+      const value = shellValueBytes(argument);
+      this.charge(value.length);
+      if (value.includes(0)) throw new PrError("NUL is not supported in arguments");
+      return raw(value);
+    });
+  }
+};
+
+// packages/safe-bash/src/commands/pr/io.ts
+init_platform();
+var Lifecycle = class {
+  constructor(budget, output) {
+    this.budget = budget;
+    output.registerCleanup(() => this.close());
+  }
+  budget;
+  pending = /* @__PURE__ */ new Set();
+  cleanups = [];
+  closing;
+  cleanup(action) {
+    this.assertOpen();
+    this.cleanups.push(action);
+  }
+  assertOpen() {
+    this.budget.signal.throwIfAborted();
+    if (this.closing) throw new PrError("command is closed");
+  }
+  async operation(action, diagnostic = false) {
+    this.assertOpen();
+    if (!diagnostic) this.budget.charge();
+    const pending = Promise.resolve().then(() => {
+      this.assertOpen();
+      return action();
+    });
+    this.pending.add(pending);
+    try {
+      const value = await pending;
+      this.assertOpen();
+      return value;
+    } finally {
+      this.pending.delete(pending);
+    }
+  }
+  close() {
+    return this.closing ??= Promise.resolve().then(async () => {
+      while (this.pending.size) await Promise.allSettled([...this.pending]);
+      const failures = [];
+      for (const cleanup of this.cleanups) {
+        try {
+          await cleanup();
+        } catch (error) {
+          failures.push(error);
+        }
+      }
+      if (failures.length === 1) throw failures[0];
+      if (failures.length > 1) throw new AggregateError(failures, "pr cleanup failed");
+    });
+  }
+  async write(value, diagnostic = false) {
+    const { budget } = this;
+    budget.emitted(value.length, diagnostic);
+    await this.operation(async () => {
+      if (!diagnostic) budget.retain(value.length * 3);
+      try {
+        const sink = diagnostic ? budget.context.stderr : budget.context.stdout;
+        await (sink.ownedOutput ?? sink).write(bytes(value));
+      } finally {
+        if (!diagnostic) budget.retain(-value.length * 3);
+      }
+    }, diagnostic);
+  }
+};
+var Reader = class {
+  constructor(name, lifecycle) {
+    this.name = name;
+    this.lifecycle = lifecycle;
+    lifecycle.cleanup(async () => {
+      try {
+        if (!this.ended) await this.iterator?.return?.();
+      } finally {
+        this.iterator = void 0;
+        this.releaseSnapshot();
+        lifecycle.budget.retain(-this.chunk.length);
+        this.chunk = new Uint8Array();
+      }
+    });
+  }
+  name;
+  lifecycle;
+  iterator;
+  chunk = new Uint8Array();
+  offset = 0;
+  pushed = -1;
+  ended = false;
+  empties = 0;
+  length = 0;
+  snapshotBytes = 0;
+  path;
+  stat;
+  releaseSnapshot = () => {
+    this.lifecycle.budget.retain(-this.snapshotBytes);
+    this.snapshotBytes = 0;
+  };
+  async open() {
+    if (this.name === "-") return;
+    const { budget } = this.lifecycle;
+    this.path = resolvePath(budget.context.cwd, pathText(this.name));
+    this.stat = await this.lifecycle.operation(() => budget.context.fs.stat(this.path, { signal: budget.signal }));
+    if (this.stat.type !== "file" && this.stat.type !== "directory" && this.stat.type !== "character") throw new FsError("ENOTSUP", { path: this.path });
+  }
+  async acquire() {
+    const { budget } = this.lifecycle;
+    const { fs, stdin } = budget.context;
+    await this.lifecycle.operation(async () => {
+      let source;
+      if (this.path === void 0) source = stdin;
+      else {
+        const capabilities = await fs.capabilitiesFor?.(this.path, { signal: budget.signal }) ?? fs.capabilities;
+        budget.signal.throwIfAborted();
+        if (fs.readStream && capabilities.streamingRead !== false) source = fs.readStream(this.path, { signal: budget.signal, chunkSize: 16384 });
+        else {
+          const maximum = Math.min(budget.limits.maxInputBytes, Math.floor(budget.limits.maxBufferedBytes / 2));
+          budget.check(this.stat.size, maximum, "buffered input bytes");
+          budget.retain(maximum);
+          this.snapshotBytes = maximum;
+          const content = await fs.readFile(this.path, { signal: budget.signal, maxBytes: maximum });
+          if (!(content instanceof Uint8Array)) throw new TypeError("pr input requires bytes");
+          budget.check(content.length, maximum, "buffered input bytes");
+          budget.retain(content.length - maximum);
+          this.snapshotBytes = content.length;
+          const { releaseSnapshot } = this;
+          source = { async *[Symbol.asyncIterator]() {
+            try {
+              yield content;
+            } finally {
+              releaseSnapshot();
+            }
+          } };
+        }
+      }
+      this.iterator = source[Symbol.asyncIterator]();
+    });
+  }
+  unget(value) {
+    this.pushed = value;
+  }
+  async get() {
+    const { budget } = this.lifecycle;
+    budget.charge();
+    await budget.checkpointWork();
+    if (this.stat?.type === "directory") throw new PrReadError(`${fileQuote(this.name)}: Is a directory`);
+    if (this.pushed >= 0) {
+      const value2 = this.pushed;
+      this.pushed = -1;
+      return value2;
+    }
+    while (this.offset === this.chunk.length) {
+      if (this.ended) return -1;
+      let next;
+      try {
+        if (!this.iterator) await this.acquire();
+        next = await this.lifecycle.operation(() => this.iterator.next());
+      } catch (error) {
+        if (error instanceof FsError) throw new PrReadError(`${fileQuote(this.name === "-" ? "standard input" : this.name)}: ${fsDetail(error)}`);
+        throw error;
+      }
+      budget.retain(-this.chunk.length);
+      this.chunk = new Uint8Array();
+      this.offset = 0;
+      if (next.done) {
+        this.ended = true;
+        this.iterator = void 0;
+        if (this.length > 0) {
+          this.length = 0;
+          budget.line();
+        }
+        return -1;
+      }
+      if (!(next.value instanceof Uint8Array)) throw new TypeError("pr input requires bytes");
+      budget.inputBytes(next.value.length);
+      budget.retain(next.value.length);
+      this.chunk = Uint8Array.from(next.value);
+      if (!this.chunk.length) budget.check(++this.empties, budget.limits.maxEmptyChunks, "empty input chunks");
+    }
+    const value = this.chunk[this.offset++];
+    if (value === 10 || value === 12) {
+      this.length = 0;
+      budget.line();
+    } else budget.check(++this.length, budget.limits.maxLineBytes, "input line bytes");
+    return value;
+  }
+};
+function fsDetail(error) {
+  const details = {
+    EACCES: "Permission denied",
+    EPERM: "Operation not permitted",
+    ENOENT: "No such file or directory",
+    EISDIR: "Is a directory",
+    ENOTDIR: "Not a directory",
+    EIO: "Input/output error",
+    ELOOP: "Too many levels of symbolic links",
+    ENAMETOOLONG: "File name too long",
+    ENOTSUP: "Operation not supported"
+  };
+  return details[error.code] ?? error.message;
+}
+
+// packages/safe-bash/src/commands/pr/options.ts
+init_platform();
+function digit(value) {
+  return value >= "0" && value <= "9";
+}
+function integer(value, minimum, label) {
+  let offset = 0;
+  while (" 	\r\n\v\f".includes(value[offset] ?? "!") && offset < value.length) offset++;
+  if (value[offset] === "+" || value[offset] === "-") offset++;
+  const start = offset;
+  while (offset < value.length && digit(value[offset])) offset++;
+  if (offset !== value.length || offset === start) throw new PrError(`${label}: ${quote(value)}`);
+  const result = Number(value);
+  if (result < minimum || result > 2147483647 || !Number.isSafeInteger(result)) throw new PrError(`${label}: ${quote(value)}: Numerical result out of range`);
+  return result;
+}
+function parseOptions(args, budget) {
+  const options = {
+    files: [],
+    columns: 1,
+    explicitColumns: false,
+    merge: false,
+    across: false,
+    length: 66,
+    width: 72,
+    header: void 0,
+    extremities: true,
+    keepFF: false,
+    formFeed: false,
+    numbered: false,
+    digits: 5,
+    numberSeparator: "	",
+    startNumber: 1,
+    separator: "",
+    useSeparator: false,
+    truncate: false,
+    join: false,
+    doubleSpace: false,
+    margin: 0,
+    expand: false,
+    tabify: false,
+    inputTab: "	",
+    inputTabWidth: 8,
+    outputTab: "	",
+    outputTabWidth: 8,
+    control: false,
+    octal: false,
+    quiet: false,
+    information: void 0
+  };
+  const long = {
+    columns: "#",
+    across: "a",
+    "show-control-chars": "c",
+    "double-space": "d",
+    "expand-tabs": "e",
+    "form-feed": "f",
+    header: "h",
+    "output-tabs": "i",
+    "join-lines": "J",
+    length: "l",
+    merge: "m",
+    "number-lines": "n",
+    "first-line-number": "N",
+    indent: "o",
+    "no-file-warnings": "r",
+    separator: "s",
+    "sep-string": "S",
+    "omit-header": "t",
+    "omit-pagination": "T",
+    "show-nonprinting": "v",
+    width: "w",
+    "page-width": "W"
+  };
+  let oldWidth = false, oldSeparator = false, oldOptions = false, stop = false;
+  let columnDigits;
+  let accumulating = false;
+  for (let index = 0; index < args.length; index++) {
+    const argument = args[index];
+    budget.charge(argument.length);
+    if (stop) {
+      options.files.push(argument);
+      continue;
+    }
+    if (argument === "--") {
+      stop = true;
+      continue;
+    }
+    if (argument === "--help" || argument === "--version") {
+      options.information = argument === "--help" ? "help" : "version";
+      return options;
+    }
+    if (!argument.startsWith("-") || argument === "-") {
+      accumulating = false;
+      options.files.push(argument);
+      continue;
+    }
+    const isLong = argument.startsWith("--");
+    let switches = argument.slice(1), attached;
+    if (isLong) {
+      const equal = argument.indexOf("=");
+      const name = argument.slice(2, equal < 0 ? void 0 : equal);
+      const candidates = Object.keys(long).filter((candidate) => candidate.startsWith(name));
+      if (!Object.hasOwn(long, name) && candidates.length > 1) throw new PrError(`option ${quote(argument)} is ambiguous; possibilities:${candidates.map((candidate) => ` '--${candidate}'`).join("")}`, true);
+      switches = long[name] ?? (candidates.length === 1 ? long[candidates[0]] : void 0) ?? "";
+      if (!switches) throw new PrError(`unrecognized option ${quote(argument)}`, true);
+      if (equal >= 0) attached = argument.slice(equal + 1);
+    }
+    for (let offset = 0; offset < switches.length; offset++) {
+      const option = switches[offset];
+      if (digit(option)) {
+        columnDigits = (accumulating ? columnDigits ?? "" : "") + option;
+        accumulating = true;
+        continue;
+      }
+      accumulating = false;
+      const required = "#hlwWNo".includes(option);
+      const optional = "nseiS".includes(option);
+      let value = attached;
+      if (required || optional) {
+        if (!isLong && offset + 1 < switches.length) value = switches.slice(offset + 1);
+        if (required && value === void 0) {
+          value = args[++index];
+          if (value === void 0) throw new PrError(isLong ? `option ${quote(argument)} requires an argument` : `option requires an argument -- '${option}'`, true);
+        }
+        offset = switches.length;
+      } else if (attached !== void 0) throw new PrError(`option ${quote(argument.slice(0, argument.indexOf("=")))} doesn't allow an argument`, true);
+      switch (option) {
+        case "#":
+          options.columns = integer(value, 1, "invalid number of columns");
+          options.explicitColumns = true;
+          columnDigits = void 0;
+          break;
+        case "h":
+          options.header = value;
+          break;
+        case "l":
+          options.length = integer(value, 1, "'-l PAGE_LENGTH' invalid number of lines");
+          break;
+        case "w":
+          oldWidth = true;
+          oldOptions = true;
+          {
+            const width = integer(value, 1, "'-w PAGE_WIDTH' invalid number of characters");
+            if (!options.truncate) options.width = width;
+          }
+          break;
+        case "W":
+          oldWidth = false;
+          options.truncate = true;
+          options.width = integer(value, 1, "'-W PAGE_WIDTH' invalid number of characters");
+          break;
+        case "m":
+          options.merge = true;
+          break;
+        case "a":
+          options.across = true;
+          break;
+        case "b":
+          break;
+        case "d":
+          options.doubleSpace = true;
+          break;
+        case "f":
+        case "F":
+          options.formFeed = true;
+          break;
+        case "J":
+          options.join = true;
+          break;
+        case "N":
+          options.startNumber = integer(value, -2147483648, "'-N NUMBER' invalid starting line number");
+          break;
+        case "o":
+          options.margin = integer(value, 0, "'-o MARGIN' invalid line offset");
+          break;
+        case "r":
+          options.quiet = true;
+          break;
+        case "s":
+          oldOptions = true;
+          oldSeparator = true;
+          if (!options.useSeparator && value !== void 0) options.separator = value;
+          break;
+        case "S":
+          oldSeparator = false;
+          options.useSeparator = true;
+          options.separator = value ?? "";
+          break;
+        case "t":
+          options.extremities = false;
+          options.keepFF = true;
+          break;
+        case "T":
+          options.extremities = false;
+          options.keepFF = false;
+          break;
+        case "c":
+          options.control = true;
+          break;
+        case "v":
+          options.octal = true;
+          break;
+        case "n":
+        case "e":
+        case "i": {
+          if (option === "n") options.numbered = true;
+          if (option === "e") options.expand = true;
+          if (option === "i") options.tabify = true;
+          if (value === void 0 || !value.length) break;
+          let character;
+          if (!digit(value[0])) {
+            character = value[0];
+            value = value.slice(1);
+          }
+          let count;
+          if (value.length) {
+            try {
+              count = integer(value, 1, "invalid number");
+            } catch {
+              throw new PrError(`'-${option}' extra characters or invalid number in the argument: ${quote(value)}${Number(value) > 2147483647 ? ": Value too large for defined data type" : ""}`, true);
+            }
+          }
+          if (option === "n") {
+            options.numberSeparator = character ?? options.numberSeparator;
+            options.digits = count ?? options.digits;
+          }
+          if (option === "e") {
+            options.inputTab = character ?? options.inputTab;
+            options.inputTabWidth = count ?? options.inputTabWidth;
+          }
+          if (option === "i") {
+            options.outputTab = character ?? options.outputTab;
+            options.outputTabWidth = count ?? options.outputTabWidth;
+          }
+          break;
+        }
+        default:
+          throw new PrError(`invalid option -- '${option}'`, true);
+      }
+    }
+  }
+  if (columnDigits !== void 0) {
+    options.columns = integer(columnDigits, 1, "invalid number of columns");
+    options.explicitColumns = true;
+  }
+  if (options.merge && options.explicitColumns) throw new PrError("cannot specify number of columns when printing in parallel");
+  if (options.merge && options.across) throw new PrError("cannot specify both printing across and printing in parallel");
+  if (oldOptions) {
+    if (oldWidth) {
+      if (options.merge || options.explicitColumns) {
+        options.truncate = true;
+        if (oldSeparator) options.useSeparator = true;
+      } else options.join = true;
+    } else if (!options.useSeparator && oldSeparator && (options.merge || options.explicitColumns)) {
+      if (!options.truncate) {
+        options.join = true;
+        if (options.separator.length) options.useSeparator = true;
+      } else options.useSeparator = true;
+    }
+  }
+  const { limits } = budget;
+  budget.check(options.files.length, limits.maxFiles, "input files");
+  budget.check(options.merge ? Math.max(1, options.files.length) : options.columns, limits.maxColumns, "columns");
+  budget.check(options.length, limits.maxPageLines, "page lines");
+  for (const width of [options.width, options.margin, options.digits, options.inputTabWidth, options.outputTabWidth]) budget.check(width, limits.maxPageWidth, "page width");
+  return options;
+}
+
+// packages/safe-bash/src/commands/pr/format.ts
+init_platform();
+var Formatter = class {
+  constructor(options, lifecycle, count) {
+    this.options = options;
+    this.lifecycle = lifecycle;
+    this.budget = lifecycle.budget;
+    if (options.length <= 10) {
+      options.extremities = false;
+      options.keepFF = true;
+    }
+    this.body = Math.floor((options.extremities ? options.length - 10 : options.length) / (options.doubleSpace ? 2 : 1));
+    if (this.body < 1) throw new PrError("page has no text lines");
+    options.columns = options.merge ? count : options.columns;
+    if (options.columns > 1) {
+      if (!options.useSeparator) {
+        options.useSeparator = true;
+        options.separator = options.join ? "	" : " ";
+      } else if (!options.join && options.separator === "	") options.separator = " ";
+      options.truncate = true;
+      options.tabify = true;
+    }
+    if (options.join) options.truncate = false;
+    this.numberWidth = options.numberSeparator === "	" ? options.digits + 8 - options.digits % 8 : options.digits + 1;
+    this.columnWidth = Math.trunc((options.width - (options.merge && options.numbered ? this.numberWidth : 0) - (options.columns - 1) * options.separator.length) / options.columns);
+    if (this.columnWidth < 1) throw new PrError("page width too narrow");
+    this.store = options.columns > 1 && !options.merge && !options.across;
+    this.lineNumber = options.startNumber;
+    lifecycle.cleanup(async () => {
+      this.budget.retain(-this.pageRetained - this.rendered.length * 2);
+      this.pageRetained = 0;
+      this.rendered = "";
+      this.columns = [];
+    });
+  }
+  options;
+  lifecycle;
+  budget;
+  body;
+  columnWidth;
+  numberWidth;
+  store;
+  columns = [];
+  lineNumber;
+  pageNumber = 1;
+  inputPosition = 0;
+  outputPosition = 0;
+  spaces = 0;
+  separators = 0;
+  padding = 0;
+  vertical = false;
+  empty = true;
+  alignEmpty = false;
+  feedOnly = false;
+  printFeed = false;
+  needHeader = false;
+  storing = false;
+  stored = "";
+  rendered = "";
+  pageRetained = 0;
+  append(value) {
+    this.budget.charge(value.length);
+    this.budget.retain(value.length * 2);
+    this.rendered += value;
+  }
+  repeat(value, count, construction = false) {
+    this.budget.admitString(value.length * count);
+    if (construction) this.budget.charge(value.length * count);
+    return value.repeat(count);
+  }
+  async flush() {
+    const text = this.rendered;
+    this.rendered = "";
+    this.budget.retain(-text.length * 2);
+    if (text) await this.lifecycle.write(text);
+  }
+  white() {
+    let position = this.outputPosition;
+    const goal = position + this.spaces;
+    this.budget.check(Math.max(0, this.spaces), this.budget.limits.maxBufferedBytes, "horizontal padding");
+    while (goal - position > 1) {
+      const next = position + this.options.outputTabWidth - position % this.options.outputTabWidth;
+      if (next > goal) break;
+      this.append(this.options.outputTab);
+      position = next;
+    }
+    if (goal > position) this.append(this.repeat(" ", goal - position));
+    this.outputPosition = goal;
+    this.spaces = 0;
+  }
+  pad(position) {
+    if (this.options.tabify) this.spaces = position - this.outputPosition;
+    else {
+      if (position > this.outputPosition) this.append(this.repeat(" ", position - this.outputPosition));
+      this.outputPosition = position;
+    }
+  }
+  separator() {
+    if (this.separators <= 0) {
+      if (this.spaces > 0) this.white();
+      return;
+    }
+    let offset = 0;
+    for (; this.separators > 0; this.separators--) {
+      while (offset < this.options.separator.length) {
+        const character = this.options.separator[offset++];
+        if (character === " ") this.spaces++;
+        else {
+          if (this.spaces > 0) this.white();
+          this.append(character);
+          this.outputPosition++;
+        }
+      }
+      if (this.spaces > 0) this.white();
+    }
+  }
+  character(character) {
+    if (this.storing) {
+      this.budget.charge(character.length);
+      this.budget.retain(character.length * 2);
+      this.pageRetained += character.length * 2;
+      this.stored += character;
+      return;
+    }
+    if (this.options.tabify) {
+      if (character === " ") {
+        this.spaces++;
+        return;
+      }
+      if (this.spaces > 0) this.white();
+      if (character >= " " && character <= "~") this.outputPosition++;
+      else if (character === "\b") this.outputPosition--;
+    }
+    this.append(character);
+  }
+  number(column) {
+    this.budget.admitString(this.options.digits);
+    const text = String(this.lineNumber++).padStart(this.options.digits, " ").slice(-this.options.digits);
+    for (const character of text) this.character(character);
+    if (this.columns.length > 1 && this.options.numberSeparator === "	") {
+      for (let count = this.numberWidth - this.options.digits; count > 0; count--) this.character(" ");
+    } else {
+      this.character(this.options.numberSeparator);
+      if (this.columns.length === 1 && this.options.numberSeparator === "	") this.outputPosition += this.options.outputTabWidth - this.outputPosition % this.options.outputTabWidth;
+    }
+    if (this.options.truncate && !this.options.merge) this.inputPosition += this.numberWidth;
+    this.budget.charge(column.numbered ? 1 : 0);
+  }
+  align(column) {
+    this.padding = column.start;
+    if (this.options.separator.length < this.padding) {
+      this.pad(this.padding - this.options.separator.length);
+      this.padding = 0;
+    }
+    if (this.options.useSeparator) this.separator();
+    if (column.numbered) this.number(column);
+  }
+  clump(byte) {
+    const character = String.fromCharCode(byte);
+    let width;
+    let text = character;
+    if (character === this.options.inputTab || byte === 9) {
+      const tab = character === this.options.inputTab ? this.options.inputTabWidth : 8;
+      width = tab - this.inputPosition % tab;
+      if (this.options.expand) text = this.repeat(" ", width, true);
+    } else if (byte < 32 || byte > 126) {
+      if (this.options.octal || this.options.control && byte >= 128) {
+        text = `\\${byte.toString(8).padStart(3, "0")}`;
+        width = 4;
+      } else if (this.options.control) {
+        text = `^${String.fromCharCode(byte ^ 64)}`;
+        width = 2;
+      } else width = byte === 8 ? -1 : 0;
+    } else width = 1;
+    if (width < 0 && this.inputPosition === 0) return "";
+    this.inputPosition = Math.max(0, this.inputPosition + width);
+    return text;
+  }
+  close(column) {
+    for (const current of this.options.merge ? [column] : this.columns) {
+      current.status = "closed";
+      if (!current.lines.length) current.remaining = 0;
+    }
+  }
+  hold(column) {
+    for (const current of this.options.merge ? [column] : this.columns) current.status = this.store ? "feed" : "held";
+    column.remaining = 0;
+  }
+  async feed(column) {
+    const next = await column.reader.get();
+    if (next !== 10) column.reader.unget(next);
+    this.hold(column);
+  }
+  async rest(column) {
+    for (; ; ) {
+      const byte = await column.reader.get();
+      if (byte === 10) return;
+      if (byte === 12) {
+        await this.feed(column);
+        if (this.options.keepFF) this.printFeed = true;
+        return;
+      }
+      if (byte < 0) {
+        this.close(column);
+        return;
+      }
+    }
+  }
+  header(date, name) {
+    const { env } = this.budget.context;
+    if (![void 0, "", "UTC", "UTC0", ":UTC", "GMT", "GMT0"].includes(env.TZ)) throw new PrError("only UTC timezones are supported for headers");
+    const ctype = env.LC_ALL || env.LC_CTYPE || env.LANG || "C";
+    if (ctype === "C.UTF-8" || ctype === "C.utf8") {
+      for (const character of name) if (character.charCodeAt(0) >= 128) throw new PrError("non-ASCII headers require the C locale");
+    }
+    this.outputPosition = 0;
+    this.pad(this.options.margin);
+    this.white();
+    const width = (text) => {
+      this.budget.charge(text.length);
+      let result = 0;
+      for (const character of text) if (character >= " " && character !== "\x7F") result++;
+      return result;
+    };
+    const page = `Page ${this.pageNumber}`;
+    const available = Math.max(0, this.options.width - width(date) - width(name) - width(page));
+    const left = Math.floor(available / 2);
+    this.budget.admitString(5 + this.options.margin + date.length + name.length + page.length + Math.max(1, left) + Math.max(1, available - left));
+    this.append(`
+
+${this.repeat(" ", this.options.margin)}${date}${this.repeat(" ", Math.max(1, left))}${name}${this.repeat(" ", Math.max(1, available - left))}${page}
+
+
+`);
+    this.needHeader = false;
+    this.outputPosition = 0;
+  }
+  async read(column, date, name) {
+    let byte = await column.reader.get();
+    if (byte === 12 && column.full) {
+      byte = await column.reader.get();
+      if (byte === 10) byte = await column.reader.get();
+    }
+    column.full = false;
+    if (byte === 12) {
+      await this.feed(column);
+      this.feedOnly = true;
+      if (this.needHeader && !this.store) {
+        this.vertical = true;
+        this.header(date, name);
+      } else if (this.options.keepFF) this.printFeed = true;
+      return;
+    }
+    if (byte < 0) {
+      this.close(column);
+      return;
+    }
+    let clump = byte === 10 ? "" : this.clump(byte);
+    if (this.options.truncate && this.inputPosition > this.columnWidth) {
+      this.inputPosition = 0;
+      await this.rest(column);
+      return;
+    }
+    if (!this.storing) {
+      this.vertical = true;
+      if (this.needHeader && !this.store) this.header(date, name);
+      if (this.options.merge && this.alignEmpty) {
+        const pending = this.separators;
+        this.separators = 0;
+        for (let index = 0; index < pending; index++) {
+          this.align(this.columns[index]);
+          this.separators++;
+        }
+        this.padding = column.start;
+        this.spaces = this.options.truncate ? this.columnWidth : 0;
+        this.alignEmpty = false;
+      }
+      if (this.options.separator.length < this.padding) {
+        this.pad(this.padding - this.options.separator.length);
+        this.padding = 0;
+      }
+      if (this.options.useSeparator) this.separator();
+    }
+    if (column.numbered) this.number(column);
+    this.empty = false;
+    if (byte === 10) return;
+    for (const character of clump) this.character(character);
+    for (; ; ) {
+      byte = await column.reader.get();
+      if (byte === 10) return;
+      if (byte === 12) {
+        await this.feed(column);
+        if (this.options.keepFF) this.printFeed = true;
+        return;
+      }
+      if (byte < 0) {
+        this.close(column);
+        return;
+      }
+      const previous = this.inputPosition;
+      clump = this.clump(byte);
+      if (this.options.truncate && this.inputPosition > this.columnWidth) {
+        this.inputPosition = previous;
+        await this.rest(column);
+        return;
+      }
+      for (const character of clump) this.character(character);
+    }
+  }
+  ready() {
+    return this.columns.some((column) => column.status === "open" || column.status === "feed" || this.store && column.remaining > 0 && column.lines.length > 0);
+  }
+  async storePage(date, name) {
+    this.budget.retain(-this.pageRetained);
+    this.pageRetained = 0;
+    const lines = [];
+    this.storing = true;
+    for (const column of this.columns) {
+      column.lines = [];
+      column.current = 0;
+    }
+    try {
+      for (const column of this.columns) {
+        for (let count = 0; count < this.body && column.status === "open"; count++) {
+          this.stored = "";
+          this.inputPosition = 0;
+          await this.read(column, date, name);
+          if (column.status === "open" || this.stored.length) {
+            this.budget.retain(32);
+            this.pageRetained += 32;
+            lines.push({ text: this.stored, end: this.inputPosition });
+          }
+        }
+      }
+    } finally {
+      this.storing = false;
+    }
+    let start = 0;
+    for (let index = 0; index < this.columns.length; index++) {
+      const column = this.columns[index];
+      const count = Math.floor(lines.length / this.columns.length) + (index < lines.length % this.columns.length ? 1 : 0);
+      column.lines = lines.slice(start, start + count);
+      column.remaining = count;
+      start += count;
+    }
+  }
+  storedLine(column, date, name) {
+    this.vertical = true;
+    if (this.needHeader) this.header(date, name);
+    if (column.status === "feed") {
+      for (const current of this.columns) current.status = "held";
+      if (this.columns[0].remaining <= 0) {
+        if (!this.options.extremities) this.vertical = false;
+        return;
+      }
+    }
+    const line = column.lines[column.current++];
+    if (!line) return;
+    if (this.options.separator.length < this.padding) {
+      this.pad(this.padding - this.options.separator.length);
+      this.padding = 0;
+    }
+    if (this.options.useSeparator) this.separator();
+    for (const character of line.text) this.character(character);
+    if (this.spaces === 0) {
+      this.outputPosition = column.start + line.end;
+      if (column.start - this.options.separator.length === this.options.margin) this.outputPosition -= this.options.separator.length;
+    }
+  }
+  async run(readers, date, name) {
+    const count = this.options.merge ? readers.length : this.options.columns;
+    for (let index = 0; index < count; index++) {
+      const start = index === 0 ? this.options.margin + this.options.separator.length : this.options.truncate ? this.options.margin + index * (this.columnWidth + this.options.separator.length) + (this.options.merge && this.options.numbered ? this.numberWidth : 0) : 0;
+      this.columns.push({
+        reader: readers[this.options.merge ? index : 0],
+        status: "open",
+        full: false,
+        numbered: this.options.numbered && (!this.options.merge || index === 0),
+        start,
+        lines: [],
+        current: 0,
+        remaining: 0
+      });
+    }
+    try {
+      await this.pages(date, name);
+    } catch (error) {
+      if (error instanceof PrReadError) await this.flush();
+      throw error;
+    }
+  }
+  async pages(date, name) {
+    for (; ; ) {
+      if (this.store) await this.storePage(date, name);
+      else for (const column of this.columns) column.remaining = column.status === "open" ? this.body : 0;
+      if (!this.ready()) return;
+      this.budget.page();
+      this.needHeader = this.options.extremities;
+      let printed = false;
+      let left = this.body * (this.options.doubleSpace ? 2 : 1);
+      while (left > 0 && this.ready()) {
+        this.outputPosition = 0;
+        this.spaces = 0;
+        this.separators = 0;
+        this.vertical = false;
+        this.alignEmpty = false;
+        this.empty = true;
+        for (const column of this.columns) {
+          this.budget.charge();
+          this.inputPosition = 0;
+          if (column.remaining > 0 || column.status === "feed") {
+            this.feedOnly = false;
+            this.padding = column.start;
+            if (this.store) this.storedLine(column, date, name);
+            else await this.read(column, date, name);
+            printed ||= this.vertical;
+            column.remaining--;
+            if (column.remaining <= 0 && !this.ready()) break;
+            if (this.options.merge && column.status !== "open") {
+              if (this.empty) this.alignEmpty = true;
+              else if (column.status === "closed" || this.feedOnly) this.align(column);
+            }
+          } else if (this.options.merge) {
+            if (this.empty) this.alignEmpty = true;
+            else this.align(column);
+          }
+          if (this.options.useSeparator) this.separators++;
+        }
+        if (this.vertical) {
+          this.append("\n");
+          left--;
+        }
+        if (!this.ready() && !this.options.extremities) {
+          await this.flush();
+          break;
+        }
+        if (this.options.doubleSpace && printed) {
+          this.append("\n");
+          left--;
+        }
+        await this.flush();
+      }
+      if (left === 0) {
+        for (const column of this.columns) if (column.status === "open") column.full = true;
+      }
+      if (printed && this.options.extremities) this.append(this.options.formFeed ? "\f" : this.repeat("\n", left + 5));
+      else if (this.options.keepFF && this.printFeed) {
+        this.append("\f");
+        this.printFeed = false;
+      }
+      await this.flush();
+      this.pageNumber++;
+      for (const column of this.columns) if (column.status === "held") column.status = "open";
+    }
+  }
+};
+
+// packages/safe-bash/src/commands/pr/command.ts
+function createPrCommand(options = {}) {
+  const limits = settings(options);
+  return { name: "pr", description: "Paginate files and print balanced or merged columns", async execute(context) {
+    const output = createOutputOperation(context, context.stdout);
+    const budget = new Budget(context, limits, output.signal);
+    let lifecycle;
+    let failure;
+    let primary;
+    let exitCode = 0;
+    try {
+      lifecycle = new Lifecycle(budget, output);
+      const parsed = parseOptions(budget.arguments(), budget);
+      if (parsed.information) {
+        await lifecycle.write(parsed.information === "version" ? "pr (virtual-bash)\n" : "Usage: pr [OPTION]... [FILE]...\nPaginate or columnate files for printing.\nOptions: -COLUMNS -h HEADER -l LENGTH -w WIDTH -t -n[SEP[DIGITS]] -m -s[SEP]\n");
+      } else {
+        const ctype = context.env.LC_ALL || context.env.LC_CTYPE || context.env.LANG || "C";
+        const timeLocale = context.env.LC_ALL || context.env.LC_TIME || context.env.LANG || "C";
+        for (const locale of [ctype, timeLocale]) if (!["C", "POSIX", "C.UTF-8", "C.utf8"].includes(locale)) throw new PrError(`unsupported locale ${quote(locale)}`);
+        let sampled;
+        const date = (reader) => {
+          let milliseconds;
+          if (reader?.stat) milliseconds = reader.stat.mtimeMs;
+          else milliseconds = sampled ??= (options.clock ?? Date.now)();
+          const value = new Date(milliseconds);
+          if (!Number.isFinite(milliseconds) || Number.isNaN(value.getTime())) throw new PrError("invalid header timestamp");
+          const year = String(value.getUTCFullYear()).padStart(4, "0");
+          const month = String(value.getUTCMonth() + 1).padStart(2, "0");
+          const day = String(value.getUTCDate()).padStart(2, "0");
+          const time = `${String(value.getUTCHours()).padStart(2, "0")}:${String(value.getUTCMinutes()).padStart(2, "0")}`;
+          if (context.env.POSIXLY_CORRECT !== void 0 && (timeLocale === "C" || timeLocale === "POSIX")) return `${["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"][value.getUTCMonth()]} ${String(value.getUTCDate()).padStart(2, " ")} ${time} ${year}`;
+          return `${year}-${month}-${day} ${time}`;
+        };
+        let stdin;
+        const open = async (name) => {
+          if (name === "-" && stdin) return stdin;
+          const reader = new Reader(name, lifecycle);
+          try {
+            await reader.open();
+          } catch (error) {
+            if (!(error instanceof FsError)) throw error;
+            exitCode = 1;
+            if (!parsed.quiet) {
+              await lifecycle.write(`pr: ${fileQuote(name)}: ${fsDetail(error)}
+`, true);
+            }
+            return void 0;
+          }
+          if (name === "-") stdin = reader;
+          return reader;
+        };
+        const names = parsed.files.length ? parsed.files : ["-"];
+        if (!parsed.files.length) parsed.merge = false;
+        const groups = parsed.merge ? [names] : names.map((name) => [name]);
+        for (const group of groups) {
+          const formatter = new Formatter({ ...parsed }, lifecycle, group.length);
+          const readers = [];
+          for (const name of group) {
+            const reader = await open(name);
+            if (reader) readers.push(reader);
+          }
+          if (!readers.length) continue;
+          const title = parsed.header ?? (parsed.merge || readers[0].name === "-" ? "" : readers[0].name);
+          await formatter.run(readers, date(parsed.merge ? void 0 : readers[0]), title);
+        }
+      }
+    } catch (error) {
+      primary = { reason: error };
+      failure = { reason: error };
+      if (!output.signal.aborted && lifecycle && error instanceof PrError) {
+        exitCode = 1;
+        try {
+          await lifecycle.write(`pr: ${publicDiagnosticMessage(error, context.onInternalError)}
+`, true);
+          if (error.usage) await lifecycle.write("Try 'pr --help' for more information.\n", true);
+          failure = void 0;
+        } catch (reporting) {
+          failure = { reason: new AggregateError([error, reporting], "pr failure reporting failed") };
+        }
+      }
+    }
+    try {
+      await output.close();
+    } catch (cleanup) {
+      const previous = failure ?? primary;
+      failure = { reason: previous ? new AggregateError([previous.reason, cleanup], "pr execution and cleanup failed") : cleanup };
+    }
+    context.signal.throwIfAborted();
+    output.signal.throwIfAborted();
+    if (failure) throw failure.reason;
+    return { exitCode };
+  } };
+}
+
+// packages/safe-bash/src/commands/pr/index.ts
+function createPrCommands(options = {}) {
+  return [createPrCommand(options)];
+}
+function prCommands(options = {}) {
+  const commands = createPrCommands(options);
+  return { name: "pr-commands", setup(host) {
+    for (const command of commands) host.commands.register(command, { replace: options.replace ?? false });
+  } };
+}
+
+export {
+  createPrCommand,
+  createPrCommands,
+  prCommands
+};
+//# sourceMappingURL=chunk-PY37EOPJ.js.map