@poe-platform/safe-bash 0.1.756 → 0.1.757

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

@@ -1,739 +0,0 @@
-import {
-  builtInDirectContextExecutors
-} from "./chunk-ISCZG7WA.js";
-import {
-  init_platform
-} from "./chunk-ZG7GWQ5P.js";
-
-// packages/safe-bash/src/commands/tsort/index.ts
-init_platform();
-
-// packages/safe-bash-command-tsort/src/index.ts
-init_platform();
-
-// packages/safe-bash-command-tsort/src/command.ts
-init_platform();
-import { createOutputOperation } from "../../safe-bash-contracts/output.js";
-
-// packages/safe-bash-command-tsort/src/internal.ts
-init_platform();
-import { getCommandArguments } from "../../safe-bash-contracts/index.js";
-import { shellValueByteLength, shellValueBytes } from "../../safe-bash-contracts/value.js";
-import { hasYieldCheckpoint, monotonicNow, runYieldCheckpoint, yieldTurn } from "../../safe-bash-contracts/yield.js";
-import { PublicDiagnostic } from "../../safe-bash-contracts/diagnostics.js";
-function settings(options) {
-  const limits = {
-    maxArguments: Infinity,
-    maxArgumentBytes: Infinity,
-    maxInputBytes: Infinity,
-    maxTokenBytes: Infinity,
-    maxTokens: Infinity,
-    maxNodes: Infinity,
-    maxEdges: Infinity,
-    maxBufferedBytes: Infinity,
-    maxOutputBytes: Infinity,
-    maxDiagnosticBytes: Infinity,
-    maxWork: Infinity,
-    maxEmptyChunks: Infinity,
-    ...options.limits
-  };
-  for (const [name, value] of Object.entries(limits)) {
-    if (value !== Infinity && (!Number.isSafeInteger(value) || value < 1)) throw new RangeError(`Invalid tsort limit: ${name}`);
-  }
-  return Object.freeze(limits);
-}
-var TsortError = class extends PublicDiagnostic {
-  constructor(message, usage = false) {
-    super(message);
-    this.usage = usage;
-  }
-  usage;
-};
-function raw(value) {
-  let result = "";
-  for (let offset = 0; offset < value.length; offset += 4096) result += String.fromCharCode(...value.subarray(offset, offset + 4096));
-  return result;
-}
-function bytes(value) {
-  const len = value.length;
-  const out = new Uint8Array(len);
-  for (let i = 0; i < len; i++) out[i] = value.charCodeAt(i);
-  return out;
-}
-function pathText(value) {
-  try {
-    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes(value));
-  } catch {
-    throw new TsortError("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;
-  let 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("'\\''")}'`;
-  }
-  const escapes = { "\x07": "\\a", "\b": "\\b", "\f": "\\f", "\n": "\\n", "\r": "\\r", "	": "\\t", "\v": "\\v" };
-  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 += escapes[character] ?? `\\${code.toString(8).padStart(3, "0")}`;
-    } 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;
-    this.signalAborted = signal.aborted;
-    this.pollSignal = Object.prototype.hasOwnProperty.call(signal, "aborted");
-    if (!this.signalAborted && !this.pollSignal) {
-      signal.addEventListener("abort", () => {
-        this.signalAborted = true;
-      }, { once: true });
-    }
-  }
-  context;
-  limits;
-  signal;
-  work = 0;
-  checkpoint = 0;
-  checkpointCount = 0;
-  lastYield = monotonicNow();
-  retained = 0;
-  input = 0;
-  output = 0;
-  diagnostics = 0;
-  signalAborted;
-  pollSignal;
-  assertSignalOpen() {
-    if (this.pollSignal ? this.signal.aborted : this.signalAborted) this.signal.throwIfAborted();
-  }
-  check(value, maximum, label) {
-    if (value > maximum || value < 0 || (value | 0) !== value && !Number.isSafeInteger(value)) throw new TsortError(`${label} limit exceeded`);
-  }
-  charge(amount = 1) {
-    this.assertSignalOpen();
-    this.check(this.work + amount, this.limits.maxWork, "work");
-    this.work += amount;
-  }
-  checkpointWork() {
-    this.assertSignalOpen();
-    if (this.work - this.checkpoint < 4096) return;
-    this.checkpoint = this.work;
-    const count = ++this.checkpointCount;
-    const now = monotonicNow();
-    if (count === 1 || now - this.lastYield >= 16 || hasYieldCheckpoint(this.signal)) {
-      this.lastYield = now;
-      return yieldTurn(this.signal).then(() => {
-        this.lastYield = monotonicNow();
-      });
-    }
-    return runYieldCheckpoint(this.signal);
-  }
-  retain(amount) {
-    this.check(this.retained + amount, this.limits.maxBufferedBytes, "buffered bytes");
-    this.retained += amount;
-  }
-  inputBytes(amount) {
-    this.check(this.input + amount, this.limits.maxInputBytes, "input bytes");
-    this.input += amount;
-  }
-  emitted(amount, diagnostic) {
-    if (diagnostic) {
-      this.check(this.diagnostics + amount, this.limits.maxDiagnosticBytes, "diagnostic bytes");
-      this.diagnostics += amount;
-    } else {
-      this.check(this.output + amount, this.limits.maxOutputBytes, "output bytes");
-      this.output += amount;
-      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 TsortError("arguments must contain well-formed Unicode");
-        } else if (unit >= 56320 && unit <= 57343) throw new TsortError("arguments must contain well-formed Unicode");
-      }
-    }
-    total = 0;
-    const values = this.context.argumentValues === void 0 ? this.context.args : getCommandArguments(this.context).values;
-    for (const argument of values) {
-      total += shellValueByteLength(argument);
-      this.check(total, this.limits.maxArgumentBytes, "argument bytes");
-    }
-    this.charge(total);
-    this.retain(total * 8 + this.context.args.length * 64 + 128);
-    total = 0;
-    return getCommandArguments(this.context).values.map((argument) => {
-      total += shellValueByteLength(argument);
-      this.check(total, this.limits.maxArgumentBytes, "argument bytes");
-      this.charge(shellValueByteLength(argument));
-      const value = shellValueBytes(argument);
-      if (value.includes(0)) throw new TsortError("NUL is not supported in arguments");
-      return raw(value);
-    });
-  }
-};
-
-// packages/safe-bash-command-tsort/src/io.ts
-init_platform();
-import { FsError, resolvePath } from "../../safe-bash-contracts/index.js";
-var Lifecycle = class {
-  constructor(budget, output) {
-    this.budget = budget;
-    output.registerCleanup(() => this.close());
-  }
-  budget;
-  pending = /* @__PURE__ */ new Set();
-  cleanups = [];
-  closing;
-  pendingStdout = "";
-  cleanup(action) {
-    this.assertOpen();
-    this.cleanups.push(action);
-  }
-  assertOpen() {
-    this.budget.assertSignalOpen();
-    if (this.closing) throw new TsortError("command is closed");
-  }
-  async flush() {
-    if (!this.pendingStdout.length) return;
-    const chunk = this.pendingStdout;
-    this.pendingStdout = "";
-    try {
-      await this.operation(async () => {
-        const sink = this.budget.context.stdout;
-        this.assertOpen();
-        const destination = sink.ownedOutput ?? sink;
-        this.assertOpen();
-        const write = destination.write;
-        this.assertOpen();
-        await Reflect.apply(write, destination, [bytes(chunk)]);
-      }, true);
-    } finally {
-      this.budget.retain(-chunk.length * 3);
-    }
-  }
-  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, "tsort cleanup failed");
-    });
-  }
-  write(value, diagnostic = false) {
-    if (!diagnostic) {
-      this.budget.emitted(value.length, false);
-      this.assertOpen();
-      if (!value.length) return;
-      this.budget.retain(value.length * 3);
-      this.pendingStdout += value;
-      if (Number.isFinite(this.budget.limits.maxBufferedBytes) || this.pendingStdout.length >= 16384) return this.flush();
-      return;
-    }
-    return this.writeDiagnostic(value);
-  }
-  async writeDiagnostic(value) {
-    const diagnostic = true;
-    if (this.pendingStdout.length) await this.flush();
-    this.budget.emitted(value.length, true);
-    await this.operation(async () => {
-      const sink = this.budget.context.stderr;
-      this.assertOpen();
-      const destination = sink.ownedOutput ?? sink;
-      this.assertOpen();
-      const write = destination.write;
-      this.assertOpen();
-      await Reflect.apply(write, destination, [bytes(value)]);
-    }, 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;
-  ended = false;
-  empties = 0;
-  snapshotBytes = 0;
-  releaseSnapshot = () => {
-    this.lifecycle.budget.retain(-this.snapshotBytes);
-    this.snapshotBytes = 0;
-  };
-  async open() {
-    const { budget } = this.lifecycle;
-    try {
-      await this.lifecycle.operation(async () => {
-        let source;
-        let needsAcquisitionCleanup = false;
-        if (this.name === "-") source = budget.context.stdin;
-        else {
-          const path = resolvePath(budget.context.cwd, pathText(this.name));
-          const fs = budget.context.fs;
-          this.lifecycle.assertOpen();
-          const statMethod = fs.stat;
-          this.lifecycle.assertOpen();
-          const stat = await Reflect.apply(statMethod, fs, [path, { signal: budget.signal }]);
-          this.lifecycle.assertOpen();
-          if (stat.type === "directory") {
-            this.ended = true;
-            return;
-          }
-          if (stat.type !== "file" && stat.type !== "character") throw new FsError("ENOTSUP", { path });
-          const capabilitiesFor = fs.capabilitiesFor;
-          this.lifecycle.assertOpen();
-          const selected = capabilitiesFor ? await Reflect.apply(capabilitiesFor, fs, [path, { signal: budget.signal }]) : void 0;
-          this.lifecycle.assertOpen();
-          const capabilities = selected ?? fs.capabilities;
-          this.lifecycle.assertOpen();
-          const readStream = fs.readStream;
-          this.lifecycle.assertOpen();
-          const streamingRead = readStream && capabilities.streamingRead !== false;
-          this.lifecycle.assertOpen();
-          if (readStream && streamingRead) {
-            source = Reflect.apply(readStream, fs, [path, { signal: budget.signal, chunkSize: 16384 }]);
-            needsAcquisitionCleanup = budget.signal.aborted;
-          } else {
-            const maximum = Math.min(budget.limits.maxInputBytes, Math.floor(budget.limits.maxBufferedBytes / 2));
-            budget.check(stat.size, maximum, "buffered input bytes");
-            const reserved = Number.isFinite(maximum) ? maximum : 0;
-            budget.retain(reserved);
-            this.snapshotBytes = reserved;
-            const readFile = fs.readFile;
-            this.lifecycle.assertOpen();
-            const content = await Reflect.apply(readFile, fs, [path, { signal: budget.signal, ...Number.isFinite(maximum) ? { maxBytes: maximum } : {} }]);
-            if (!(content instanceof Uint8Array)) throw new TypeError("tsort input requires bytes");
-            budget.check(content.length, maximum, "buffered input bytes");
-            budget.retain(content.length - reserved);
-            this.snapshotBytes = content.length;
-            const { releaseSnapshot } = this;
-            source = { async *[Symbol.asyncIterator]() {
-              try {
-                yield content;
-              } finally {
-                releaseSnapshot();
-              }
-            } };
-          }
-        }
-        if (!needsAcquisitionCleanup) this.lifecycle.assertOpen();
-        const factory = source[Symbol.asyncIterator];
-        if (!needsAcquisitionCleanup) this.lifecycle.assertOpen();
-        this.iterator = Reflect.apply(factory, source, []);
-      });
-    } catch (error) {
-      if (error instanceof FsError) throw new TsortError(`${fileQuote(this.name)}: ${fsDetail(error)}`);
-      throw error;
-    }
-  }
-  get() {
-    const { budget } = this.lifecycle;
-    budget.charge();
-    const cp = budget.checkpointWork();
-    if (!cp && this.offset < this.chunk.length) return this.chunk[this.offset++];
-    return this.getSlow(cp);
-  }
-  async getSlow(cp) {
-    const { budget } = this.lifecycle;
-    if (cp) await cp;
-    while (this.offset === this.chunk.length) {
-      if (this.ended) return -1;
-      let next;
-      try {
-        next = await this.lifecycle.operation(() => {
-          const iterator = this.iterator;
-          const advance = iterator.next;
-          this.lifecycle.assertOpen();
-          return Reflect.apply(advance, iterator, []);
-        });
-      } catch (error) {
-        if (error instanceof FsError) throw new TsortError(`${fileQuote(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;
-        return -1;
-      }
-      if (!(next.value instanceof Uint8Array)) throw new TypeError("tsort input requires bytes");
-      budget.inputBytes(next.value.length);
-      budget.charge(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");
-    }
-    return this.chunk[this.offset++];
-  }
-};
-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-command-tsort/src/graph.ts
-init_platform();
-import { yieldTurn as yieldTurn2 } from "../../safe-bash-contracts/yield.js";
-async function sort(reader, lifecycle) {
-  const { budget } = lifecycle;
-  const nodes = /* @__PURE__ */ new Map();
-  let tokens = 0, edges = 0, length = 0, nameLength = 0;
-  let nul = false;
-  let token = new Uint8Array();
-  let predecessor;
-  const admitToken = () => {
-    budget.check(++tokens, budget.limits.maxTokens, "tokens");
-    budget.charge(nameLength + 1);
-    budget.retain(nameLength * 4);
-    const name = raw(token.subarray(0, nameLength));
-    let node = nodes.get(name);
-    if (!node) {
-      budget.check(nodes.size + 1, budget.limits.maxNodes, "nodes");
-      budget.retain(160);
-      node = { name, count: 0, printed: false, top: void 0, link: void 0 };
-      nodes.set(name, node);
-    } else budget.retain(-nameLength * 4);
-    if (!predecessor) predecessor = node;
-    else {
-      if (predecessor !== node) {
-        budget.check(++edges, budget.limits.maxEdges, "edges");
-        budget.retain(48);
-        predecessor.top = { target: node, next: predecessor.top };
-        node.count++;
-      }
-      predecessor = void 0;
-    }
-    length = 0;
-    nameLength = 0;
-    nul = false;
-  };
-  for (; ; ) {
-    const r = reader.get();
-    const value = typeof r === "number" ? r : await r;
-    if (value < 0 || value === 32 || value === 9 || value === 10) {
-      if (length) admitToken();
-      if (value < 0) break;
-    } else {
-      budget.check(++length, budget.limits.maxTokenBytes, "token bytes");
-      if (value === 0) nul = true;
-      if (!nul) {
-        if (nameLength === token.length) {
-          const capacity = Math.min(budget.limits.maxTokenBytes, Math.max(64, token.length * 2));
-          budget.retain(capacity);
-          budget.charge(token.length);
-          const grown = new Uint8Array(capacity);
-          grown.set(token);
-          budget.retain(-token.length);
-          token = grown;
-        }
-        token[nameLength++] = value;
-      }
-    }
-  }
-  budget.retain(-token.length);
-  token = new Uint8Array();
-  if (predecessor) throw new TsortError(`${fileQuote(reader.name)}: input contains an odd number of tokens`);
-  await yieldTurn2(budget.signal);
-  budget.retain(nodes.size * 16);
-  let ordered = [...nodes.values()];
-  let scratch = new Array(ordered.length);
-  for (let width = 1; width < ordered.length; width *= 2) {
-    for (let start = 0; start < ordered.length; start += width * 2) {
-      const middle = Math.min(start + width, ordered.length), end = Math.min(start + width * 2, ordered.length);
-      let left = start, right = middle;
-      for (let offset = start; offset < end; offset++) {
-        budget.charge();
-        let useLeft = right === end;
-        if (left < middle && right < end) {
-          budget.charge(Math.min(ordered[left].name.length, ordered[right].name.length) + 1);
-          useLeft = ordered[left].name < ordered[right].name;
-        }
-        scratch[offset] = left < middle && useLeft ? ordered[left++] : ordered[right++];
-        {
-          const cp = budget.checkpointWork();
-          if (cp) await cp;
-        }
-      }
-    }
-    [ordered, scratch] = [scratch, ordered];
-  }
-  let remaining = ordered.length, status = 0;
-  while (remaining) {
-    let head, tail;
-    for (const node of ordered) {
-      budget.charge();
-      if (!node.printed && !node.count) {
-        if (tail) tail.link = node;
-        else head = node;
-        tail = node;
-        node.link = void 0;
-      }
-      {
-        const cp = budget.checkpointWork();
-        if (cp) await cp;
-      }
-    }
-    while (head) {
-      const node = head;
-      budget.check(node.name.length + 1, budget.limits.maxOutputBytes, "output bytes");
-      {
-        const w = lifecycle.write(`${node.name}
-`);
-        if (w) await w;
-      }
-      node.printed = true;
-      remaining--;
-      for (let edge = node.top; edge; edge = edge.next) {
-        budget.charge();
-        if (!--edge.target.count) {
-          tail.link = edge.target;
-          tail = edge.target;
-          tail.link = void 0;
-        }
-        {
-          const cp = budget.checkpointWork();
-          if (cp) await cp;
-        }
-      }
-      head = node.link;
-      node.link = void 0;
-    }
-    if (!remaining) break;
-    status = 1;
-    await lifecycle.write(`tsort: ${fileQuote(reader.name)}: input contains a loop:
-`, true);
-    let loop;
-    do {
-      let found = false;
-      for (const node of ordered) {
-        budget.charge();
-        {
-          const cp = budget.checkpointWork();
-          if (cp) await cp;
-        }
-        if (!node.count) continue;
-        if (!loop) {
-          loop = node;
-          continue;
-        }
-        let previous;
-        for (let edge = node.top; edge; edge = edge.next) {
-          budget.charge();
-          {
-            const cp = budget.checkpointWork();
-            if (cp) await cp;
-          }
-          if (edge.target === loop) {
-            if (node.link) {
-              while (loop) {
-                budget.charge();
-                const next = loop.link;
-                await lifecycle.write(`tsort: ${loop.name}
-`, true);
-                if (loop === node) {
-                  edge.target.count--;
-                  if (previous) previous.next = edge.next;
-                  else node.top = edge.next;
-                  break;
-                }
-                loop.link = void 0;
-                loop = next;
-              }
-              while (loop) {
-                budget.charge();
-                const next = loop.link;
-                loop.link = void 0;
-                loop = next;
-                {
-                  const cp = budget.checkpointWork();
-                  if (cp) await cp;
-                }
-              }
-              found = true;
-            } else {
-              node.link = loop;
-              loop = node;
-            }
-            break;
-          }
-          previous = edge;
-        }
-        if (found) break;
-      }
-    } while (loop);
-  }
-  await lifecycle.flush();
-  return status;
-}
-
-// packages/safe-bash-command-tsort/src/command.ts
-function createTsortCommand(options = {}) {
-  const limits = settings(options);
-  return { name: "tsort", description: "Topologically sort pairs of byte-valued node names", 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 args = budget.arguments();
-      const lone = args.length === 1 ? args[0] : "";
-      if (lone.length > 2 && ("--help".startsWith(lone) || "--version".startsWith(lone))) {
-        await lifecycle.write("--help".startsWith(lone) ? "Usage: tsort [OPTION] [FILE]\nWrite a topological ordering of whitespace-separated node pairs.\nWith no FILE, or FILE -, read standard input.\nOptions: --help --version\n" : "tsort (virtual-bash)\n");
-        await lifecycle.flush();
-      } else {
-        let optionsEnded = false;
-        const files = [];
-        for (const argument of args) {
-          if (!optionsEnded && argument === "--") {
-            optionsEnded = true;
-            continue;
-          }
-          if (!optionsEnded && argument.startsWith("--")) throw new TsortError(`unrecognized option '${argument}'`, true);
-          if (!optionsEnded && argument.length > 1 && argument.startsWith("-")) throw new TsortError(`invalid option -- '${argument[1]}'`, true);
-          files.push(argument);
-          if (context.env.POSIXLY_CORRECT !== void 0) optionsEnded = true;
-        }
-        if (files.length > 1) throw new TsortError(`extra operand ${quote(files[1])}`, true);
-        const reader = new Reader(files[0] ?? "-", lifecycle);
-        await reader.open();
-        exitCode = await sort(reader, lifecycle);
-        await lifecycle.flush();
-      }
-    } catch (error) {
-      primary = { reason: error };
-      if (error instanceof TsortError && !output.signal.aborted && lifecycle) {
-        exitCode = 1;
-        try {
-          await lifecycle.write(`tsort: ${error.message}
-${error.usage ? "Try 'tsort --help' for more information.\n" : ""}`, true);
-        } catch (reporting) {
-          failure = { reason: new AggregateError([error, reporting], "tsort failure reporting failed") };
-        }
-      } else failure = { reason: error };
-    }
-    try {
-      await output.close();
-    } catch (cleanup) {
-      const previous = failure ?? primary;
-      failure = { reason: previous ? new AggregateError([previous.reason, cleanup], "tsort execution and cleanup failed") : cleanup };
-    }
-    context.signal.throwIfAborted();
-    output.signal.throwIfAborted();
-    if (failure) throw failure.reason;
-    return { exitCode };
-  } };
-}
-
-// packages/safe-bash-command-tsort/src/index.ts
-function createTsortCommand2(options = {}) {
-  const def = createTsortCommand(options);
-  builtInDirectContextExecutors.add(def.execute);
-  return def;
-}
-function createTsortCommands(options = {}) {
-  return [createTsortCommand2(options)];
-}
-function tsortCommands(options = {}) {
-  const commands = createTsortCommands(options);
-  return { name: "tsort-commands", setup(host) {
-    for (const command of commands) host.commands.register(command, { replace: options.replace ?? false });
-  } };
-}
-
-export {
-  createTsortCommand2 as createTsortCommand,
-  createTsortCommands,
-  tsortCommands
-};
-//# sourceMappingURL=chunk-UWLYRWT4.js.map