@poe-platform/safe-bash 0.1.756 → 0.1.758

package/dist/safe-bash/chunks/chunk-4E3SGG37.js

@@ -1,876 +0,0 @@
-import {
-  builtInDirectContextExecutors
-} from "./chunk-ISCZG7WA.js";
-import {
-  init_platform
-} from "./chunk-ZG7GWQ5P.js";
-
-// packages/safe-bash/src/commands/hexdump/index.ts
-init_platform();
-
-// packages/safe-bash-command-hexdump/src/index.ts
-init_platform();
-
-// packages/safe-bash-command-hexdump/src/command.ts
-init_platform();
-import { FsError as FsError2 } from "../../safe-bash-contracts/index.js";
-import { createOutputOperation } from "../../safe-bash-contracts/output.js";
-import { outputFailure } from "../../safe-bash-contracts/io.js";
-
-// packages/safe-bash-command-hexdump/src/internal.ts
-init_platform();
-import { getCommandArguments } from "../../safe-bash-contracts/index.js";
-import { shellValueByteLength, shellValueBytes } from "../../safe-bash-contracts/value.js";
-import { yieldTurn } from "../../safe-bash-contracts/yield.js";
-import { PublicDiagnostic } from "../../safe-bash-contracts/diagnostics.js";
-function settings(options) {
-  if (options.dialect !== void 0 && options.dialect !== "bsd" && options.dialect !== "util-linux") throw new RangeError("Invalid hexdump dialect");
-  const limits = {
-    maxArguments: Infinity,
-    maxArgumentBytes: Infinity,
-    maxInputBytes: Infinity,
-    maxBufferedBytes: Infinity,
-    maxOutputBytes: Infinity,
-    maxDiagnosticBytes: Infinity,
-    maxFormats: Infinity,
-    maxWork: Infinity,
-    maxEmptyChunks: Infinity,
-    ...options.limits
-  };
-  for (const [name, value] of Object.entries(options.limits ?? {})) {
-    if (value !== Infinity && (!Number.isSafeInteger(value) || value < 1)) throw new RangeError(`Invalid hexdump limit: ${name}`);
-  }
-  return Object.freeze(limits);
-}
-var HexdumpError = class extends PublicDiagnostic {
-  constructor(message, bare = false) {
-    super(message);
-    this.bare = bare;
-  }
-  bare;
-};
-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 out = new Uint8Array(value.length);
-  for (let i = 0; i < value.length; 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 HexdumpError("filesystem paths must be valid UTF-8");
-  }
-}
-var Budget = class {
-  constructor(context, limits, signal, callerSignal, admission) {
-    this.context = context;
-    this.limits = limits;
-    this.signal = signal;
-    this.callerSignal = callerSignal;
-    this.admission = admission;
-    this.pollSignal = typeof signal.addEventListener !== "function" || Object.prototype.hasOwnProperty.call(signal, "aborted");
-    if (signal.aborted) this.aborted = true;
-    else if (!this.pollSignal) signal.addEventListener("abort", () => {
-      this.aborted = true;
-    }, { once: true });
-  }
-  context;
-  limits;
-  signal;
-  callerSignal;
-  admission;
-  work = 0;
-  checkpoint = 0;
-  retained = 0;
-  input = 0;
-  output = 0;
-  diagnostics = 0;
-  aborted = false;
-  pollSignal;
-  assertOpen() {
-    if (this.aborted || this.pollSignal && this.signal.aborted) {
-      this.aborted = true;
-      this.signal.throwIfAborted();
-    }
-    if (this.admission.closed) throw new HexdumpError("command is closed");
-  }
-  check(value, maximum, label) {
-    if (!Number.isSafeInteger(value) || value < 0 || value > maximum) throw new HexdumpError(`${label} limit exceeded`);
-  }
-  charge(amount = 1) {
-    this.assertOpen();
-    this.check(this.work + amount, this.limits.maxWork, "work");
-    this.work += amount;
-  }
-  canChargeWithoutCheckpoint(amount) {
-    if (this.aborted || this.pollSignal && this.signal.aborted || this.admission.closed) return false;
-    if (this.work + amount > this.limits.maxWork) return false;
-    return this.work + amount - this.checkpoint < 4096;
-  }
-  checkpointWork() {
-    this.assertOpen();
-    if (this.work - this.checkpoint < 4096) return;
-    this.checkpoint = this.work;
-    return yieldTurn(this.callerSignal).then(() => {
-      this.assertOpen();
-    });
-  }
-  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.charge(amount);
-      this.output += amount;
-    }
-  }
-  arguments() {
-    this.assertOpen();
-    const args = this.context.args;
-    this.assertOpen();
-    const count = args.length;
-    this.assertOpen();
-    this.check(count, this.limits.maxArguments, "argument count");
-    const argumentValues = this.context.argumentValues;
-    this.assertOpen();
-    const carrier = argumentValues === void 0 ? void 0 : getCommandArguments({ args, argumentValues });
-    this.assertOpen();
-    this.retain(count * 64 + 128);
-    const snapshot = [];
-    let units = 0, total = 0;
-    for (let index = 0; index < count; index++) {
-      const argument = args[index];
-      this.assertOpen();
-      if (typeof argument !== "string") throw new HexdumpError("arguments must be strings");
-      units += argument.length;
-      this.check(units, this.limits.maxArgumentBytes, "argument bytes");
-      this.charge(argument.length + 1);
-      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 HexdumpError("arguments must contain well-formed Unicode");
-        } else if (unit >= 56320 && unit <= 57343) throw new HexdumpError("arguments must contain well-formed Unicode");
-      }
-      const size = shellValueByteLength(carrier ? carrier.values[index] : argument);
-      total += size;
-      this.check(total, this.limits.maxArgumentBytes, "argument bytes");
-      this.charge(size);
-      this.retain(size * 8);
-      snapshot.push(argument);
-    }
-    return (carrier ?? getCommandArguments({ args: snapshot })).values.map((argument) => {
-      this.charge(shellValueByteLength(argument));
-      const value = shellValueBytes(argument);
-      if (value.includes(0)) throw new HexdumpError("NUL is not supported in arguments");
-      return raw(value);
-    });
-  }
-};
-
-// packages/safe-bash-command-hexdump/src/io.ts
-init_platform();
-import { FsError, resolvePath } from "../../safe-bash-contracts/index.js";
-var typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
-var viewBuffer = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer").get;
-var viewOffset = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteOffset").get;
-var viewLength = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength").get;
-var Lifecycle = class {
-  constructor(budget, output, stdout, caller) {
-    this.budget = budget;
-    this.stdout = stdout;
-    this.caller = caller;
-    output.registerCleanup(() => this.close());
-  }
-  budget;
-  stdout;
-  caller;
-  pending = /* @__PURE__ */ new Set();
-  cleanups = /* @__PURE__ */ new Set();
-  closing;
-  diagnostic;
-  diagnosticCancellation;
-  cleanup(action) {
-    this.assertOpen();
-    this.cleanups.add(action);
-  }
-  forget(action) {
-    this.cleanups.delete(action);
-  }
-  assertOpen() {
-    this.budget.assertOpen();
-    if (this.closing) throw new HexdumpError("command is closed");
-  }
-  assertDiagnosticOpen() {
-    this.caller.throwIfAborted();
-    const consumer = this.diagnostic?.consumer;
-    if (consumer?.aborted) {
-      this.diagnosticCancellation = { reason: consumer.reason };
-      consumer.throwIfAborted();
-    }
-  }
-  async operation(action, diagnostic = false) {
-    if (diagnostic) this.assertDiagnosticOpen();
-    else this.assertOpen();
-    if (this.closing || this.budget.admission.closed) throw new HexdumpError("command is closed");
-    if (!diagnostic) this.budget.charge();
-    const pending = Promise.resolve().then(() => {
-      if (diagnostic) this.assertDiagnosticOpen();
-      else this.assertOpen();
-      return action();
-    });
-    this.pending.add(pending);
-    try {
-      const value = await pending;
-      if (diagnostic) this.assertDiagnosticOpen();
-      else 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, "hexdump 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 {
-        let destination;
-        if (diagnostic) {
-          if (!this.diagnostic) {
-            const sink = this.budget.context.stderr;
-            this.assertDiagnosticOpen();
-            const capability = sink.ownedOutput;
-            this.assertDiagnosticOpen();
-            const consumer = capability?.consumerClosed;
-            this.diagnostic = { destination: capability ?? sink, consumer };
-          }
-          this.assertDiagnosticOpen();
-          destination = this.diagnostic.destination;
-        } else {
-          destination = this.stdout;
-          this.assertOpen();
-        }
-        const write = destination.write;
-        if (diagnostic) this.assertDiagnosticOpen();
-        else this.assertOpen();
-        await Reflect.apply(write, destination, [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.budget.retain(256);
-    lifecycle.cleanup(this.close);
-  }
-  name;
-  lifecycle;
-  iterator;
-  chunk = new Uint8Array();
-  offset = 0;
-  ended = false;
-  empties = 0;
-  snapshotBytes = 0;
-  closed;
-  close = () => this.closed ??= Promise.resolve().then(async () => {
-    try {
-      if (!this.ended) await this.iterator?.return?.();
-    } finally {
-      this.iterator = void 0;
-      this.releaseSnapshot();
-      this.lifecycle.budget.retain(-this.chunk.length - 256);
-      this.chunk = new Uint8Array();
-      this.lifecycle.forget(this.close);
-    }
-  });
-  releaseSnapshot = () => {
-    this.lifecycle.budget.retain(-this.snapshotBytes);
-    this.snapshotBytes = 0;
-  };
-  async open() {
-    const { budget } = this.lifecycle;
-    await this.lifecycle.operation(async () => {
-      let source;
-      let needsAcquisitionCleanup = false;
-      if (this.name === void 0) source = budget.context.stdin;
-      else {
-        if (this.name === "") throw new FsError("ENOENT", { path: this.name });
-        const cwd = budget.context.cwd;
-        this.lifecycle.assertOpen();
-        const path = resolvePath(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();
-        const type = stat.type;
-        this.lifecycle.assertOpen();
-        if (this.name.endsWith("/") && type !== "directory") throw new FsError("ENOTDIR", { path });
-        if (type === "directory") throw new FsError("EISDIR", { path });
-        if (type !== "file" && 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 || budget.admission.closed;
-        } else {
-          const maximum = Math.min(budget.limits.maxInputBytes, Math.floor(budget.limits.maxBufferedBytes / 2));
-          const size = stat.size;
-          this.lifecycle.assertOpen();
-          budget.check(size, maximum, "buffered input bytes");
-          budget.retain(Number.isFinite(maximum) ? maximum : size);
-          this.snapshotBytes = Number.isFinite(maximum) ? maximum : size;
-          const readFile = fs.readFile;
-          this.lifecycle.assertOpen();
-          const content = await Reflect.apply(readFile, fs, [path, { signal: budget.signal, ...Number.isFinite(maximum) ? { maxBytes: maximum } : {} }]);
-          this.lifecycle.assertOpen();
-          if (!(content instanceof Uint8Array)) throw new TypeError("hexdump input requires bytes");
-          const length = viewLength.call(content);
-          budget.check(length, maximum, "buffered input bytes");
-          budget.retain(length - this.snapshotBytes);
-          this.snapshotBytes = 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, []);
-    });
-  }
-  hasBufferedBytes() {
-    return this.offset < this.chunk.length;
-  }
-  canReadBlockSync(size) {
-    const { budget } = this.lifecycle;
-    return this.offset + size <= this.chunk.length && budget.canChargeWithoutCheckpoint(size);
-  }
-  readBlockSync(target, size) {
-    const { budget } = this.lifecycle;
-    budget.charge(size);
-    for (let i = 0; i < size; i++) target[i] = this.chunk[this.offset + i];
-    this.offset += size;
-  }
-  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;
-      const cp2 = budget.checkpointWork();
-      if (cp2) await cp2;
-      const next = await this.lifecycle.operation(() => {
-        const iterator = this.iterator;
-        const advance = iterator.next;
-        this.lifecycle.assertOpen();
-        return Reflect.apply(advance, iterator, []);
-      });
-      budget.retain(-this.chunk.length);
-      this.chunk = new Uint8Array();
-      this.offset = 0;
-      const done = next.done;
-      this.lifecycle.assertOpen();
-      if (done) {
-        this.ended = true;
-        this.iterator = void 0;
-        return -1;
-      }
-      const value = next.value;
-      this.lifecycle.assertOpen();
-      if (!(value instanceof Uint8Array)) throw new TypeError("hexdump input requires bytes");
-      const buffer = viewBuffer.call(value);
-      const offset = viewOffset.call(value);
-      const length = viewLength.call(value);
-      this.lifecycle.assertOpen();
-      budget.inputBytes(length);
-      budget.charge(length);
-      budget.retain(length);
-      try {
-        if (viewOffset.call(value) !== offset || viewLength.call(value) < length) throw new TypeError("hexdump input extent changed during admission");
-        this.chunk = new Uint8Array(new Uint8Array(buffer, offset, length));
-      } catch (error) {
-        budget.retain(-length);
-        throw error;
-      }
-      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-hexdump/src/options.ts
-init_platform();
-var usage = "usage: hexdump [-bcCdovx] [-e fmt] [-f fmt_file] [-n length]\n               [-s skip] [file ...]\n       hd      [-bcdovx]  [-e fmt] [-f fmt_file] [-n length]\n               [-s skip] [file ...]";
-function number(text, skip, dialect) {
-  let offset = 0;
-  while (offset < text.length && " 	\n\r\v\f".includes(text[offset])) offset++;
-  const negative = text[offset] === "-";
-  if (negative || text[offset] === "+") offset++;
-  let base = 10;
-  if ((skip || dialect === "util-linux") && text[offset] === "0") {
-    base = 8;
-    if ((text[offset + 1] === "x" || text[offset + 1] === "X") && "0123456789abcdef".includes((text[offset + 2] ?? "!").toLowerCase())) {
-      base = 16;
-      offset += 2;
-    }
-  }
-  let value = 0;
-  const start = offset;
-  for (; offset < text.length; offset++) {
-    const digit = "0123456789abcdef".indexOf(text[offset].toLowerCase());
-    if (digit < 0 || digit >= base) break;
-    value = value * base + digit;
-    if (!Number.isSafeInteger(value)) throw new HexdumpError(`${text}: numeric value exceeds safe integer range`);
-  }
-  if (negative && value !== 0) throw new HexdumpError(`${text}: bad ${skip ? "skip" : "length"} value`);
-  if (dialect === "util-linux") {
-    const suffix = text.slice(offset);
-    let multiplier = suffix === "b" ? 512 : 1;
-    if (suffix !== "" && suffix !== "b") {
-      const power = "KMGTPEZY".indexOf(suffix[0] === "k" ? "K" : suffix[0]) + 1;
-      const tail = suffix.slice(1);
-      if (!power || tail !== "" && tail !== "B" && tail !== "iB") throw new HexdumpError(`${text}: bad ${skip ? "skip" : "length"} value`);
-      multiplier = (tail === "B" ? 1e3 : 1024) ** power;
-    }
-    if (offset === start || negative) throw new HexdumpError(`${text}: bad ${skip ? "skip" : "length"} value`);
-    value *= multiplier;
-  } else if (skip) value *= { b: 512, k: 1024, m: 1048576 }[text[offset] ?? ""] ?? 1;
-  if (!Number.isSafeInteger(value)) throw new HexdumpError(`${text}: numeric value exceeds safe integer range`);
-  return value;
-}
-function parse(budget, name, dialect) {
-  const args = budget.arguments();
-  const files = [];
-  const formats = name === "hd" ? ["C"] : [];
-  let verbose = false, ended = false, skip = 0, count = Infinity;
-  for (let index = 0; index < args.length; index++) {
-    const argument = args[index];
-    if (!ended && argument === "--") {
-      ended = true;
-      continue;
-    }
-    if (ended || argument === "-" || !argument.startsWith("-")) {
-      files.push(argument);
-      if (budget.context.env.POSIXLY_CORRECT !== void 0) ended = true;
-      continue;
-    }
-    for (let offset = 1; offset < argument.length; offset++) {
-      budget.charge();
-      const flag = argument[offset];
-      if (flag === "v") verbose = true;
-      else if (flag === "C" || flag === "b" || flag === "c" || flag === "d" || flag === "o" || flag === "x") {
-        if (name === "hd" && flag === "C") throw new HexdumpError(usage, true);
-        budget.check(formats.length + 1, budget.limits.maxFormats, "format count");
-        formats.push(flag);
-      } else if (flag === "n" || flag === "s") {
-        const parameter = argument.slice(offset + 1) || args[++index];
-        if (parameter === void 0) throw new HexdumpError(`${name}: option requires an argument -- '${flag}'
-${usage}`, true);
-        if (flag === "n") count = number(parameter, false, dialect);
-        else skip = number(parameter, true, dialect);
-        break;
-      } else if (flag === "e" || flag === "f") throw new HexdumpError(`-${flag}: custom formats are not supported`);
-      else throw new HexdumpError(`unsupported option -- '${flag}'`);
-    }
-  }
-  return { files, formats: formats.length ? formats : ["default"], verbose, skip, count, dialect };
-}
-
-// packages/safe-bash-command-hexdump/src/format.ts
-init_platform();
-var HEX_BYTE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-var ASCII_CHAR = Array.from({ length: 256 }, (_, i) => i >= 32 && i <= 126 ? String.fromCharCode(i) : ".");
-function formatBlock(block, used, address, format) {
-  const canonical = format === "C";
-  if (canonical && used === 16) {
-    const b0 = block[0], b1 = block[1], b2 = block[2], b3 = block[3];
-    const b4 = block[4], b5 = block[5], b6 = block[6], b7 = block[7];
-    const b8 = block[8], b9 = block[9], b10 = block[10], b11 = block[11];
-    const b12 = block[12], b13 = block[13], b14 = block[14], b15 = block[15];
-    return `${address.toString(16).padStart(8, "0")}  ${HEX_BYTE[b0]} ${HEX_BYTE[b1]} ${HEX_BYTE[b2]} ${HEX_BYTE[b3]} ${HEX_BYTE[b4]} ${HEX_BYTE[b5]} ${HEX_BYTE[b6]} ${HEX_BYTE[b7]}  ${HEX_BYTE[b8]} ${HEX_BYTE[b9]} ${HEX_BYTE[b10]} ${HEX_BYTE[b11]} ${HEX_BYTE[b12]} ${HEX_BYTE[b13]} ${HEX_BYTE[b14]} ${HEX_BYTE[b15]}  |${ASCII_CHAR[b0]}${ASCII_CHAR[b1]}${ASCII_CHAR[b2]}${ASCII_CHAR[b3]}${ASCII_CHAR[b4]}${ASCII_CHAR[b5]}${ASCII_CHAR[b6]}${ASCII_CHAR[b7]}${ASCII_CHAR[b8]}${ASCII_CHAR[b9]}${ASCII_CHAR[b10]}${ASCII_CHAR[b11]}${ASCII_CHAR[b12]}${ASCII_CHAR[b13]}${ASCII_CHAR[b14]}${ASCII_CHAR[b15]}|
-`;
-  }
-  let result = address.toString(16).padStart(canonical ? 8 : 7, "0") + (canonical ? "  " : " ");
-  if (canonical) {
-    for (let index = 0; index < 16; index++) {
-      if (index === 8) result += " ";
-      result += index < used ? HEX_BYTE[block[index]] : "  ";
-      if (index !== 15) result += " ";
-    }
-    result += "  |";
-    for (let index = 0; index < used; index++) {
-      result += ASCII_CHAR[block[index]];
-    }
-    return result + "|\n";
-  }
-  if (format !== "default") {
-    const byteFormat = format === "b" || format === "c";
-    const stride = byteFormat ? 1 : 2;
-    const width = byteFormat ? 3 : 7;
-    const escapes = { 0: "\\0", 7: "\\a", 8: "\\b", 9: "\\t", 10: "\\n", 11: "\\v", 12: "\\f", 13: "\\r" };
-    for (let index = 0; index < 16; index += stride) {
-      let field = "";
-      if (index < used) {
-        const byte = block[index];
-        if (format === "c") field = escapes[byte] ?? (byte >= 32 && byte <= 126 ? String.fromCharCode(byte) : byte.toString(8).padStart(3, "0"));
-        else if (format === "b") field = byte.toString(8).padStart(3, "0");
-        else {
-          const word = byte + (index + 1 < used ? block[index + 1] * 256 : 0);
-          field = word.toString(format === "d" ? 10 : format === "o" ? 8 : 16).padStart(format === "d" ? 5 : format === "o" ? 6 : 4, "0");
-        }
-      }
-      result += field.padStart(width, " ") + (index + stride < 16 ? " " : "");
-    }
-    return result + "\n";
-  }
-  for (let index = 0; index < 16; index += 2) {
-    result += index < used ? (block[index] + (index + 1 < used ? block[index + 1] * 256 : 0)).toString(16).padStart(4, "0") : "    ";
-    if (index !== 14) result += " ";
-  }
-  return result + "\n";
-}
-
-// packages/safe-bash-command-hexdump/src/command.ts
-async function dump(options, lifecycle, name) {
-  if (options.count === 0) return 0;
-  const { budget } = lifecycle;
-  budget.retain(32);
-  const block = new Uint8Array(16), previous = new Uint8Array(16);
-  let address = 0, used = 0, skip = options.skip, count = options.count;
-  let hasPrevious = false, squeezed = false, exitCode = 0;
-  let firstWrite = true, outBuf = "";
-  let currentReader;
-  const unlimitedFast = budget.limits.maxOutputBytes === Infinity && budget.limits.maxBufferedBytes === Infinity && budget.limits.maxWork === Infinity;
-  const flushOut = async () => {
-    if (outBuf) {
-      const chunk = outBuf;
-      outBuf = "";
-      await lifecycle.write(chunk);
-    }
-  };
-  const writeOut = (text) => {
-    if (!unlimitedFast || firstWrite || !currentReader?.hasBufferedBytes()) {
-      firstWrite = false;
-      return flushOut().then(() => lifecycle.write(text));
-    }
-    outBuf += text;
-    if (outBuf.length >= 16384) return flushOut();
-  };
-  const emitAsync = async () => {
-    for (const format of options.formats) {
-      budget.charge(16);
-      const cp = budget.checkpointWork();
-      if (cp) {
-        await flushOut();
-        await cp;
-      }
-      const w = writeOut(formatBlock(block, used, address, format));
-      if (w) await w;
-    }
-    previous.set(block);
-    hasPrevious = true;
-    squeezed = false;
-    address += used;
-    used = 0;
-  };
-  const emit = () => {
-    let same = hasPrevious && (options.dialect !== "util-linux" || used === 16);
-    for (let index = 0; same && index < used; index++) if (block[index] !== previous[index]) same = false;
-    budget.charge(used);
-    if (!options.verbose && same) {
-      let p = void 0;
-      if (!squeezed) p = writeOut("*\n");
-      squeezed = true;
-      address += used;
-      used = 0;
-      return p;
-    }
-    if (options.formats.length === 1 && unlimitedFast && !firstWrite && currentReader?.hasBufferedBytes()) {
-      budget.charge(16);
-      const cp = budget.checkpointWork();
-      if (!cp) {
-        outBuf += formatBlock(block, used, address, options.formats[0]);
-        previous.set(block);
-        hasPrevious = true;
-        squeezed = false;
-        address += used;
-        used = 0;
-        if (outBuf.length >= 16384) return flushOut();
-        return;
-      }
-      return flushOut().then(() => cp).then(() => {
-        const w = writeOut(formatBlock(block, used, address, options.formats[0]));
-        previous.set(block);
-        hasPrevious = true;
-        squeezed = false;
-        address += used;
-        used = 0;
-        return w;
-      });
-    }
-    return emitAsync();
-  };
-  for (const file of options.files.length ? options.files : [void 0]) {
-    if (count === 0) break;
-    const reader = new Reader(file, lifecycle);
-    currentReader = reader;
-    let opened = true;
-    try {
-      await reader.open();
-    } catch (error) {
-      budget.signal.throwIfAborted();
-      if (!(error instanceof FsError2)) throw error;
-      opened = false;
-      if (error.code !== "EISDIR") exitCode = 1;
-      await lifecycle.write(`${name}: ${file ?? "stdin"}: ${fsDetail(error)}
-`, true);
-    }
-    if (opened) {
-      while (count > 0) {
-        if (skip === 0 && used === 0 && count >= 16 && reader.hasBufferedBytes()) {
-          const cp = budget.checkpointWork();
-          if (cp) await cp;
-          if (reader.canReadBlockSync(16)) {
-            reader.readBlockSync(block, 16);
-            used = 16;
-            count -= 16;
-            const p = emit();
-            if (p) await p;
-            continue;
-          }
-        }
-        if (skip === 0 && used === 0 && count >= 16 && reader.canReadBlockSync(16)) {
-          reader.readBlockSync(block, 16);
-          used = 16;
-          count -= 16;
-          const p = emit();
-          if (p) await p;
-          continue;
-        }
-        let byte;
-        try {
-          const b = reader.get();
-          byte = typeof b === "number" ? b : await b;
-        } catch (error) {
-          budget.signal.throwIfAborted();
-          if (!(error instanceof FsError2)) throw error;
-          if (error.code !== "EISDIR") exitCode = 1;
-          await lifecycle.write(`${name}: ${file ?? "stdin"}: ${fsDetail(error)}
-`, true);
-          break;
-        }
-        if (byte < 0) break;
-        if (skip > 0) {
-          skip--;
-          address++;
-          continue;
-        }
-        block[used++] = byte;
-        count--;
-        if (used === 16) {
-          const p = emit();
-          if (p) await p;
-        }
-      }
-    }
-    await flushOut();
-    currentReader = void 0;
-    await lifecycle.operation(() => reader.close());
-  }
-  if (used) {
-    const p = emit();
-    if (p) await p;
-  }
-  await flushOut();
-  if (address > 0) await lifecycle.write(address.toString(16).padStart(options.formats.at(-1) === "C" ? 8 : 7, "0") + "\n");
-  return exitCode;
-}
-async function execute(context, name, limits, dialect) {
-  let lifecycle;
-  const caller = context.signal;
-  caller.throwIfAborted();
-  const stdout = context.stdout;
-  caller.throwIfAborted();
-  const capability = stdout.ownedOutput;
-  caller.throwIfAborted();
-  const consumer = capability?.consumerClosed;
-  caller.throwIfAborted();
-  consumer?.throwIfAborted();
-  const failureHandler = stdout[outputFailure];
-  caller.throwIfAborted();
-  consumer?.throwIfAborted();
-  const registerCleanup = context.registerCleanup;
-  caller.throwIfAborted();
-  consumer?.throwIfAborted();
-  const destination = capability ?? stdout;
-  const write = async (value) => {
-    lifecycle.assertOpen();
-    const method = destination.write;
-    lifecycle.assertOpen();
-    await Reflect.apply(method, destination, [value]);
-  };
-  const captured = {
-    write,
-    ...capability ? { ownedOutput: { consumerClosed: consumer, write } } : {},
-    ...failureHandler ? { [outputFailure]: failureHandler } : {}
-  };
-  const admission = { closed: false };
-  const output = createOutputOperation({ signal: caller, ...registerCleanup ? { registerCleanup(cleanup) {
-    caller.throwIfAborted();
-    Reflect.apply(registerCleanup, context, [() => {
-      admission.closed = true;
-      return cleanup();
-    }]);
-  } } : {} }, captured);
-  const budget = new Budget(context, limits, output.signal, caller, admission);
-  let failure;
-  let primary;
-  let exitCode = 0;
-  try {
-    lifecycle = new Lifecycle(budget, output, captured, caller);
-    exitCode = await dump(parse(budget, name, dialect), lifecycle, name);
-  } catch (error) {
-    primary = { reason: error };
-    if (error instanceof HexdumpError && !output.signal.aborted && lifecycle) {
-      exitCode = 1;
-      try {
-        await lifecycle.write(`${error.bare ? "" : name + ": "}${error.message}
-`, true);
-      } catch (reporting) {
-        failure = { reason: new AggregateError([error, reporting], "hexdump 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], "hexdump execution and cleanup failed") : cleanup };
-  }
-  caller.throwIfAborted();
-  output.signal.throwIfAborted();
-  if (lifecycle?.diagnosticCancellation) throw lifecycle.diagnosticCancellation.reason;
-  if (failure) throw failure.reason;
-  return { exitCode };
-}
-function createHexdumpCommand(options = {}) {
-  const limits = settings(options);
-  const dialect = options.dialect;
-  return {
-    name: "hexdump",
-    description: "Display bytes as hexadecimal words or canonical hex and ASCII",
-    execute: (context) => execute(context, "hexdump", limits, dialect)
-  };
-}
-function createHdCommand(options = {}) {
-  const limits = settings(options);
-  const dialect = options.dialect;
-  return {
-    name: "hd",
-    description: "Display canonical hexadecimal and ASCII bytes",
-    execute: (context) => execute(context, "hd", limits, dialect)
-  };
-}
-
-// packages/safe-bash-command-hexdump/src/index.ts
-function createHexdumpCommand2(options = {}) {
-  const def = createHexdumpCommand(options);
-  builtInDirectContextExecutors.add(def.execute);
-  return def;
-}
-function createHdCommand2(options = {}) {
-  const def = createHdCommand(options);
-  builtInDirectContextExecutors.add(def.execute);
-  return def;
-}
-function createHexdumpCommands(options = {}) {
-  return [createHexdumpCommand2(options), createHdCommand2(options)];
-}
-function hexdumpCommands(options = {}) {
-  const commands = createHexdumpCommands(options);
-  return { name: "hexdump-commands", setup(host) {
-    if (!options.replace) {
-      for (const command of commands) if (host.commands.has(command.name)) throw new Error(`Command already registered: ${command.name}`);
-    }
-    for (const command of commands) host.commands.register(command, { replace: options.replace ?? false });
-  } };
-}
-
-export {
-  createHexdumpCommand2 as createHexdumpCommand,
-  createHdCommand2 as createHdCommand,
-  createHexdumpCommands,
-  hexdumpCommands
-};
-//# sourceMappingURL=chunk-4E3SGG37.js.map