@poe-platform/safe-bash 0.1.535 → 0.1.537

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

@@ -0,0 +1,617 @@
+import {
+  createOutputOperation
+} from "./chunk-PPVCI2F2.js";
+import {
+  FsError,
+  PublicDiagnostic,
+  getCommandArguments,
+  init_platform,
+  resolvePath,
+  shellValueByteLength,
+  shellValueBytes,
+  yieldTurn
+} from "./chunk-L2GZSOSJ.js";
+
+// packages/safe-bash/src/commands/tsort/index.ts
+init_platform();
+
+// packages/safe-bash/src/commands/tsort/command.ts
+init_platform();
+
+// packages/safe-bash/src/commands/tsort/internal.ts
+init_platform();
+function settings(options) {
+  const limits = {
+    maxArguments: 4096,
+    maxArgumentBytes: 65536,
+    maxInputBytes: 33554432,
+    maxTokenBytes: 1048576,
+    maxTokens: 2097152,
+    maxNodes: 131072,
+    maxEdges: 1048576,
+    maxBufferedBytes: 33554432,
+    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 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) {
+  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 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;
+  }
+  context;
+  limits;
+  signal;
+  work = 0;
+  checkpoint = 0;
+  retained = 0;
+  input = 0;
+  output = 0;
+  diagnostics = 0;
+  check(value, maximum, label) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > maximum) throw new TsortError(`${label} limit exceeded`);
+  }
+  charge(amount = 1) {
+    this.signal.throwIfAborted();
+    this.check(this.work + amount, this.limits.maxWork, "work");
+    this.work += amount;
+  }
+  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;
+  }
+  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/src/commands/tsort/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 TsortError("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, "tsort cleanup failed");
+    });
+  }
+  async write(value, diagnostic = false) {
+    this.budget.emitted(value.length, diagnostic);
+    await this.operation(async () => {
+      if (!diagnostic) this.budget.retain(value.length * 3);
+      try {
+        const sink = diagnostic ? this.budget.context.stderr : this.budget.context.stdout;
+        await (sink.ownedOutput ?? sink).write(bytes(value));
+      } finally {
+        if (!diagnostic) this.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;
+  ended = false;
+  empties = 0;
+  snapshotBytes = 0;
+  releaseSnapshot = () => {
+    this.lifecycle.budget.retain(-this.snapshotBytes);
+    this.snapshotBytes = 0;
+  };
+  async open() {
+    const { budget } = this.lifecycle;
+    const { fs, stdin } = budget.context;
+    try {
+      await this.lifecycle.operation(async () => {
+        let source;
+        if (this.name === "-") source = stdin;
+        else {
+          const path = resolvePath(budget.context.cwd, pathText(this.name));
+          const stat = await fs.stat(path, { signal: budget.signal });
+          budget.signal.throwIfAborted();
+          if (stat.type === "directory") {
+            this.ended = true;
+            return;
+          }
+          if (stat.type !== "file" && stat.type !== "character") throw new FsError("ENOTSUP", { path });
+          const capabilities = await fs.capabilitiesFor?.(path, { signal: budget.signal }) ?? fs.capabilities;
+          budget.signal.throwIfAborted();
+          if (fs.readStream && capabilities.streamingRead !== false) source = fs.readStream(path, { signal: budget.signal, chunkSize: 16384 });
+          else {
+            const maximum = Math.min(budget.limits.maxInputBytes, Math.floor(budget.limits.maxBufferedBytes / 2));
+            budget.check(stat.size, maximum, "buffered input bytes");
+            budget.retain(maximum);
+            this.snapshotBytes = maximum;
+            const content = await fs.readFile(path, { signal: budget.signal, 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 - maximum);
+            this.snapshotBytes = content.length;
+            const { releaseSnapshot } = this;
+            source = { async *[Symbol.asyncIterator]() {
+              try {
+                yield content;
+              } finally {
+                releaseSnapshot();
+              }
+            } };
+          }
+        }
+        this.iterator = source[Symbol.asyncIterator]();
+      });
+    } catch (error) {
+      if (error instanceof FsError) throw new TsortError(`${fileQuote(this.name)}: ${fsDetail(error)}`);
+      throw error;
+    }
+  }
+  async get() {
+    const { budget } = this.lifecycle;
+    budget.charge();
+    await budget.checkpointWork();
+    while (this.offset === this.chunk.length) {
+      if (this.ended) return -1;
+      let next;
+      try {
+        next = await this.lifecycle.operation(() => this.iterator.next());
+      } 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/src/commands/tsort/graph.ts
+init_platform();
+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 value = await reader.get();
+    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`);
+  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++];
+        await budget.checkpointWork();
+      }
+    }
+    [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;
+      }
+      await budget.checkpointWork();
+    }
+    while (head) {
+      const node = head;
+      budget.check(node.name.length + 1, budget.limits.maxOutputBytes, "output bytes");
+      await lifecycle.write(`${node.name}
+`);
+      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;
+        }
+        await budget.checkpointWork();
+      }
+      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();
+        await budget.checkpointWork();
+        if (!node.count) continue;
+        if (!loop) {
+          loop = node;
+          continue;
+        }
+        let previous;
+        for (let edge = node.top; edge; edge = edge.next) {
+          budget.charge();
+          await budget.checkpointWork();
+          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;
+                await budget.checkpointWork();
+              }
+              found = true;
+            } else {
+              node.link = loop;
+              loop = node;
+            }
+            break;
+          }
+          previous = edge;
+        }
+        if (found) break;
+      }
+    } while (loop);
+  }
+  return status;
+}
+
+// packages/safe-bash/src/commands/tsort/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");
+      } 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);
+      }
+    } 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/src/commands/tsort/index.ts
+function createTsortCommands(options = {}) {
+  return [createTsortCommand(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 {
+  createTsortCommand,
+  createTsortCommands,
+  tsortCommands
+};
+//# sourceMappingURL=chunk-JWUT4LBW.js.map