poe-code 15.0.15 → 15.0.17

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

@@ -0,0 +1,1069 @@
+import {
+  writeFileOutput
+} from "./chunk-AZNI263O.js";
+import {
+  dirname,
+  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/line-endings/index.ts
+init_platform();
+
+// packages/safe-bash/src/commands/line-endings/command.ts
+init_platform();
+
+// packages/safe-bash/src/commands/line-endings/internal.ts
+init_platform();
+function settings(options) {
+  const limits = {
+    maxArguments: 1024,
+    maxArgumentBytes: 262144,
+    maxInputBytes: 16777216,
+    maxOutputBytes: 33554432,
+    maxBufferedBytes: 2097152,
+    maxDiagnosticBytes: 65536,
+    maxFiles: 128,
+    maxWork: 134217728,
+    maxEmptyChunks: 1024,
+    maxPathBytes: 4096,
+    maxDepth: 64,
+    maxTempAttempts: 128,
+    chunkSize: 16384,
+    ...options.limits
+  };
+  for (const [name, value] of Object.entries(limits)) if (!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;
+  }
+  context;
+  limits;
+  signal;
+  caller;
+  admission;
+  work = 0;
+  quantum = 0;
+  memory = 0;
+  input = 0;
+  output = 0;
+  diagnostics = 0;
+  files = 0;
+  assertOpen() {
+    this.signal.throwIfAborted();
+    if (this.admission.closed) throw new LineEndingError("command is closed");
+  }
+  check(value, maximum, label) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > maximum) 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");
+  }
+  async step(amount = 1) {
+    this.assertOpen();
+    this.check(this.work + amount, this.limits.maxWork, "work");
+    this.work += amount;
+    this.quantum += amount;
+    if (this.quantum >= 1024) {
+      this.quantum = 0;
+      await yieldTurn(this.caller);
+      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++) {
+        await this.step();
+        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) {
+      await this.step(shellValueByteLength(value));
+      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/src/commands/line-endings/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.signal.throwIfAborted();
+    if (this.closing || this.admission.closed) 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 () => {
+      await this.budget.step();
+      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 }]);
+          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(maximum);
+          this.snapshotBytes = maximum;
+          const readFile = fs.readFile;
+          this.life.assertOpen();
+          const bytes = await Reflect.apply(readFile, fs, [path, { signal, 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");
+          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, []);
+    });
+  }
+  async get() {
+    await this.life.budget.step();
+    this.life.assertOpen();
+    while (this.offset === this.chunk.length) {
+      if (this.ended) return -1;
+      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 size = Math.min(life.budget.limits.chunkSize, life.budget.limits.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;
+  }
+  async put(byte) {
+    await this.life.budget.step();
+    this.life.assertOpen();
+    this.life.budget.emitted(1);
+    this.buffer[this.used++] = byte;
+    if (this.used === this.buffer.length) await this.flush();
+  }
+  async flush() {
+    this.life.assertOpen();
+    if (this.used) {
+      await this.publish(this.buffer.subarray(0, this.used));
+      this.used = 0;
+    }
+  }
+};
+
+// packages/safe-bash/src/commands/line-endings/stage.ts
+init_platform();
+import { retainFileSystemCleanup } from "poe-code/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");
+    }
+    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 && (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 }]);
+    this.created = false;
+  }
+};
+
+// packages/safe-bash/src/commands/line-endings/convert.ts
+init_platform();
+async function convert(direction, reader, writer, life, options, state, name, stdio) {
+  const prefix = [];
+  let bom = "bytes";
+  const diagnostic = async (message) => {
+    await life.diagnostic(`${direction}: ${message}
+`);
+  };
+  const first = await reader.get();
+  let bomError = false;
+  if (first !== -1) {
+    if (first !== 255 && first !== 254 && first !== 239 && first !== 132) prefix.push(first);
+    else {
+      const second = await reader.get();
+      if (second === -1) bomError = 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) bomError = 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) bomError = true;
+            else if (fourth === 51) {
+              bom = "gb";
+              prefix.length = 0;
+            } else prefix.push(fourth);
+          }
+        }
+      }
+    }
+  }
+  if (bomError) {
+    if (!options.quiet) await diagnostic("can not read from input file: Success");
+    return { kind: "bom-error", encoding: "" };
+  }
+  if (bom === "bytes") bom = options.assume;
+  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);
+  }
+  let prefixOffset = 0;
+  const byte = async () => prefixOffset < prefix.length ? prefix[prefixOffset++] : await reader.get();
+  let pushed = -1;
+  const unit = async () => {
+    if (pushed !== -1) {
+      const value = pushed;
+      pushed = -1;
+      return value;
+    }
+    const lead = await byte();
+    if (lead === -1 || !wide) return lead;
+    const trail = await byte();
+    return trail === -1 ? -1 : bom === "le" ? lead + trail * 256 : lead * 256 + trail;
+  };
+  let line = 1;
+  const result = { kind: "ok" };
+  const put = async (value) => {
+    if (!wide) {
+      await writer.put(options.sevenBit && bom === "bytes" && value >= 128 ? 32 : value);
+      return true;
+    }
+    if (options.keepUtf16) {
+      await writer.put(bom === "le" ? value & 255 : value >> 8);
+      await writer.put(bom === "le" ? value >> 8 : value & 255);
+      return true;
+    }
+    if (state.high >= 55296 && state.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) {
+      state.high = value;
+      return true;
+    }
+    if (value >= 56320 && value < 57344) {
+      if (!(state.high >= 55296 && state.high < 56320)) {
+        await diagnostic("error: Invalid surrogate pair. Missing high surrogate.");
+        result.kind = "unicode";
+        return false;
+      }
+      value = 65536 + (state.high & 1023) * 1024 + (value & 1023);
+      state.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;
+  for (; ; ) {
+    let current = await unit();
+    if (current === -1) break;
+    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) {
+        pushed = await unit();
+        if (pushed !== 10) {
+          if (!await put(13)) break;
+        } else if (options.newline && !await put(10)) break;
+      } else {
+        if (current === 10) line++;
+        if (!await put(current)) break;
+      }
+    } else {
+      if (current === 10) {
+        if (!await put(13)) break;
+      } else if (current === 13) {
+        current = await unit();
+        if (current === -1) current = 13;
+        else {
+          if (!await put(13)) break;
+          previous = 13;
+        }
+      }
+      if (current === 10) line++;
+      if (!await put(current)) break;
+      if (options.newline && current === 10 && previous !== 13) {
+        if (!await put(13) || !await put(10)) break;
+      }
+      previous = current;
+    }
+  }
+  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/src/commands/line-endings/command.ts
+function definition(direction, options) {
+  const limits = settings(options);
+  return { 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 };
+      const state = { high: 1 };
+      const diagnostic = async (text) => {
+        await active.diagnostic(`${direction}: ${text}
+`);
+      };
+      const file = async (name, destination2) => {
+        budget.file();
+        const inputPath = files.path(name);
+        const outputPath = files.path(destination2);
+        const expected = await files.stat(outputPath);
+        if (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 (!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 FsError && 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, state, name, false);
+          await reader.close();
+          if (result?.kind === "ok") {
+            await stage.publish(input, flags);
+            if (!flags.quiet) {
+              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...`);
+            }
+          } 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;
+      };
+      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 "--":
+              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;
+              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":
+              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";
+              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 -b -r -m -f -s -q -k -l -u -ul -ub -7 -ascii --
+`);
+              budget.emitted(bytes.length);
+              await active.stdout(bytes);
+              stop = true;
+              sawFile = true;
+              break;
+            }
+            default:
+              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) {
+        const reader = new Reader(active);
+        const writer = new Writer(active, (bytes) => active.stdout(bytes));
+        await reader.open();
+        const result = await convert(direction, reader, writer, active, flags, state, "stdin", true);
+        if (result.kind === "binary" && !flags.quiet) status ||= 1;
+      }
+      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 };
+  } };
+}
+function createDos2unixCommand(options = {}) {
+  return definition("dos2unix", options);
+}
+function createUnix2dosCommand(options = {}) {
+  return definition("unix2dos", options);
+}
+
+// packages/safe-bash/src/commands/line-endings/index.ts
+function createLineEndingCommands(options = {}) {
+  return [createDos2unixCommand(options), createUnix2dosCommand(options)];
+}
+function lineEndingCommands(options = {}) {
+  const commands = createLineEndingCommands(options);
+  return { name: "line-ending-commands", setup(host) {
+    for (const command of commands) host.commands.register(command, { replace: options.replace ?? false });
+  } };
+}
+
+export {
+  createDos2unixCommand,
+  createUnix2dosCommand,
+  createLineEndingCommands,
+  lineEndingCommands
+};
+//# sourceMappingURL=chunk-MVVKEMEG.js.map