poe-code 15.0.14 → 15.0.16

package/packages/safe-bash/dist/chunks/chunk-R3QJL5HH.js

@@ -0,0 +1,698 @@
+import {
+  resolvePath
+} from "./chunk-DPJWEGIX.js";
+import {
+  createOutputOperation
+} from "./chunk-PZMJ4EC3.js";
+import {
+  FsError,
+  PublicDiagnostic,
+  getCommandArguments,
+  outputFailure,
+  shellValueByteLength,
+  shellValueBytes,
+  yieldTurn
+} from "./chunk-5VBLSPNM.js";
+import {
+  init_platform
+} from "./chunk-2KL6W6NB.js";
+
+// packages/safe-bash/src/commands/hexdump/index.ts
+init_platform();
+
+// packages/safe-bash/src/commands/hexdump/command.ts
+init_platform();
+
+// packages/safe-bash/src/commands/hexdump/internal.ts
+init_platform();
+function settings(options) {
+  const limits = {
+    maxArguments: 4096,
+    maxArgumentBytes: 65536,
+    maxInputBytes: 33554432,
+    maxBufferedBytes: 8388608,
+    maxOutputBytes: 134217728,
+    maxDiagnosticBytes: 65536,
+    maxFormats: 64,
+    maxWork: 536870912,
+    maxEmptyChunks: 4096,
+    ...options.limits
+  };
+  for (const [name, value] of Object.entries(limits)) {
+    if (!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) {
+  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 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;
+  }
+  context;
+  limits;
+  signal;
+  callerSignal;
+  admission;
+  work = 0;
+  checkpoint = 0;
+  retained = 0;
+  input = 0;
+  output = 0;
+  diagnostics = 0;
+  assertOpen() {
+    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;
+  }
+  async checkpointWork() {
+    this.assertOpen();
+    if (this.work - this.checkpoint >= 4096) {
+      this.checkpoint = this.work;
+      await yieldTurn(this.callerSignal);
+      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/src/commands/hexdump/io.ts
+init_platform();
+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(maximum);
+          this.snapshotBytes = maximum;
+          const readFile = fs.readFile;
+          this.lifecycle.assertOpen();
+          const content = await Reflect.apply(readFile, fs, [path, { signal: budget.signal, 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 - maximum);
+          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, []);
+    });
+  }
+  async get() {
+    const { budget } = this.lifecycle;
+    budget.charge();
+    await budget.checkpointWork();
+    while (this.offset === this.chunk.length) {
+      if (this.ended) return -1;
+      await budget.checkpointWork();
+      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/src/commands/hexdump/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) {
+  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 && 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;
+  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 (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) {
+  const args = budget.arguments();
+  const files = [];
+  let canonical = name === "hd" ? 1 : 0;
+  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") {
+        if (name === "hd") throw new HexdumpError(usage, true);
+        budget.check(++canonical, budget.limits.maxFormats, "format count");
+      } 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);
+        else skip = number(parameter, true);
+        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, canonical, verbose, skip, count };
+}
+
+// packages/safe-bash/src/commands/hexdump/format.ts
+init_platform();
+function formatBlock(block, used, address, canonical) {
+  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 ? block[index].toString(16).padStart(2, "0") : "  ";
+      if (index !== 15) result += " ";
+    }
+    result += "  |";
+    for (let index = 0; index < used; index++) {
+      const byte = block[index];
+      result += byte >= 32 && byte <= 126 ? String.fromCharCode(byte) : ".";
+    }
+    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/src/commands/hexdump/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;
+  const emit = async () => {
+    let same = hasPrevious;
+    for (let index = 0; same && index < used; index++) if (block[index] !== previous[index]) same = false;
+    budget.charge(used);
+    if (!options.verbose && same) {
+      if (!squeezed) await lifecycle.write("*\n");
+      squeezed = true;
+    } else {
+      for (let index = 0; index < Math.max(1, options.canonical); index++) {
+        budget.charge(16);
+        await budget.checkpointWork();
+        await lifecycle.write(formatBlock(block, used, address, options.canonical > 0));
+      }
+      previous.set(block);
+      hasPrevious = true;
+      squeezed = false;
+    }
+    address += used;
+    used = 0;
+  };
+  for (const file of options.files.length ? options.files : [void 0]) {
+    if (count === 0) break;
+    const reader = new Reader(file, lifecycle);
+    let opened = true;
+    try {
+      await reader.open();
+    } catch (error) {
+      budget.signal.throwIfAborted();
+      if (!(error instanceof FsError)) throw error;
+      opened = false;
+      if (error.code !== "EISDIR") exitCode = 1;
+      await lifecycle.write(`${name}: ${file ?? "stdin"}: ${fsDetail(error)}
+`, true);
+    }
+    if (opened) {
+      while (count > 0) {
+        let byte;
+        try {
+          byte = await reader.get();
+        } catch (error) {
+          budget.signal.throwIfAborted();
+          if (!(error instanceof FsError)) throw error;
+          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) await emit();
+      }
+    }
+    await lifecycle.operation(() => reader.close());
+  }
+  if (used) await emit();
+  if (address > 0) await lifecycle.write(address.toString(16).padStart(options.canonical ? 8 : 7, "0") + "\n");
+  return exitCode;
+}
+async function execute(context, name, limits) {
+  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), 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);
+  return {
+    name: "hexdump",
+    description: "Display bytes as hexadecimal words or canonical hex and ASCII",
+    execute: (context) => execute(context, "hexdump", limits)
+  };
+}
+function createHdCommand(options = {}) {
+  const limits = settings(options);
+  return {
+    name: "hd",
+    description: "Display canonical hexadecimal and ASCII bytes",
+    execute: (context) => execute(context, "hd", limits)
+  };
+}
+
+// packages/safe-bash/src/commands/hexdump/index.ts
+function createHexdumpCommands(options = {}) {
+  return [createHexdumpCommand(options), createHdCommand(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 {
+  createHexdumpCommand,
+  createHdCommand,
+  createHexdumpCommands,
+  hexdumpCommands
+};
+//# sourceMappingURL=chunk-R3QJL5HH.js.map