@poe-platform/safe-bash 0.1.756 → 0.1.757

package/dist/safe-bash/chunks/chunk-6IIFUPN2.js

@@ -1,1526 +0,0 @@
-import {
-  init_platform
-} from "./chunk-ZG7GWQ5P.js";
-
-// packages/safe-bash/src/commands/line-endings/index.ts
-init_platform();
-
-// packages/safe-bash-command-dos2unix/src/index.ts
-init_platform();
-import { builtInDirectContextExecutors, FsError as FsError2, outputFailure } from "../../safe-bash-contracts/index.js";
-import { createOutputOperation } from "../../safe-bash-contracts/output.js";
-
-// packages/safe-bash-line-ending-engine/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,
-    maxOutputBytes: Infinity,
-    maxBufferedBytes: Infinity,
-    maxDiagnosticBytes: Infinity,
-    maxFiles: Infinity,
-    maxWork: Infinity,
-    maxEmptyChunks: Infinity,
-    maxPathBytes: Infinity,
-    maxDepth: Infinity,
-    maxTempAttempts: Infinity,
-    chunkSize: 16384,
-    ...options.limits
-  };
-  for (const [name, value] of Object.entries(options.limits ?? {})) if (value !== Infinity && (!Number.isSafeInteger(value) || value < 1)) throw new RangeError(`Invalid line-ending limit: ${name}`);
-  return Object.freeze(limits);
-}
-var LineEndingError = class extends PublicDiagnostic {
-  constructor(message, status = 1) {
-    super(message);
-    this.status = status;
-  }
-  status;
-};
-var Budget = class {
-  constructor(context, limits, signal, caller, admission) {
-    this.context = context;
-    this.limits = limits;
-    this.signal = signal;
-    this.caller = caller;
-    this.admission = admission;
-    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;
-  caller;
-  admission;
-  work = 0;
-  quantum = 0;
-  checkpointCount = 0;
-  lastYield = monotonicNow();
-  memory = 0;
-  input = 0;
-  output = 0;
-  diagnostics = 0;
-  files = 0;
-  signalAborted;
-  pollSignal;
-  assertOpen() {
-    if (this.pollSignal ? this.signal.aborted : this.signalAborted) this.signal.throwIfAborted();
-    if (this.admission.closed) throw new LineEndingError("command is closed");
-  }
-  check(value, maximum, label) {
-    if (value > maximum || value < 0 || (value | 0) !== value && !Number.isSafeInteger(value)) throw new LineEndingError(`${label} limit exceeded`);
-  }
-  retain(amount) {
-    this.check(this.memory + amount, this.limits.maxBufferedBytes, "buffered bytes");
-    this.memory += amount;
-  }
-  incoming(amount) {
-    this.check(this.input + amount, this.limits.maxInputBytes, "input bytes");
-    this.input += amount;
-  }
-  emitted(amount, diagnostic = false) {
-    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;
-    }
-  }
-  file() {
-    this.check(++this.files, this.limits.maxFiles, "file count");
-  }
-  step(amount = 1) {
-    this.assertOpen();
-    this.check(this.work + amount, this.limits.maxWork, "work");
-    this.work += amount;
-    this.quantum += amount;
-    if (this.quantum < 1024) return;
-    this.quantum = 0;
-    if (++this.checkpointCount > 1 && (this.checkpointCount & 255) !== 0 && !hasYieldCheckpoint(this.caller) && monotonicNow() - this.lastYield < 25) {
-      runYieldCheckpoint(this.caller);
-      this.assertOpen();
-      return;
-    }
-    return yieldTurn(this.caller).then(() => {
-      this.lastYield = monotonicNow();
-      this.assertOpen();
-    });
-  }
-  async arguments() {
-    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 });
-    const snapshot = [];
-    this.retain(count * 64);
-    let total = 0;
-    for (let index = 0; index < count; index++) {
-      const argument = args[index];
-      this.assertOpen();
-      if (typeof argument !== "string") throw new LineEndingError("arguments must be strings");
-      this.check(argument.length, this.limits.maxPathBytes, "argument bytes");
-      total += argument.length;
-      this.check(total, this.limits.maxArgumentBytes, "argument bytes");
-      this.retain(argument.length * 12);
-      snapshot.push(argument);
-    }
-    for (const argument of snapshot) {
-      for (let index = 0; index < argument.length; index++) {
-        {
-          const s = this.step();
-          if (s) await s;
-        }
-        const unit = argument.charCodeAt(index);
-        if (unit >= 55296 && unit <= 56319) {
-          const next = argument.charCodeAt(++index);
-          if (!(next >= 56320 && next <= 57343)) throw new LineEndingError("arguments must be valid UTF-8 paths");
-        } else if (unit >= 56320 && unit <= 57343) throw new LineEndingError("arguments must be valid UTF-8 paths");
-      }
-    }
-    const values = (carrier ?? getCommandArguments({ args: snapshot })).values;
-    total = 0;
-    for (const value of values) {
-      const length = shellValueByteLength(value);
-      this.check(length, this.limits.maxPathBytes, "argument bytes");
-      total += length;
-      this.check(total, this.limits.maxArgumentBytes, "argument bytes");
-    }
-    const result = [];
-    for (const value of values) {
-      {
-        const s = this.step(shellValueByteLength(value));
-        if (s) await s;
-      }
-      let text;
-      try {
-        text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(shellValueBytes(value));
-      } catch {
-        throw new LineEndingError("arguments must be valid UTF-8 paths");
-      }
-      if (text.includes("\0")) throw new LineEndingError("NUL is not supported in paths");
-      result.push(text);
-    }
-    return result;
-  }
-};
-function sameIdentity(first, second) {
-  return (typeof first.identityScope === "object" && first.identityScope !== null || typeof first.identityScope === "symbol") && first.identityScope === second.identityScope && Number.isSafeInteger(first.dev) && Number.isSafeInteger(first.ino) && first.dev >= 0 && first.ino >= 0 && first.dev === second.dev && first.ino === second.ino;
-}
-function missing(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
-
-// packages/safe-bash-line-ending-engine/src/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, captured, caller, admission) {
-    this.budget = budget;
-    this.captured = captured;
-    this.caller = caller;
-    this.admission = admission;
-    output.registerCleanup(() => this.close());
-  }
-  budget;
-  captured;
-  caller;
-  admission;
-  pending = /* @__PURE__ */ new Set();
-  cleanups = [];
-  closing;
-  diagnosticDestination;
-  diagnosticCancellation;
-  assertOpen() {
-    this.budget.assertOpen();
-    if (this.closing) throw new LineEndingError("command is closed");
-  }
-  assertDiagnosticOpen() {
-    this.caller.throwIfAborted();
-    const consumer = this.diagnosticDestination?.consumer;
-    if (consumer?.aborted) {
-      this.diagnosticCancellation = { reason: consumer.reason };
-      consumer.throwIfAborted();
-    }
-  }
-  cleanup(action) {
-    this.assertOpen();
-    this.cleanups.push(action);
-  }
-  async operation(action) {
-    this.assertOpen();
-    const pending = Promise.resolve().then(async () => {
-      {
-        const s = this.budget.step();
-        if (s) await s;
-      }
-      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 close of this.cleanups) {
-        try {
-          await close();
-        } catch (error) {
-          failures.push(error);
-        }
-      }
-      if (failures.length === 1) throw failures[0];
-      if (failures.length > 1) throw new AggregateError(failures, "line-ending cleanup failed");
-    });
-  }
-  async stdout(bytes) {
-    await this.operation(async () => {
-      const write = this.captured.write;
-      this.assertOpen();
-      await Reflect.apply(write, this.captured, [bytes]);
-    });
-  }
-  async diagnostic(text) {
-    this.assertDiagnosticOpen();
-    if (this.closing || this.admission.closed) throw new LineEndingError("command is closed");
-    this.budget.check(text.length * 3, this.budget.limits.maxDiagnosticBytes, "diagnostic buffer bytes");
-    const bytes = new TextEncoder().encode(text);
-    this.budget.emitted(bytes.length, true);
-    const pending = Promise.resolve().then(async () => {
-      this.assertDiagnosticOpen();
-      if (!this.diagnosticDestination) {
-        const sink = this.budget.context.stderr;
-        this.assertDiagnosticOpen();
-        const capability = sink.ownedOutput;
-        this.assertDiagnosticOpen();
-        const consumer = capability?.consumerClosed;
-        this.diagnosticDestination = { destination: capability ?? sink, consumer };
-      }
-      this.assertDiagnosticOpen();
-      const destination = this.diagnosticDestination.destination;
-      const write = destination.write;
-      this.assertDiagnosticOpen();
-      await Reflect.apply(write, destination, [bytes]);
-    });
-    this.pending.add(pending);
-    try {
-      await pending;
-      this.assertDiagnosticOpen();
-    } finally {
-      this.pending.delete(pending);
-    }
-  }
-};
-var Reader = class {
-  constructor(life) {
-    this.life = life;
-    life.cleanup(() => this.close());
-  }
-  life;
-  iterator;
-  chunk = new Uint8Array();
-  offset = 0;
-  ended = false;
-  empties = 0;
-  snapshotBytes = 0;
-  closing;
-  close() {
-    return this.closing ??= (async () => {
-      try {
-        if (!this.ended && this.iterator) {
-          const iterator = this.iterator;
-          const close = iterator.return;
-          if (close) await Reflect.apply(close, iterator, []);
-        }
-      } finally {
-        this.iterator = void 0;
-        this.life.budget.retain(-this.chunk.length - this.snapshotBytes);
-        this.chunk = new Uint8Array();
-        this.snapshotBytes = 0;
-      }
-    })();
-  }
-  async open(path, stat) {
-    const { context, signal, limits } = this.life.budget;
-    await this.life.operation(async () => {
-      let source;
-      let acquisitionAborted = false;
-      if (path === void 0) source = context.stdin;
-      else {
-        const fs = context.fs;
-        const capabilitiesFor = fs.capabilitiesFor;
-        this.life.assertOpen();
-        const selected = capabilitiesFor ? await Reflect.apply(capabilitiesFor, fs, [path, { signal }]) : void 0;
-        this.life.assertOpen();
-        const capabilities = selected ?? fs.capabilities;
-        this.life.assertOpen();
-        const readStream = fs.readStream;
-        this.life.assertOpen();
-        const streaming = capabilities.streamingRead !== false;
-        this.life.assertOpen();
-        if (readStream && streaming) {
-          source = Reflect.apply(readStream, fs, [path, { signal, chunkSize: limits.chunkSize === Infinity ? 16384 : limits.chunkSize }]);
-          acquisitionAborted = signal.aborted || this.life.admission.closed;
-        } else {
-          const maximum = Math.min(limits.maxInputBytes, Math.floor(limits.maxBufferedBytes / 3));
-          const size = stat.size;
-          this.life.assertOpen();
-          this.life.budget.check(size, maximum, "buffered input bytes");
-          this.life.budget.retain(Number.isFinite(maximum) ? maximum : size);
-          this.snapshotBytes = Number.isFinite(maximum) ? maximum : size;
-          const readFile = fs.readFile;
-          this.life.assertOpen();
-          const bytes = await Reflect.apply(readFile, fs, [path, { signal, ...Number.isFinite(maximum) ? { maxBytes: maximum } : {} }]);
-          this.life.assertOpen();
-          if (!(bytes instanceof Uint8Array)) throw new TypeError("line-ending input requires bytes");
-          this.life.budget.check(viewLength.call(bytes), maximum, "buffered input bytes");
-          this.life.budget.retain(viewLength.call(bytes) - this.snapshotBytes);
-          this.snapshotBytes = viewLength.call(bytes);
-          source = { [Symbol.asyncIterator]: (async function* () {
-            try {
-              yield bytes;
-            } finally {
-              this.life.budget.retain(-this.snapshotBytes);
-              this.snapshotBytes = 0;
-            }
-          }).bind(this) };
-        }
-      }
-      if (!acquisitionAborted) this.life.assertOpen();
-      const factory = source[Symbol.asyncIterator];
-      if (!acquisitionAborted) this.life.assertOpen();
-      this.iterator = Reflect.apply(factory, source, []);
-    });
-  }
-  get() {
-    const step = this.life.budget.step();
-    if (!step && this.offset < this.chunk.length) {
-      this.life.assertOpen();
-      return this.chunk[this.offset++];
-    }
-    return this.getSlow(step);
-  }
-  beforeRead;
-  async getSlow(step) {
-    if (step) await step;
-    this.life.assertOpen();
-    while (this.offset === this.chunk.length) {
-      if (this.ended) return -1;
-      await this.beforeRead?.();
-      const next = await this.life.operation(() => {
-        const iterator = this.iterator;
-        const advance = iterator.next;
-        this.life.assertOpen();
-        return Reflect.apply(advance, iterator, []);
-      });
-      this.life.budget.retain(-this.chunk.length);
-      this.chunk = new Uint8Array();
-      this.offset = 0;
-      const done = next.done;
-      this.life.assertOpen();
-      if (done) {
-        this.ended = true;
-        this.iterator = void 0;
-        return -1;
-      }
-      const value = next.value;
-      this.life.assertOpen();
-      if (!(value instanceof Uint8Array)) throw new TypeError("line-ending input requires bytes");
-      const buffer = viewBuffer.call(value);
-      const offset = viewOffset.call(value);
-      const length = viewLength.call(value);
-      this.life.budget.incoming(length);
-      this.life.budget.retain(length);
-      try {
-        if (viewOffset.call(value) !== offset || viewLength.call(value) < length) throw new TypeError("line-ending input extent changed during admission");
-        this.chunk = new Uint8Array(new Uint8Array(buffer, offset, length));
-      } catch (error) {
-        this.life.budget.retain(-length);
-        throw error;
-      }
-      if (!this.chunk.length) this.life.budget.check(++this.empties, this.life.budget.limits.maxEmptyChunks, "empty input chunks");
-    }
-    return this.chunk[this.offset++];
-  }
-};
-var Writer = class {
-  constructor(life, publish) {
-    this.life = life;
-    this.publish = publish;
-    const { chunkSize, maxBufferedBytes } = life.budget.limits;
-    const size = Math.min(chunkSize === Infinity ? 16384 : chunkSize, maxBufferedBytes);
-    life.budget.retain(size);
-    this.buffer = new Uint8Array(size);
-    life.cleanup(async () => {
-      this.release();
-    });
-  }
-  life;
-  publish;
-  buffer;
-  used = 0;
-  release() {
-    this.life.budget.retain(-this.buffer.length);
-    this.buffer = new Uint8Array();
-    this.used = 0;
-  }
-  put(byte) {
-    const step = this.life.budget.step();
-    if (step) return step.then(() => this.putAfterStep(byte));
-    return this.putAfterStep(byte);
-  }
-  putAfterStep(byte) {
-    this.life.assertOpen();
-    this.life.budget.emitted(1);
-    this.buffer[this.used++] = byte;
-    if (this.used === this.buffer.length) return this.flush();
-  }
-  async flush() {
-    this.life.assertOpen();
-    if (this.used) {
-      await this.publish(this.buffer.slice(0, this.used));
-      this.used = 0;
-    }
-  }
-};
-
-// packages/safe-bash-line-ending-engine/src/stage.ts
-init_platform();
-import { FsError } from "../../safe-bash-contracts/index.js";
-import { writeFileOutput } from "../../safe-bash-contracts/filesystem-output-budget.js";
-import { dirname, resolvePath, retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
-var Files = class {
-  constructor(life) {
-    this.life = life;
-  }
-  life;
-  async call(select, args) {
-    return await this.life.operation(async () => {
-      const fs = this.life.budget.context.fs;
-      this.life.assertOpen();
-      const method = select(fs);
-      this.life.assertOpen();
-      return await Reflect.apply(method, fs, args);
-    });
-  }
-  async stat(path) {
-    try {
-      return await this.call((fs) => fs.lstat, [path, { signal: this.life.budget.signal }]);
-    } catch (error) {
-      this.life.assertOpen();
-      if (missing(error)) return void 0;
-      throw error;
-    }
-  }
-  path(name) {
-    const path = resolvePath(this.life.budget.context.cwd, name);
-    this.life.budget.check(path.length * 3, this.life.budget.limits.maxPathBytes, "path bytes");
-    this.life.budget.check(path.split("/").length - 1, this.life.budget.limits.maxDepth, "path depth");
-    return path;
-  }
-  async parents(path) {
-    const parents = [];
-    let current = "/";
-    for (const component of ["", ...dirname(path).split("/").filter(Boolean)]) {
-      if (component) current = resolvePath(current, component);
-      const stat = await this.stat(current);
-      if (!stat) throw new FsError("ENOENT", { path: current });
-      if (stat.type !== "directory" || !sameIdentity(stat, stat)) throw new LineEndingError("output requires stable non-symlink directory identities");
-      parents.push({ path: current, stat });
-    }
-    return parents;
-  }
-};
-var Stage = class {
-  constructor(files, path, expected) {
-    this.files = files;
-    this.path = path;
-    this.expected = expected;
-    const { life } = files;
-    life.assertOpen();
-    this.cleanup = retainFileSystemCleanup(life.budget.context.fs, async (view) => {
-      if (!this.created || !this.identity) return;
-      try {
-        for (const parent of this.parents) {
-          const stat2 = await view.lstat(parent.path);
-          if (stat2.type !== "directory" || !sameIdentity(stat2, parent.stat)) return;
-        }
-        const stat = await view.lstat(this.temporary);
-        if (stat.type === "file" && sameIdentity(stat, this.identity)) await view.rm(this.temporary);
-      } catch (error) {
-        if (!missing(error)) throw error;
-      }
-    }, { maxOperations: Math.min(4096, life.budget.limits.maxDepth + 4) });
-    life.cleanup(this.cleanup);
-  }
-  files;
-  path;
-  expected;
-  temporary = "";
-  identity;
-  created = false;
-  parents = [];
-  cleanup;
-  async open() {
-    const { life } = this.files;
-    const { signal, limits } = life.budget;
-    const capabilities = await life.operation(async () => {
-      const fs = life.budget.context.fs;
-      const query = fs.capabilitiesFor;
-      life.assertOpen();
-      const result = query ? await Reflect.apply(query, fs, [this.path, { signal, create: true }]) : fs.capabilities;
-      life.assertOpen();
-      return result;
-    });
-    if (capabilities.atomicRename !== true || capabilities.exclusiveCreate !== true || capabilities.permissions !== true || capabilities.append === false || capabilities.remove === false) {
-      throw new LineEndingError("file conversion requires atomic rename, exclusive create, permissions, append and cleanup capabilities");
-    }
-    if (this.expected === void 0 && capabilities.atomicRenameNoReplace !== true) {
-      throw new LineEndingError("new destination requires atomic no-replace rename capability");
-    }
-    this.parents = await this.files.parents(this.path);
-    for (let attempt = 0; attempt < limits.maxTempAttempts; attempt++) {
-      this.temporary = resolvePath(dirname(this.path), `.line-ending-${attempt + 1}`);
-      this.files.path(this.temporary);
-      if (this.temporary === this.path || await this.files.stat(this.temporary)) continue;
-      try {
-        await this.files.call((fs) => fs.writeFile, [this.temporary, new Uint8Array(), { signal, flag: "wx", mode: 384 }]);
-      } catch (error) {
-        life.assertOpen();
-        if (typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST") continue;
-        throw error;
-      }
-      this.created = true;
-      this.identity = await this.files.stat(this.temporary);
-      if (!this.identity || this.identity.type !== "file" || !sameIdentity(this.identity, this.identity)) throw new LineEndingError("temporary file identity unavailable; unowned path is not removed");
-      return;
-    }
-    throw new LineEndingError("temporary file attempts limit exceeded");
-  }
-  async checked() {
-    for (const parent of this.parents) {
-      const stat2 = await this.files.stat(parent.path);
-      if (!stat2 || stat2.type !== "directory" || !sameIdentity(stat2, parent.stat)) throw new LineEndingError("output parent changed before mutation");
-    }
-    const stat = await this.files.stat(this.temporary);
-    if (!this.identity || !stat || stat.type !== "file" || !sameIdentity(stat, this.identity)) throw new LineEndingError("temporary file changed before mutation");
-  }
-  async append(bytes) {
-    await this.checked();
-    const { context, signal } = this.files.life.budget;
-    await this.files.life.operation(() => writeFileOutput(
-      { signal, ...context.registerCleanup ? { registerCleanup: context.registerCleanup } : {} },
-      bytes,
-      async (chunk) => {
-        await this.files.call((fs) => fs.appendFile, [this.temporary, chunk, { signal }]);
-      }
-    ));
-  }
-  async publish(input, options) {
-    const { signal } = this.files.life.budget;
-    await this.checked();
-    if (!options.newFile && !options.allowChown && (input.uid !== void 0 && input.uid !== this.identity.uid || input.gid !== void 0 && input.gid !== this.identity.gid)) {
-      throw new LineEndingError("filesystem cannot preserve input user/group ownership");
-    }
-    await this.files.call((fs) => fs.chmod, [this.temporary, input.mode & 511 & (options.newFile ? ~18 : 511), { signal }]);
-    if (options.keepDate) {
-      await this.checked();
-      await this.files.call((fs) => fs.utimes, [this.temporary, Math.floor(input.atimeMs / 1e3) * 1e3, Math.floor(input.mtimeMs / 1e3) * 1e3, { signal }]);
-    }
-    await this.checked();
-    const current = await this.files.stat(this.path);
-    if (current ? !this.expected || current.type !== "file" || !sameIdentity(current, this.expected) : this.expected !== void 0) throw new LineEndingError("destination changed before publication");
-    await this.files.call((fs) => fs.rename, [this.temporary, this.path, { signal, noReplace: this.expected === void 0 }]);
-    this.created = false;
-  }
-};
-
-// packages/safe-bash-line-ending-engine/src/convert.ts
-init_platform();
-
-// packages/safe-bash-line-ending-engine/src/encoding.ts
-init_platform();
-var encodingLabels = { bytes: "no_bom", le: "UTF-16LE", be: "UTF-16BE", utf8: "UTF-8", gb: "GB18030" };
-async function readEncoding(reader) {
-  const prefix = [];
-  let bom = "bytes", error = false;
-  const first = await reader.get();
-  if (first !== -1) {
-    if (first !== 255 && first !== 254 && first !== 239 && first !== 132) prefix.push(first);
-    else {
-      const second = await reader.get();
-      if (second === -1) error = true;
-      else if (first === 255 && second === 254) bom = "le";
-      else if (first === 254 && second === 255) bom = "be";
-      else {
-        const third = await reader.get();
-        if (third === -1) error = true;
-        else if (first === 239 && second === 187 && third === 191) bom = "utf8";
-        else {
-          prefix.push(first, second, third);
-          if (first === 132 && second === 49 && third === 149) {
-            const fourth = await reader.get();
-            if (fourth === -1) error = true;
-            else if (fourth === 51) {
-              bom = "gb";
-              prefix.length = 0;
-            } else prefix.push(fourth);
-          }
-        }
-      }
-    }
-  }
-  let offset = 0;
-  return { bom, error, byte: () => offset < prefix.length ? prefix[offset++] : reader.get() };
-}
-
-// packages/safe-bash-line-ending-engine/src/convert.ts
-async function convert(direction, reader, writer, life, options, name, stdio) {
-  let high = 1;
-  if (stdio) reader.beforeRead = () => writer.flush();
-  const diagnostic = async (message) => {
-    if (stdio) await writer.flush();
-    await life.diagnostic(`${direction}: ${message}
-`);
-  };
-  const input = await readEncoding(reader);
-  if (input.error) {
-    if (!options.quiet) await diagnostic("can not read from input file: Success");
-    return { kind: "bom-error", encoding: "" };
-  }
-  const bom = input.bom === "bytes" ? options.assume : input.bom;
-  if (options.verbose) {
-    if (options.assume !== "bytes") await diagnostic(`Assuming UTF-16${options.assume === "le" ? "LE" : "BE"} encoding.`);
-    if (input.bom !== "bytes") await diagnostic(`Input file ${name} has ${encodingLabels[input.bom]} BOM.`);
-  }
-  const wide = bom === "le" || bom === "be";
-  const encoding = wide ? bom === "le" ? "UTF-16LE" : "UTF-16BE" : "";
-  const env = life.budget.context.env;
-  const locale = env.LC_ALL || env.LC_CTYPE || env.LANG || "C";
-  const utf8 = locale === "C.UTF-8" || locale === "C.utf8";
-  if (wide && !options.keepUtf16 && !utf8 && locale !== "C" && locale !== "POSIX") throw new LineEndingError("UTF-16 conversion supports only C/POSIX and C.UTF-8 locales");
-  if (options.addBom || options.keepBom && bom !== "bytes") {
-    const bytes = options.keepUtf16 && wide ? bom === "le" ? [255, 254] : [254, 255] : bom === "gb" ? [132, 49, 149, 51] : [239, 187, 191];
-    for (const byte2 of bytes) await writer.put(byte2);
-    if (options.verbose) await diagnostic(`Writing ${options.keepUtf16 && wide ? encodingLabels[bom] : bom === "gb" ? "GB18030" : "UTF-8"} BOM.`);
-  }
-  const byte = input.byte;
-  let pushed = -1;
-  const unit = () => {
-    if (pushed !== -1) {
-      const value = pushed;
-      pushed = -1;
-      return value;
-    }
-    const lead = byte();
-    if (typeof lead === "number") {
-      if (lead === -1 || !wide) return lead;
-      const trail = byte();
-      if (typeof trail === "number") return trail === -1 ? -1 : bom === "le" ? lead + trail * 256 : lead * 256 + trail;
-      return trail.then((t) => t === -1 ? -1 : bom === "le" ? lead + t * 256 : lead * 256 + t);
-    }
-    return lead.then(async (l) => {
-      if (l === -1 || !wide) return l;
-      const trail = await byte();
-      return trail === -1 ? -1 : bom === "le" ? l + trail * 256 : l * 256 + trail;
-    });
-  };
-  let line = 1;
-  const result = { kind: "ok" };
-  const put = (value) => {
-    if (!wide) {
-      const p = writer.put(options.sevenBit && bom === "bytes" && value >= 128 ? 32 : value);
-      return p ? p.then(() => true) : true;
-    }
-    return putWide(value);
-  };
-  const putWide = async (value) => {
-    if (options.keepUtf16) {
-      await writer.put(bom === "le" ? value & 255 : value >> 8);
-      await writer.put(bom === "le" ? value >> 8 : value & 255);
-      return true;
-    }
-    if (high >= 55296 && high < 56320 && (value < 56320 || value >= 57344)) {
-      await diagnostic("error: Invalid surrogate pair. Missing low surrogate.");
-      result.kind = "unicode";
-      return false;
-    }
-    if (value >= 55296 && value < 56320) {
-      high = value;
-      return true;
-    }
-    if (value >= 56320 && value < 57344) {
-      if (!(high >= 55296 && high < 56320)) {
-        await diagnostic("error: Invalid surrogate pair. Missing high surrogate.");
-        result.kind = "unicode";
-        return false;
-      }
-      value = 65536 + (high & 1023) * 1024 + (value & 1023);
-      high = 1;
-    }
-    if (!utf8 && value > 127) {
-      if (!options.quiet) await diagnostic("Invalid or incomplete multibyte or wide character");
-      result.kind = "unicode";
-      return false;
-    }
-    if (value < 128) await writer.put(value);
-    else if (value < 2048) {
-      await writer.put(192 | value >> 6);
-      await writer.put(128 | value & 63);
-    } else if (value < 65536) {
-      await writer.put(224 | value >> 12);
-      await writer.put(128 | value >> 6 & 63);
-      await writer.put(128 | value & 63);
-    } else {
-      await writer.put(240 | value >> 18);
-      await writer.put(128 | value >> 12 & 63);
-      await writer.put(128 | value >> 6 & 63);
-      await writer.put(128 | value & 63);
-    }
-    return true;
-  };
-  let previous = 0;
-  let last = -1, converted = 0;
-  for (; ; ) {
-    const u = unit();
-    const current = typeof u === "number" ? u : await u;
-    if (current === -1) break;
-    last = current;
-    if (!options.force && current < 32 && current !== 9 && current !== 10 && current !== 12 && current !== 13) {
-      result.kind = "binary";
-      if (!options.quiet) await diagnostic(`Binary symbol 0x${current.toString(16).toUpperCase().padStart(wide ? 4 : 2, "0")} found at line ${line}`);
-      break;
-    }
-    if (direction === "dos2unix") {
-      if (current === 13) {
-        const u2 = unit();
-        pushed = typeof u2 === "number" ? u2 : await u2;
-        if (pushed !== 10) {
-          const ok = put(13);
-          if (!(typeof ok === "boolean" ? ok : await ok)) break;
-        } else {
-          converted++;
-          last = 10;
-          if (options.newline) {
-            const ok = put(10);
-            if (!(typeof ok === "boolean" ? ok : await ok)) break;
-          }
-        }
-      } else {
-        const ok = put(current);
-        if (!(typeof ok === "boolean" ? ok : await ok)) break;
-        if (current === 10) line++;
-      }
-    } else {
-      if (current === 10 && previous !== 13) {
-        converted++;
-        const ok2 = put(13);
-        if (!(typeof ok2 === "boolean" ? ok2 : await ok2)) break;
-      }
-      const ok = put(current);
-      if (!(typeof ok === "boolean" ? ok : await ok)) break;
-      if (current === 10) line++;
-      if (options.newline && current === 10) {
-        const ok1 = put(13);
-        if (!(typeof ok1 === "boolean" ? ok1 : await ok1)) break;
-        const ok2 = put(10);
-        if (!(typeof ok2 === "boolean" ? ok2 : await ok2)) break;
-      }
-      previous = current;
-    }
-  }
-  if (result.kind === "ok" && high >= 55296 && high < 56320) {
-    await diagnostic("error: Invalid surrogate pair. Missing low surrogate.");
-    result.kind = "unicode";
-  }
-  if (result.kind === "ok" && options.addEol && last !== -1 && last !== 10) {
-    if (options.verbose) await diagnostic("Added line break to last line.");
-    if (direction === "unix2dos") await put(13);
-    await put(10);
-  }
-  if (result.kind === "ok" && options.verbose) await diagnostic(`Converted ${converted} out of ${line - 1} line breaks.`);
-  if (stdio || result.kind === "ok") await writer.flush();
-  if (!options.quiet) {
-    if (result.kind === "binary") await diagnostic(`Skipping binary file ${name}`);
-    if (result.kind === "unicode") await diagnostic(`Skipping UTF-16 file ${name}, an UTF-16 conversion error occurred on line ${line}.`);
-  }
-  return { kind: result.kind, encoding };
-}
-
-// packages/safe-bash-line-ending-engine/src/info.ts
-init_platform();
-var FileInformation = class {
-  constructor(life) {
-    this.life = life;
-  }
-  life;
-  flags = /* @__PURE__ */ new Set();
-  headerDone = false;
-  configure(value) {
-    for (const flag of value) {
-      if (!"0dumbtechp".includes(flag)) throw new LineEndingError(`wrong flag '${flag}' for option -i or --info`);
-      this.flags.add(flag);
-    }
-    if (![...value].some((flag) => "dumbtec".includes(flag))) for (const flag of "dumbt") this.flags.add(flag);
-  }
-  async print(direction, reader, options, filename) {
-    if (options.verbose && options.assume !== "bytes") await this.life.diagnostic(`${direction}: Assuming UTF-16${options.assume === "le" ? "LE" : "BE"} encoding.
-`);
-    const input = await readEncoding(reader);
-    if (input.error) {
-      if (!options.quiet) await this.life.diagnostic(`${direction}: can not read from input file: Success
-`);
-      return;
-    }
-    const bom = encodingLabels[input.bom];
-    const encoding = input.bom === "bytes" ? options.assume : input.bom === "le" || input.bom === "be" ? input.bom : "bytes";
-    const byte = input.byte;
-    let dos = 0, unix = 0, mac = 0, previous = -1, last = "noeol", binary = false;
-    for (; ; ) {
-      const b1 = byte();
-      let current = typeof b1 === "number" ? b1 : await b1;
-      if (current === -1) break;
-      if (encoding !== "bytes") {
-        const b2 = byte();
-        const trail = typeof b2 === "number" ? b2 : await b2;
-        if (trail === -1) break;
-        current = encoding === "le" ? current + trail * 256 : current * 256 + trail;
-      }
-      if (current < 32 && ![9, 10, 12, 13].includes(current)) binary = true;
-      if (current === 13) {
-        mac++;
-        last = "mac";
-      } else if (current === 10 && previous === 13) {
-        dos++;
-        mac--;
-        last = "dos";
-      } else if (current === 10) {
-        unix++;
-        last = "unix";
-      } else last = "noeol";
-      previous = current;
-    }
-    const flags = this.flags;
-    if (flags.has("c") && (binary && !options.force || (direction === "dos2unix" ? dos : unix) === 0 && (!options.addEol || last === (direction === "dos2unix" ? "unix" : "dos")))) return;
-    const eol = flags.has("e") || options.addEol && !flags.has("c");
-    const fields = ["d", "u", "m", "b", "t", "e"].filter((flag) => flag === "e" ? eol : flags.has(flag));
-    const separator = fields.length ? "  " : "";
-    const terminator = flags.has("0") ? "\0" : "\n";
-    if (flags.has("p")) filename = filename.slice(Math.max(filename.lastIndexOf("/"), filename.lastIndexOf("\\")) + 1);
-    let text = "";
-    if (flags.has("h") && !this.headerDone) {
-      const labels = { d: "     DOS", u: "    UNIX", m: "     MAC", b: "  BOM     ", t: "  TXTBIN", e: " LASTLN" };
-      text += fields.map((field) => labels[field]).join("") + (filename ? `${separator}FILE` : "") + terminator;
-      this.headerDone = true;
-    }
-    const values = {
-      d: `  ${String(dos).padStart(6)}`,
-      u: `  ${String(unix).padStart(6)}`,
-      m: `  ${String(mac).padStart(6)}`,
-      b: `  ${bom.padEnd(8)}`,
-      t: binary ? "  binary" : "  text  ",
-      e: ` ${last.padEnd(5)} `
-    };
-    text += fields.map((field) => values[field]).join("") + (filename ? separator + filename : "") + terminator;
-    const budget = this.life.budget;
-    budget.check(text.length * 3, budget.limits.maxBufferedBytes, "information buffer bytes");
-    const bytes = new TextEncoder().encode(text);
-    budget.emitted(bytes.length);
-    await this.life.stdout(bytes);
-  }
-};
-
-// packages/safe-bash-command-dos2unix/src/index.ts
-function definition(direction, options) {
-  const limits = settings(options);
-  const command = { name: direction, description: "Convert DOS and Unix line endings in bounded VFS files or streams", async execute(context) {
-    let life;
-    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 admission = { closed: false };
-    const destination = capability ?? stdout;
-    const write = async (bytes) => {
-      life.assertOpen();
-      const method = destination.write;
-      life.assertOpen();
-      await Reflect.apply(method, destination, [bytes]);
-    };
-    const captured = {
-      write,
-      ...capability ? { ownedOutput: { consumerClosed: consumer, write } } : {},
-      ...failureHandler ? { [outputFailure]: failureHandler } : {}
-    };
-    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 status = 0;
-    try {
-      life = new Lifecycle(budget, output, captured, caller, admission);
-      const active = life;
-      const files = new Files(active);
-      const args = await budget.arguments();
-      const flags = { keepBom: direction === "unix2dos", addBom: false, keepUtf16: false, assume: "bytes", force: false, quiet: false, newline: false, sevenBit: false, keepDate: false, newFile: false, addEol: false, verbose: false, allowChown: false };
-      let toStdout = false;
-      const information = new FileInformation(active);
-      const diagnostic = async (text) => {
-        await active.diagnostic(`${direction}: ${text}
-`);
-      };
-      const converted = async (result, name, destination2) => {
-        if (flags.quiet) return;
-        const locale = context.env.LC_ALL || context.env.LC_CTYPE || context.env.LANG || "C";
-        const outFormat = flags.keepUtf16 ? result.encoding : locale === "C" || locale === "POSIX" ? "ANSI_X3.4-1968" : "UTF-8";
-        const encoding = result.encoding ? `${result.encoding} ` : "";
-        const target = result.encoding ? `${outFormat} ` : "";
-        await diagnostic(`converting ${encoding}file ${name} to ${flags.newFile ? `${target}file ${destination2} in ` : target}${direction === "dos2unix" ? "Unix" : "DOS"} format...`);
-      };
-      const file = async (name, destination2) => {
-        budget.file();
-        const inputPath = files.path(name);
-        const outputPath = files.path(destination2);
-        const expected = await files.stat(outputPath);
-        const readOnly = !flags.newFile && (toStdout || information.flags.size > 0);
-        if (!readOnly && expected?.type === "symlink") {
-          if (!flags.quiet) await diagnostic(flags.newFile ? `Skipping ${name}, output file ${destination2} is a symbolic link.` : `Skipping symbolic link ${name}.`);
-          return;
-        }
-        let input = await files.stat(inputPath);
-        if (!input || input.type !== "file" && input.type !== "symlink") {
-          if (!flags.quiet) {
-            if (!input) {
-              status = 2;
-              await diagnostic(`${name}: No such file or directory`);
-            }
-            await diagnostic(`Skipping ${name}, not a regular file.`);
-          }
-          return;
-        }
-        let path = inputPath;
-        if (input.type === "symlink") {
-          path = await files.call((fs) => fs.realpath, [path, { signal: budget.signal }]);
-          path = files.path(path);
-          input = await files.stat(path);
-          if (!input || input.type !== "file") {
-            if (!flags.quiet) await diagnostic(`Skipping symbolic link ${name}, target is not a regular file.`);
-            return;
-          }
-        }
-        if (readOnly) {
-          const reader2 = new Reader(active);
-          try {
-            await reader2.open(path, input);
-            if (information.flags.size) await information.print(direction, reader2, flags, name);
-            else {
-              const writer2 = new Writer(active, (bytes) => active.stdout(bytes));
-              try {
-                const result2 = await convert(direction, reader2, writer2, active, flags, name, true);
-                if (result2.kind === "unicode") status ||= 1;
-                if (result2.kind === "ok") await converted(result2, name, destination2);
-              } finally {
-                writer2.release();
-              }
-            }
-          } finally {
-            await reader2.close();
-          }
-          return;
-        }
-        if (!sameIdentity(input, input) || expected && (expected.type !== "file" || !sameIdentity(expected, expected))) throw new LineEndingError("file conversion requires stable regular-file identities");
-        const reader = new Reader(active);
-        const stage = new Stage(files, outputPath, expected);
-        const writer = new Writer(active, (bytes) => stage.append(bytes));
-        let result;
-        let failed;
-        try {
-          await reader.open(path, input);
-          let opened = false;
-          try {
-            await stage.open();
-            opened = true;
-          } catch (error) {
-            if (error instanceof FsError2 && error.code === "ENOENT") {
-              if (!flags.quiet) {
-                status = 2;
-                await diagnostic("Failed to open temporary output file: No such file or directory");
-                await diagnostic(`problems converting file ${name}${flags.newFile ? ` to file ${destination2}` : ""}`);
-              }
-            } else throw error;
-          }
-          if (opened && await files.stat(outputPath) !== void 0 && expected === void 0) throw new LineEndingError("destination appeared during acquisition");
-          if (opened) result = await convert(direction, reader, writer, active, flags, name, false);
-          await reader.close();
-          if (result?.kind === "ok") {
-            await stage.publish(input, flags);
-            await converted(result, name, destination2);
-          } else if (result?.kind === "unicode") status ||= 1;
-          else if (result?.kind === "bom-error" && !flags.quiet) await diagnostic(`problems converting file ${name}${flags.newFile ? ` to file ${destination2}` : ""}`);
-        } catch (error) {
-          failed = { reason: error };
-        }
-        try {
-          await reader.close();
-          await stage.cleanup();
-        } catch (error) {
-          throw failed ? new AggregateError([failed.reason, error], "line-ending conversion and cleanup failed") : error;
-        } finally {
-          writer.release();
-        }
-        if (failed) throw failed.reason;
-      };
-      const stdin = async () => {
-        const reader = new Reader(active);
-        const writer = new Writer(active, (bytes) => active.stdout(bytes));
-        await reader.open();
-        if (information.flags.size) await information.print(direction, reader, flags, "");
-        else {
-          const result = await convert(direction, reader, writer, active, flags, "stdin", true);
-          if (result.kind === "unicode" || result.kind === "bom-error" || result.kind === "binary" && !flags.quiet) status ||= 1;
-        }
-      };
-      let paired = true, processOptions = true, sawFile = false, stop = false;
-      let index = 0;
-      for (; index < args.length && !stop; index++) {
-        const argument = args[index];
-        if (processOptions && argument.startsWith("-")) {
-          switch (argument) {
-            case "-":
-              sawFile = true;
-              await stdin();
-              break;
-            case "--":
-              processOptions = false;
-              break;
-            case "-b":
-            case "--keep-bom":
-              flags.keepBom = true;
-              break;
-            case "-r":
-            case "--remove-bom":
-              flags.keepBom = false;
-              flags.addBom = false;
-              break;
-            case "-m":
-            case "--add-bom":
-              flags.addBom = true;
-              break;
-            case "-f":
-            case "--force":
-              flags.force = true;
-              break;
-            case "-s":
-            case "--safe":
-              flags.force = false;
-              break;
-            case "-q":
-            case "--quiet":
-              flags.quiet = true;
-              flags.verbose = false;
-              break;
-            case "-v":
-            case "--verbose":
-              flags.verbose = true;
-              flags.quiet = false;
-              break;
-            case "-e":
-            case "--add-eol":
-              flags.addEol = true;
-              break;
-            case "--no-add-eol":
-              flags.addEol = false;
-              break;
-            case "--allow-chown":
-              flags.allowChown = true;
-              break;
-            case "--no-allow-chown":
-              flags.allowChown = false;
-              break;
-            case "-i":
-            case "--info":
-              information.configure("");
-              break;
-            case "-l":
-            case "--newline":
-              flags.newline = true;
-              break;
-            case "-k":
-            case "--keepdate":
-              flags.keepDate = true;
-              break;
-            case "-u":
-            case "--keep-utf16":
-              flags.keepUtf16 = true;
-              break;
-            case "-ul":
-            case "--assume-utf16le":
-              flags.assume = "le";
-              break;
-            case "-ub":
-            case "--assume-utf16be":
-              flags.assume = "be";
-              break;
-            case "-7":
-              flags.sevenBit = true;
-              flags.assume = "bytes";
-              break;
-            case "-ascii":
-              flags.assume = "bytes";
-              flags.sevenBit = false;
-              flags.keepUtf16 = false;
-              break;
-            case "-S":
-            case "--skip-symlink":
-              break;
-            case "-o":
-            case "--oldfile":
-            case "-n":
-            case "--newfile":
-            case "-O":
-            case "--to-stdout":
-              if (!paired) {
-                await diagnostic(`target of file ${args[index - 1]} not specified in new-file mode`);
-                status = 1;
-                sawFile = true;
-                stop = true;
-              }
-              flags.newFile = argument === "-n" || argument === "--newfile";
-              if (argument !== "-O" && argument !== "--to-stdout") information.flags.clear();
-              if (!flags.newFile) toStdout = argument === "-O" || argument === "--to-stdout";
-              break;
-            case "-c":
-            case "--convmode": {
-              const mode = args[++index];
-              if (mode === void 0) {
-                await diagnostic(`option '${argument}' requires an argument`);
-                status = 1;
-                sawFile = true;
-                stop = true;
-              } else if (mode.toLowerCase() === "ascii") {
-                flags.sevenBit = false;
-                flags.assume = "bytes";
-                flags.keepUtf16 = false;
-              } else if (mode.toLowerCase() === "7bit") {
-                flags.sevenBit = true;
-                flags.assume = "bytes";
-              } else {
-                await diagnostic(`invalid ${mode} conversion mode specified`);
-                status = 1;
-                sawFile = true;
-                stop = true;
-              }
-              break;
-            }
-            case "-h":
-            case "--help": {
-              const bytes = new TextEncoder().encode(`Usage: ${direction} [options] [file ...] [-n infile outfile ...]
-Virtual byte/UTF-16 profile:
-  -o -n -O -i[FLAGS] -e -v -b -r -m -f -s -q -k -l -u -ul -ub -7 -ascii --
-  --no-add-eol --allow-chown --no-allow-chown
-`);
-              budget.emitted(bytes.length);
-              await active.stdout(bytes);
-              stop = true;
-              sawFile = true;
-              break;
-            }
-            default:
-              if (argument.startsWith("--info=")) information.configure(argument.slice(7));
-              else if (argument.startsWith("-i")) information.configure(argument.slice(2));
-              else throw new LineEndingError(`unsupported option in virtual profile: ${argument}`);
-          }
-        } else {
-          sawFile = true;
-          if (!flags.newFile) await file(argument, argument);
-          else if (paired) paired = false;
-          else {
-            await file(args[index - 1], argument);
-            paired = true;
-          }
-        }
-      }
-      if (!sawFile) await stdin();
-      if (!paired) {
-        await diagnostic(`target of file ${args[Math.min(index - 1, args.length - 1)]} not specified in new-file mode`);
-        status = 1;
-      }
-    } catch (error) {
-      primary = { reason: error };
-      if (error instanceof LineEndingError && life && !output.signal.aborted) {
-        status = error.status;
-        try {
-          await life.diagnostic(`${direction}: ${error.message}
-`);
-        } catch (reporting) {
-          failure = { reason: new AggregateError([error, reporting], "line-ending 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], "line-ending execution and cleanup failed") : cleanup };
-    }
-    caller.throwIfAborted();
-    output.signal.throwIfAborted();
-    if (life?.diagnosticCancellation) throw life.diagnosticCancellation.reason;
-    if (failure) throw failure.reason;
-    return { exitCode: status };
-  } };
-  if (options.limits === void 0) builtInDirectContextExecutors.add(command.execute);
-  return command;
-}
-function createDos2unixCommand(options = {}) {
-  return definition("dos2unix", options);
-}
-function createUnix2dosCommand(options = {}) {
-  return definition("unix2dos", options);
-}
-function createDos2unixCommands(options = {}) {
-  return [createDos2unixCommand(options), createUnix2dosCommand(options)];
-}
-function dos2unixCommands(options = {}) {
-  const commands = createDos2unixCommands(options);
-  return { name: "line-ending-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 });
-  } };
-}
-
-// packages/safe-bash/src/commands/line-endings/index.ts
-function evalSyncLineEndings(cmdName, inBytes, opArgs, readFileSync, writeFileSync) {
-  let force = false;
-  let quiet = false;
-  let toStdout = false;
-  let newFileMode = false;
-  let addEol = false;
-  let newline = false;
-  let convMode = "ascii";
-  let bomMode = "keep";
-  let endOfOptions = false;
-  const files = [];
-  for (let i = 0; i < opArgs.length; i++) {
-    const a = opArgs[i];
-    if (!endOfOptions && a === "--") {
-      endOfOptions = true;
-      continue;
-    }
-    if (!endOfOptions && a.startsWith("--") && a.length > 2) {
-      if (a === "--quiet") {
-        quiet = true;
-        continue;
-      }
-      if (a === "--force") {
-        force = true;
-        continue;
-      }
-      if (a === "--to-stdout") {
-        toStdout = true;
-        continue;
-      }
-      if (a === "--newfile") {
-        newFileMode = true;
-        continue;
-      }
-      if (a === "--add-eol") {
-        addEol = true;
-        continue;
-      }
-      if (a === "--no-add-eol") {
-        addEol = false;
-        continue;
-      }
-      if (a === "--newline") {
-        newline = true;
-        continue;
-      }
-      if (a === "--no-newline") {
-        newline = false;
-        continue;
-      }
-      if (a === "--remove-bom") {
-        bomMode = "remove";
-        continue;
-      }
-      if (a === "--add-bom") {
-        bomMode = "add";
-        continue;
-      }
-      if (a === "--keep-bom") {
-        bomMode = "keep";
-        continue;
-      }
-      if (a === "--convmode" || a.startsWith("--convmode=")) {
-        const v = a.startsWith("--convmode=") ? a.slice(11) : opArgs[++i];
-        if (v === "mac") {
-          convMode = "mac";
-          continue;
-        }
-        if (v === "ascii") {
-          convMode = "ascii";
-          continue;
-        }
-        return void 0;
-      }
-      return void 0;
-    }
-    if (!endOfOptions && a.startsWith("-") && a.length > 1) {
-      for (let j = 1; j < a.length; j++) {
-        const ch = a[j];
-        if (ch === "q") quiet = true;
-        else if (ch === "f") force = true;
-        else if (ch === "O") toStdout = true;
-        else if (ch === "n") newFileMode = true;
-        else if (ch === "e") addEol = true;
-        else if (ch === "E") addEol = false;
-        else if (ch === "l") newline = true;
-        else if (ch === "N") newline = false;
-        else if (ch === "r") bomMode = "remove";
-        else if (ch === "m") bomMode = "add";
-        else if (ch === "b") bomMode = "keep";
-        else if (ch === "c") {
-          const v = j + 1 < a.length ? a.slice(j + 1) : opArgs[++i];
-          if (v === "mac") convMode = "mac";
-          else if (v === "ascii") convMode = "ascii";
-          else return void 0;
-          break;
-        } else return void 0;
-      }
-      continue;
-    }
-    files.push(a);
-  }
-  if (files.length > 0 && !toStdout) {
-    if (!quiet || !readFileSync || !writeFileSync) return void 0;
-    if (newFileMode && files.length % 2 !== 0) return void 0;
-    const pairs = [];
-    if (newFileMode) {
-      for (let k = 0; k < files.length; k += 2) pairs.push([files[k], files[k + 1]]);
-    } else {
-      for (const f of files) pairs.push([f, f]);
-    }
-    for (const [inPath, outPath] of pairs) {
-      if (inPath === "-" || outPath === "-") return void 0;
-      const b = readFileSync(inPath);
-      if (!b || b.byteLength > 16384) return void 0;
-      const subArgs = [
-        force ? "-fO" : "-O",
-        ...addEol ? ["-e"] : [],
-        ...newline ? ["-l"] : [],
-        ...convMode === "mac" ? ["-c", "mac"] : [],
-        ...bomMode === "remove" ? ["-r"] : bomMode === "add" ? ["-m"] : []
-      ];
-      const converted = evalSyncLineEndings(cmdName, b, subArgs);
-      if (!converted || !writeFileSync(outPath, converted)) return void 0;
-    }
-    return new Uint8Array(0);
-  }
-  const chunks = [];
-  if (files.length === 0) {
-    if (!inBytes || inBytes.byteLength > 16384) return void 0;
-    chunks.push(inBytes);
-  } else {
-    if (!readFileSync) return void 0;
-    for (const f of files) {
-      const b = readFileSync(f);
-      if (!b || b.byteLength > 16384) return void 0;
-      chunks.push(b);
-    }
-  }
-  const out = [];
-  for (const src of chunks) {
-    let startIdx = 0;
-    let hasUtf8Bom = false;
-    if (src.byteLength >= 2) {
-      const b0 = src[0], b1 = src[1];
-      if (b0 === 255 && b1 === 254 || b0 === 254 && b1 === 255 || b0 === 132 && b1 === 49) {
-        return void 0;
-      }
-      if (src.byteLength >= 3 && b0 === 239 && b1 === 187 && src[2] === 191) {
-        hasUtf8Bom = true;
-        startIdx = 3;
-      }
-    }
-    if (!force) {
-      for (let i = startIdx; i < src.byteLength; i++) {
-        const c = src[i];
-        if (c < 32 && c !== 9 && c !== 10 && c !== 12 && c !== 13) return void 0;
-      }
-    }
-    if (bomMode === "add" || bomMode === "keep" && hasUtf8Bom) {
-      out.push(239, 187, 191);
-    }
-    let last = -1;
-    if (cmdName === "dos2unix") {
-      for (let i = startIdx; i < src.byteLength; i++) {
-        const c = src[i];
-        if (convMode === "mac") {
-          if (c === 13 && (i + 1 >= src.byteLength || src[i + 1] !== 10)) {
-            out.push(10);
-            if (newline) out.push(10);
-            last = 10;
-          } else {
-            out.push(c);
-            last = c;
-          }
-        } else if (c === 13 && i + 1 < src.byteLength && src[i + 1] === 10) {
-          out.push(10);
-          if (newline) out.push(10);
-          last = 10;
-          i++;
-        } else {
-          out.push(c);
-          last = c;
-        }
-      }
-      if (addEol && last !== -1 && last !== 10) out.push(10);
-    } else {
-      let prev = 0;
-      for (let i = startIdx; i < src.byteLength; i++) {
-        const c = src[i];
-        if (convMode === "mac") {
-          if (c === 10 && prev !== 13) {
-            out.push(13);
-            if (newline) out.push(13);
-            last = 13;
-          } else {
-            out.push(c);
-            last = c;
-          }
-        } else if (c === 10 && prev !== 13) {
-          out.push(13, 10);
-          if (newline) out.push(13, 10);
-          last = 10;
-        } else {
-          out.push(c);
-          if (newline && c === 10) out.push(13, 10);
-          last = c;
-        }
-        prev = c;
-      }
-      if (addEol && last !== -1 && last !== (convMode === "mac" ? 13 : 10)) {
-        if (convMode === "mac") out.push(13);
-        else out.push(13, 10);
-      }
-    }
-  }
-  return new Uint8Array(out);
-}
-
-export {
-  createDos2unixCommand,
-  createUnix2dosCommand,
-  createDos2unixCommands,
-  dos2unixCommands,
-  evalSyncLineEndings
-};
-//# sourceMappingURL=chunk-6IIFUPN2.js.map