@poe-platform/safe-bash 0.1.798 → 0.1.800

package/dist/safe-bash/command-chunks/chunk-TEVJJPTC.js

@@ -0,0 +1,1392 @@
+import {
+  editInPlace,
+  prepareInPlace
+} from "./chunk-CQ5YGOGB.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-sed/src/sed.ts
+init_buffer();
+import { tryReadMemoryFileViewSync } from "@poe-platform/safe-fs/core";
+import { FsError, writeBytes } from "../../safe-bash-contracts/index.js";
+import { writeFileOutput } from "../../safe-bash-contracts/filesystem-output.js";
+import { decodeBytes, encodeBytes, writeEncodedBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+import { assertPathRequirements, requiredFileInput, sedRequirements } from "../../safe-bash-io-engine/commands/search/requirements.js";
+import { Budget, ProgramError, byteString, bytes, command, getCachedLatin1Batch, input, lineRecordBatches, readProgram, virtualPath } from "../../safe-bash-io-engine/commands/text-programs/shared.js";
+import { pathOf } from "../../safe-bash-io-engine/internal.js";
+import { Pattern, trySubstitutePairBatchToBufferSync, trySubstitutePairSync, trySubstitutePairToBufferSync, trySubstituteSync } from "../../safe-bash-regex-engine/text/regex.js";
+var sedProgramCache = /* @__PURE__ */ new Map();
+var EMPTY_STRINGS = Object.freeze([]);
+var EMPTY_SET = /* @__PURE__ */ new Set();
+function tryParseFastPairProgramSync(rawProg, budget) {
+  if (rawProg.length > 256 || rawProg.startsWith("#n")) return void 0;
+  const parts = rawProg.split(/[;\n]/);
+  const instructions = [];
+  const stepsBefore = budget.stepsUsed;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i].trim();
+    if (part.length === 0) continue;
+    if (part.charCodeAt(0) !== 115 || part.length < 4) return void 0;
+    const delim = part[1];
+    if (delim === "\\" || delim === "\n") return void 0;
+    let p = 2;
+    let patStr = "";
+    while (p < part.length && part[p] !== delim) {
+      const ch = part[p++];
+      if (ch === "\\") {
+        if (p >= part.length) return void 0;
+        const next = part[p++];
+        if (next === "[" || next === "]" || next === delim) return void 0;
+        patStr += `\\${next}`;
+      } else {
+        if (ch === "[") return void 0;
+        patStr += ch;
+      }
+    }
+    if (p >= part.length || part[p] !== delim || patStr.length === 0) return void 0;
+    p++;
+    let repStr = "";
+    let repGroupCount = 0;
+    while (p < part.length && part[p] !== delim) {
+      const ch = part[p++];
+      if (ch === "\\") {
+        if (p >= part.length) return void 0;
+        const next = part[p++];
+        if (next === delim) return void 0;
+        if (next >= "1" && next <= "9") repGroupCount = Math.max(repGroupCount, Number(next));
+        repStr += `\\${next}`;
+      } else {
+        repStr += ch;
+      }
+    }
+    if (p >= part.length || part[p] !== delim) return void 0;
+    p++;
+    let global = false;
+    for (; p < part.length; p++) {
+      if (part[p] === "g" && !global) global = true;
+      else return void 0;
+    }
+    let compiled;
+    try {
+      compiled = new Pattern(patStr, false, false);
+    } catch {
+      return void 0;
+    }
+    const compiledInternal = compiled;
+    if (compiledInternal.parsed || repGroupCount > compiled.groupCount) return void 0;
+    if (!compiledInternal.budgetPrepared && (compiledInternal.compiledSteps ?? 0) > 0) {
+      compiledInternal.budgetPrepared = true;
+      budget.step(compiledInternal.compiledSteps);
+    }
+    instructions.push({
+      kind: "s",
+      negate: false,
+      pattern: compiled,
+      replacement: repStr,
+      replacementGroupCount: repGroupCount,
+      global
+    });
+    if (instructions.length > 2) return void 0;
+  }
+  if (instructions.length !== 2) return void 0;
+  const steps = budget.stepsUsed - stepsBefore;
+  const cached = {
+    program: instructions,
+    steps,
+    outputFiles: EMPTY_STRINGS,
+    readFiles: EMPTY_STRINGS
+  };
+  const cacheKey = `0:
+:${Infinity}:${rawProg}`;
+  if (sedProgramCache.size >= 64) sedProgramCache.delete(sedProgramCache.keys().next().value);
+  sedProgramCache.set(cacheKey, cached);
+  return cached;
+}
+async function parse(source, extended, separator, maxProgramInstructions, budget) {
+  const result = [];
+  const groups = [];
+  const labels = /* @__PURE__ */ new Map();
+  let offset = 0;
+  const horizontal = () => {
+    while (source[offset] === " " || source[offset] === "	" || source[offset] === "\r") offset++;
+  };
+  const delimited = (delimiter, regex = false) => {
+    let text = "";
+    let bracket = false;
+    let first = 0;
+    let special = "";
+    while (offset < source.length) {
+      const character = source[offset++];
+      if (character === delimiter && !bracket) return text;
+      if (character === "\\") {
+        if (bracket && source[offset] !== delimiter && source[offset] !== "\n") {
+          text += "\\";
+          first = 0;
+          continue;
+        }
+        const next = source[offset++];
+        if (next === void 0) break;
+        text += next === "\n" || !bracket && next === delimiter && (regex ? !extended && "()|+?{}".includes(next) || "ntrfva".includes(next) : next === "n" || next === "t" || next >= "0" && next <= "9") ? next : `\\${next}`;
+        if (bracket) first = 0;
+      } else {
+        if (character === "\n") throw new ProgramError("unterminated delimited expression");
+        if (regex) {
+          if (!bracket && character === "[") {
+            bracket = true;
+            first = 2;
+          } else if (bracket) {
+            if (special) {
+              if (character === special && source[offset] === "]") {
+                text += character + source[offset++];
+                special = "";
+                continue;
+              }
+            } else if (character === "[" && [":", ".", "="].includes(source[offset] ?? "")) {
+              special = source[offset++];
+              text += character + special;
+              first = 0;
+              continue;
+            } else if (character === "]" && !first) bracket = false;
+            first = first === 2 && character === "^" ? 1 : 0;
+          }
+        }
+        text += character;
+      }
+    }
+    throw new ProgramError(bracket ? "unterminated bracket expression" : "unterminated delimited expression");
+  };
+  const address = async () => {
+    horizontal();
+    const number = /^[0-9]+/u.exec(source.slice(offset));
+    if (number) {
+      offset += number[0].length;
+      const value = Number(number[0]);
+      if (!Number.isSafeInteger(value)) throw new ProgramError("sed line address exceeds safe integer range");
+      if (source[offset] === "~") {
+        offset++;
+        const stepMatch = /^[0-9]+/u.exec(source.slice(offset));
+        if (!stepMatch) throw new ProgramError("invalid step address");
+        offset += stepMatch[0].length;
+        const step = Number(stepMatch[0]);
+        if (!Number.isSafeInteger(step)) throw new ProgramError("sed line address exceeds safe integer range");
+        return { kind: "step", first: value, step };
+      }
+      return { kind: "number", number: value };
+    }
+    if (source[offset] === "$") {
+      offset++;
+      return { kind: "last" };
+    }
+    let delimiter;
+    if (source[offset] === "/") delimiter = source[offset++];
+    else if (source[offset] === "\\" && source[offset + 1] && source[offset + 1] !== "\n") {
+      offset++;
+      delimiter = source[offset++];
+    }
+    if (delimiter !== void 0) {
+      const pattern = delimited(delimiter, true);
+      const ignoreCase = source[offset] === "I";
+      if (ignoreCase) offset++;
+      if (!pattern && ignoreCase) throw new ProgramError("flags on an empty regex are not supported");
+      const compiled = pattern ? new Pattern(pattern, extended, ignoreCase) : void 0;
+      if (compiled) await compiled.prepare(budget);
+      return { kind: "regex", pattern: compiled };
+    }
+    return void 0;
+  };
+  const label = () => {
+    horizontal();
+    const start = offset;
+    while (offset < source.length && ![";", "\n", "}"].includes(source[offset])) offset++;
+    const text = source.slice(start, offset).trim();
+    return text;
+  };
+  const textArgument = (terminator) => {
+    horizontal();
+    if (source[offset] === "\\") {
+      offset++;
+      if (source[offset] === "\n") offset++;
+    }
+    let text = "";
+    while (offset < source.length && source[offset] !== "\n") {
+      const character = source[offset++];
+      if (character === "\\" && offset < source.length) {
+        const next = source[offset++];
+        text += next === "n" ? "\n" : next === "t" ? "	" : next;
+      } else text += character;
+    }
+    return text + terminator;
+  };
+  const fileArgument = () => {
+    horizontal();
+    const start = offset;
+    while (offset < source.length && source[offset] !== "\n") offset++;
+    const file = decodeBytes(encodeBytes(source.slice(start, offset), "latin1"), "utf8");
+    if (!file || file.includes("\0")) throw new ProgramError("file command requires a nonempty filename without NUL");
+    return file;
+  };
+  while (offset < source.length) {
+    horizontal();
+    if (source[offset] === ";" || source[offset] === "\n") {
+      offset++;
+      continue;
+    }
+    if (source[offset] === "#") {
+      while (offset < source.length && source[offset] !== "\n") offset++;
+      continue;
+    }
+    if (offset === source.length) break;
+    if (result.length >= maxProgramInstructions) throw new ProgramError("program instruction limit exceeded");
+    const first = await address();
+    horizontal();
+    let second;
+    if (source[offset] === ",") {
+      offset++;
+      horizontal();
+      if (source[offset] === "+" || source[offset] === "~") {
+        const relKind = source[offset];
+        const relMatch = /^[0-9]+/u.exec(source.slice(offset + 1));
+        if (relMatch) {
+          offset += 1 + relMatch[0].length;
+          const count = Number(relMatch[0]);
+          if (!Number.isSafeInteger(count)) throw new ProgramError("sed line address exceeds safe integer range");
+          second = { kind: relKind === "+" ? "plus" : "tilde", count };
+        }
+      }
+      if (!second) second = await address();
+      if (!first || !second) throw new ProgramError("invalid address range");
+    }
+    if (first?.kind === "number" && first.number === 0 && second?.kind !== "regex" || second?.kind === "number" && second.number === 0) throw new ProgramError("zero address requires a 0,/regex/ range");
+    horizontal();
+    const negate = source[offset] === "!";
+    if (negate) {
+      offset++;
+      horizontal();
+    }
+    const kind = source[offset++];
+    if (kind === void 0) throw new ProgramError("missing sed command");
+    const instruction = { kind, negate, ...first ? { first } : {}, ...second ? { second } : {} };
+    if (kind === "{") {
+      groups.push(result.length);
+      result.push(instruction);
+      continue;
+    }
+    if (kind === "}") {
+      if (first || negate) throw new ProgramError("closing group cannot have an address");
+      const start = groups.pop();
+      if (start === void 0) throw new ProgramError("unmatched '}'");
+      result[start].jump = result.length + 1;
+    } else if (kind === "s") {
+      const delimiter = source[offset++];
+      if (!delimiter || delimiter === "\\" || delimiter === "\n") throw new ProgramError("invalid substitution delimiter");
+      const pattern = delimited(delimiter, true);
+      instruction.replacement = delimited(delimiter);
+      instruction.replacementGroupCount = 0;
+      for (let index = 0; index < instruction.replacement.length; index++) {
+        if (instruction.replacement[index] !== "\\") continue;
+        const escaped = instruction.replacement[++index];
+        if (escaped !== void 0 && escaped >= "1" && escaped <= "9") {
+          instruction.replacementGroupCount = Math.max(instruction.replacementGroupCount, Number(escaped));
+        }
+      }
+      let ignoreCase = false;
+      while (offset < source.length && ![";", "\n", "}", " ", "	", "#"].includes(source[offset])) {
+        const flag = source[offset++];
+        if (flag === "g" && !instruction.global) instruction.global = true;
+        else if (flag === "p" && !instruction.print) instruction.print = true;
+        else if ((flag === "i" || flag === "I") && !ignoreCase) ignoreCase = true;
+        else if (flag === "w" && instruction.file === void 0) {
+          instruction.file = fileArgument();
+          break;
+        } else if (/^[1-9]$/u.test(flag) && instruction.occurrence === void 0) {
+          const rest = /^[0-9]*/u.exec(source.slice(offset))[0];
+          offset += rest.length;
+          instruction.occurrence = Number(flag + rest);
+          if (!Number.isSafeInteger(instruction.occurrence)) throw new ProgramError("invalid substitution occurrence");
+        } else throw new ProgramError(`unsupported substitution flag '${flag}'`);
+      }
+      if (!pattern && ignoreCase) throw new ProgramError("flags on an empty regex are not supported");
+      if (pattern) {
+        instruction.pattern = new Pattern(pattern, extended, ignoreCase);
+        if (instruction.replacementGroupCount > instruction.pattern.groupCount) throw new ProgramError("replacement references an undefined capture group");
+        await instruction.pattern.prepare(budget);
+      }
+    } else if (kind === "r" || kind === "w") {
+      if (kind === "r" && second) throw new ProgramError("read accepts at most one address");
+      instruction.file = fileArgument();
+    } else if (kind === "a" || kind === "i" || kind === "c") instruction.text = textArgument(kind === "a" ? "\n" : separator);
+    else if (kind === "b" || kind === "t" || kind === "T" || kind === ":") {
+      instruction.text = label();
+      if (first && kind === ":") throw new ProgramError("labels cannot have addresses");
+      if (kind === ":") {
+        if (!instruction.text || labels.has(instruction.text)) throw new ProgramError("empty or duplicate branch label");
+        labels.set(instruction.text, result.length);
+      }
+    } else if (kind === "q" || kind === "Q") {
+      if (second) throw new ProgramError("quit accepts at most one address");
+      horizontal();
+      const status = /^[0-9]+/u.exec(source.slice(offset));
+      if (status) {
+        offset += status[0].length;
+        instruction.status = Number(status[0]);
+        if (instruction.status > 255) throw new ProgramError("quit status exceeds 255");
+      }
+    } else if (kind === "y") {
+      const delimiter = source[offset++];
+      if (!delimiter || delimiter === "\\" || delimiter === "\n") throw new ProgramError("invalid translation delimiter");
+      const decode = (text) => text.replace(/\\(.)/gsu, (_whole, escaped) => escaped === "n" ? "\n" : escaped === "t" ? "	" : escaped);
+      const from = decode(delimited(delimiter));
+      const to = decode(delimited(delimiter));
+      if (from.length !== to.length) throw new ProgramError("translation sets have different lengths");
+      instruction.translation = new Map([...from].map((character, index) => [character, to[index]]));
+    } else if (!"pdDPhHgGxnN=lzF".includes(kind)) throw new ProgramError(`unsupported sed command '${kind}'`);
+    result.push(instruction);
+    horizontal();
+    if (offset < source.length && ![";", "\n", "}", "#"].includes(source[offset])) throw new ProgramError(`unexpected text after '${kind}' command`);
+  }
+  if (groups.length) throw new ProgramError("unclosed sed group");
+  for (const instruction of result) if (["b", "t", "T"].includes(instruction.kind)) {
+    const target = instruction.text ? labels.get(instruction.text) : result.length;
+    if (target === void 0) throw new ProgramError(`undefined branch label '${instruction.text}'`);
+    instruction.jump = target;
+  }
+  return result;
+}
+async function* nullRecords(context, files, budget) {
+  const names = files.length ? files : ["-"];
+  for (let fileIndex = 0; fileIndex < names.length; fileIndex++) {
+    const file = names[fileIndex];
+    let pending = "";
+    for await (const chunk of input(context, file)) {
+      budget.step();
+      let start = 0;
+      while (start < chunk.byteLength) {
+        const end = chunk.indexOf(0, start);
+        const stop = end < 0 ? chunk.byteLength : end;
+        if (pending.length + stop - start > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+        pending += decodeBytes(encodeBytes(chunk.subarray(start, stop)), "latin1");
+        if (end < 0) break;
+        yield { text: pending, terminated: true, file, fileIndex };
+        pending = "";
+        start = end + 1;
+      }
+    }
+    if (pending) yield { text: pending, terminated: false, file, fileIndex };
+  }
+}
+var STDOUT_CAP = 65536;
+var STDOUT_FLUSH = 6e4;
+async function execute(program, context, files, quiet, budget, separator, outputState, lineLength) {
+  const useBatches = separator !== "\0";
+  const batchSource = useBatches ? lineRecordBatches(context, files, budget) : void 0;
+  const singleSource = useBatches ? void 0 : nullRecords(context, files, budget);
+  let currentBatch;
+  let currentBatchLen = 0;
+  let batchIndex = 0;
+  const sharedBatchRecord = {
+    text: "",
+    terminated: true,
+    file: "",
+    fileIndex: 0
+  };
+  const fillFromBatch = (batch, idx, target) => {
+    if (idx < batch.ends.length) {
+      const start = idx === 0 ? 0 : batch.ends[idx - 1] + 1;
+      const end = batch.ends[idx];
+      const slice = batch.text.slice(start, end);
+      target.text = idx === 0 && batch.firstLinePrefix ? batch.firstLinePrefix + slice : slice;
+      target.terminated = true;
+    } else {
+      target.text = batch.trailingText;
+      target.terminated = false;
+    }
+    target.file = batch.file;
+    target.fileIndex = batch.fileIndex;
+    return target;
+  };
+  let currentRecord;
+  let followingRecord;
+  if (batchSource) {
+    const firstBatch = await batchSource.next();
+    if (!firstBatch.done) {
+      currentBatch = firstBatch.value;
+      currentBatchLen = currentBatch.ends.length + (currentBatch.trailingText !== void 0 ? 1 : 0);
+      if (currentBatchLen > 0) {
+        currentRecord = fillFromBatch(currentBatch, 0, sharedBatchRecord);
+        batchIndex = 1;
+      }
+    }
+  } else {
+    const first = await singleSource.next();
+    if (!first.done) currentRecord = first.value;
+  }
+  const peekNextRecord = async () => {
+    if (followingRecord !== void 0) return followingRecord ?? void 0;
+    if (batchSource) {
+      if (currentBatch && batchIndex < currentBatchLen) {
+        followingRecord = fillFromBatch(currentBatch, batchIndex, { text: "", terminated: true, file: "", fileIndex: 0 });
+        return followingRecord;
+      }
+      const nextBatch = await batchSource.next();
+      if (nextBatch.done) {
+        followingRecord = null;
+        return void 0;
+      }
+      currentBatch = nextBatch.value;
+      currentBatchLen = currentBatch.ends.length + (currentBatch.trailingText !== void 0 ? 1 : 0);
+      if (currentBatchLen === 0) {
+        followingRecord = null;
+        return void 0;
+      }
+      batchIndex = 0;
+      followingRecord = fillFromBatch(currentBatch, 0, { text: "", terminated: true, file: "", fileIndex: 0 });
+      return followingRecord;
+    }
+    const next = await singleSource.next();
+    followingRecord = next.done ? null : next.value;
+    return followingRecord ?? void 0;
+  };
+  const readNextRecord = async () => {
+    if (followingRecord !== void 0) {
+      const next2 = followingRecord ?? void 0;
+      followingRecord = void 0;
+      if (batchSource && next2 !== void 0 && currentBatch && batchIndex < currentBatchLen) {
+        batchIndex++;
+      }
+      return next2;
+    }
+    if (batchSource) {
+      if (currentBatch && batchIndex < currentBatchLen) {
+        return fillFromBatch(currentBatch, batchIndex++, sharedBatchRecord);
+      }
+      const nextBatch = await batchSource.next();
+      if (nextBatch.done) return void 0;
+      currentBatch = nextBatch.value;
+      currentBatchLen = currentBatch.ends.length + (currentBatch.trailingText !== void 0 ? 1 : 0);
+      if (currentBatchLen === 0) return void 0;
+      batchIndex = 1;
+      return fillFromBatch(currentBatch, 0, sharedBatchRecord);
+    }
+    const next = await singleSource.next();
+    return next.done ? void 0 : next.value;
+  };
+  const prepareRecord = async (record2) => {
+    if (record2.terminated || files.length < 2) return record2;
+    const next = await peekNextRecord();
+    return next !== void 0 && next.fileIndex !== record2.fileIndex ? { ...record2, terminated: true } : record2;
+  };
+  let number = 0;
+  let hold = "";
+  let holdTerminated = true;
+  const STDOUT_CAP2 = 65536;
+  const STDOUT_FLUSH2 = 6e4;
+  const stdoutSync = typeof context.stdout.writeSync === "function" ? context.stdout : void 0;
+  let stdoutBuf;
+  let stdoutLen = 0;
+  const sepCode = separator.charCodeAt(0) & 255;
+  const appendStdout = (text) => {
+    const tLen = text.length;
+    if (tLen === 0) return;
+    if (!stdoutBuf) {
+      stdoutBuf = new Uint8Array(Math.max(STDOUT_CAP2, tLen + 1));
+    } else if (stdoutLen + tLen > stdoutBuf.length) {
+      const grown = new Uint8Array(Math.max(stdoutBuf.length * 2, stdoutLen + tLen + 1));
+      grown.set(stdoutBuf.subarray(0, stdoutLen), 0);
+      stdoutBuf = grown;
+    }
+    writeEncodedBytes(stdoutBuf, text, stdoutLen, tLen, "latin1");
+    stdoutLen += tLen;
+  };
+  const appendStdoutSep = () => {
+    if (!stdoutBuf) {
+      stdoutBuf = new Uint8Array(STDOUT_CAP2);
+    } else if (stdoutLen + 1 > stdoutBuf.length) {
+      const grown = new Uint8Array(stdoutBuf.length * 2);
+      grown.set(stdoutBuf.subarray(0, stdoutLen), 0);
+      stdoutBuf = grown;
+    }
+    stdoutBuf[stdoutLen++] = sepCode;
+  };
+  const flushStdout = () => {
+    if (stdoutLen > 0 && stdoutBuf) {
+      const flushedLen = stdoutLen;
+      const chunk = new Uint8Array(stdoutBuf.buffer, stdoutBuf.byteOffset, flushedLen);
+      stdoutLen = 0;
+      context.signal.throwIfAborted();
+      if (stdoutSync) {
+        stdoutSync.writeSync(chunk);
+        return void 0;
+      }
+      return writeBytes(context.stdout, encodeBytes(chunk), context.signal);
+    }
+    return void 0;
+  };
+  const joinSpace = (left, right) => {
+    if (left.length + separator.length + right.length > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+    return left + separator + right;
+  };
+  const emit = (text, terminated = true) => {
+    if (outputState.stdoutUnterminated) appendStdoutSep();
+    appendStdout(text);
+    outputState.stdoutUnterminated = !terminated;
+    if (!useBatches || stdoutLen >= STDOUT_FLUSH2) return flushStdout();
+    return void 0;
+  };
+  let lastPattern;
+  const active = /* @__PURE__ */ new Map();
+  for (let pc = 0; pc < program.length; pc++) {
+    const first = program[pc].first;
+    if (first?.kind === "number" && first.number === 0) active.set(pc, 0);
+  }
+  const getPattern = (pattern2) => {
+    if (pattern2) lastPattern = pattern2;
+    if (!lastPattern) throw new ProgramError("no previous regular expression");
+    return lastPattern;
+  };
+  const appended = [];
+  let appendedSize = 0;
+  const append = (item) => {
+    appendedSize += (item.text ?? item.file ?? "").length + 32;
+    if (appendedSize > budget.maxBufferBytes) throw new ProgramError("append queue buffer limit exceeded");
+    appended.push(item);
+  };
+  let record;
+  let pattern = "";
+  let substituted = false;
+  let deleted = false;
+  let quit = false;
+  let status = 0;
+  const print = () => {
+    if (outputState.stdoutUnterminated) appendStdoutSep();
+    appendStdout(pattern);
+    if (record.terminated) appendStdoutSep();
+    outputState.stdoutUnterminated = !record.terminated;
+    if (!useBatches || stdoutLen >= STDOUT_FLUSH2) return flushStdout();
+    return void 0;
+  };
+  const flushSlow = async (printPattern) => {
+    if (appended.length > 0) {
+      await assertPathRequirements(context, sedRequirements, ["script-read"], appended.flatMap((item) => item.file === void 0 ? [] : [item.file]));
+    }
+    if (printPattern && !quiet && !deleted) {
+      const p = print();
+      if (p) await p;
+    }
+    if (outputState.stdoutUnterminated && (appended.length || quit)) {
+      appendStdoutSep();
+      if (stdoutLen >= STDOUT_FLUSH2) await flushStdout();
+      outputState.stdoutUnterminated = false;
+    }
+    for (const item of appended) {
+      if (item.text !== void 0) {
+        appendStdout(item.text);
+        if (stdoutLen >= STDOUT_FLUSH2) await flushStdout();
+        continue;
+      }
+      await flushStdout();
+      const path = virtualPath(context, item.file);
+      try {
+        for await (const chunk of requiredFileInput(context, sedRequirements, "script-read", path, budget.maxBufferBytes)) {
+          budget.step();
+          const pendingCheck = budget.checkpointSync();
+          if (pendingCheck) await pendingCheck;
+          if (chunk.byteLength > budget.maxBufferBytes) throw new ProgramError("read buffer limit exceeded");
+          await writeBytes(context.stdout, chunk, context.signal);
+        }
+      } catch (error) {
+        context.signal.throwIfAborted();
+        if (!(error instanceof FsError) || !["ENOENT", "EACCES", "EPERM", "EISDIR", "ENOTDIR"].includes(error.code)) throw error;
+      }
+    }
+    appended.length = 0;
+    appendedSize = 0;
+  };
+  const flush = (printPattern = true) => {
+    if (appended.length === 0 && !quit) {
+      if (printPattern && !quiet && !deleted) return print();
+      return void 0;
+    }
+    return flushSlow(printPattern);
+  };
+  const writeFile = async (file) => {
+    if (stdoutLen > 0) await flushStdout();
+    const path = virtualPath(context, file);
+    const terminated = record.terminated || separator === "\n";
+    const text = (outputState.unterminatedFiles.has(path) ? separator : "") + pattern + (terminated ? separator : "");
+    await writeFileOutput(context, bytes(text), (chunk) => context.fs.appendFile(path, chunk, { signal: context.signal }));
+    if (terminated) outputState.unterminatedFiles.delete(path);
+    else outputState.unterminatedFiles.add(path);
+  };
+  const matches = (address) => {
+    if (address.kind === "number") return number === address.number;
+    if (address.kind === "step") return address.step === 0 ? number === address.first : number >= address.first && (number - address.first) % address.step === 0;
+    if (address.kind === "plus" || address.kind === "tilde") return false;
+    if (address.kind === "last") {
+      if (batchSource && batchIndex < currentBatchLen) return false;
+      return peekNextRecord().then((next) => next === void 0);
+    }
+    return getPattern(address.pattern).tryTestSync(pattern, budget);
+  };
+  try {
+    while (currentRecord !== void 0) {
+      budget.step();
+      number++;
+      record = currentRecord.terminated || files.length < 2 ? currentRecord : await prepareRecord(currentRecord);
+      pattern = record.text;
+      substituted = false;
+      deleted = false;
+      quit = false;
+      status = 0;
+      for (let pc = 0; pc < program.length; ) {
+        budget.step();
+        const instruction = program[pc];
+        if (number === 1 || (number & 31) === 0 || instruction.kind === "b" || instruction.kind === "t" || instruction.kind === "T" || instruction.kind === "D") {
+          const pendingCheck = budget.checkpointSync();
+          if (pendingCheck) await pendingCheck;
+        }
+        let selected = true;
+        let ending = false;
+        if (instruction.first) {
+          if (instruction.second) {
+            if (active.has(pc)) {
+              const startLine = active.get(pc);
+              if (instruction.second.kind === "number" && number > instruction.second.number) selected = false;
+              const endMatch = instruction.second.kind === "number" ? number >= instruction.second.number : instruction.second.kind === "plus" ? number >= startLine + instruction.second.count : instruction.second.kind === "tilde" ? instruction.second.count === 0 || number > startLine && number % instruction.second.count === 0 : matches(instruction.second);
+              ending = endMatch instanceof Promise ? await endMatch : endMatch;
+              if (ending) active.delete(pc);
+            } else {
+              const firstMatch = matches(instruction.first);
+              selected = firstMatch instanceof Promise ? await firstMatch : firstMatch;
+              if (selected) {
+                ending = instruction.second.kind === "number" && number >= instruction.second.number || (instruction.second.kind === "plus" || instruction.second.kind === "tilde") && instruction.second.count === 0 || instruction.second.kind === "last" && await peekNextRecord() === void 0;
+                if (!ending) active.set(pc, number);
+              }
+            }
+          } else {
+            const firstMatch = matches(instruction.first);
+            selected = firstMatch instanceof Promise ? await firstMatch : firstMatch;
+          }
+        }
+        if (instruction.negate) selected = !selected;
+        if (!selected) {
+          pc = instruction.kind === "{" ? instruction.jump : pc + 1;
+          continue;
+        }
+        switch (instruction.kind) {
+          case "p": {
+            const p = print();
+            if (p) await p;
+            break;
+          }
+          case "P": {
+            const end = pattern.indexOf(separator);
+            const p = emit(end < 0 ? pattern + (record.terminated ? separator : "") : pattern.slice(0, end + 1), end >= 0 || record.terminated);
+            if (p) await p;
+            break;
+          }
+          case "=": {
+            const p = emit(`${number}${separator}`);
+            if (p) await p;
+            break;
+          }
+          case "l": {
+            const escapes = { "\x07": "\\a", "\b": "\\b", "\f": "\\f", "\n": "\\n", "\r": "\\r", "	": "\\t", "\v": "\\v", "\\": "\\\\" };
+            let line = "";
+            for (let offset = 0; offset <= pattern.length; offset++) {
+              budget.step();
+              await budget.checkpointSync();
+              const character = pattern[offset];
+              const lineEnd = character === "\n" && separator === "\n";
+              const token = character === void 0 || lineEnd ? "$" : escapes[character] ?? (character.charCodeAt(0) < 32 || character.charCodeAt(0) >= 127 ? `\\${character.charCodeAt(0).toString(8).padStart(3, "0")}` : character);
+              if (lineLength > 0 && character !== void 0 && !lineEnd && line.length + token.length >= lineLength) {
+                await emit(line + "\\" + separator);
+                line = "";
+              }
+              line = budget.check(line + token);
+              if (lineEnd) {
+                await emit(line + separator);
+                line = "";
+              }
+            }
+            await emit(line + separator);
+            break;
+          }
+          case "d":
+            deleted = true;
+            pc = program.length;
+            continue;
+          case "D": {
+            const end = pattern.indexOf(separator);
+            if (end < 0) {
+              deleted = true;
+              pc = program.length;
+            } else {
+              pattern = pattern.slice(end + 1);
+              pc = 0;
+            }
+            continue;
+          }
+          case "q":
+            quit = true;
+            status = instruction.status ?? 0;
+            pc = program.length;
+            continue;
+          case "Q":
+            deleted = true;
+            quit = true;
+            status = instruction.status ?? 0;
+            pc = program.length;
+            continue;
+          case "z":
+            pattern = "";
+            break;
+          case "F": {
+            const p = emit(`${record.file}${separator}`);
+            if (p) await p;
+            break;
+          }
+          case "a":
+            append({ text: instruction.text });
+            break;
+          case "r":
+            append({ file: instruction.file });
+            break;
+          case "w":
+            await writeFile(instruction.file);
+            break;
+          case "i":
+            await emit(instruction.text);
+            break;
+          case "c":
+            if (!instruction.second || ending || instruction.negate || await peekNextRecord() === void 0) await emit(instruction.text);
+            deleted = true;
+            pc = program.length;
+            continue;
+          case "h":
+            hold = pattern;
+            holdTerminated = record.terminated;
+            break;
+          case "H":
+            hold = joinSpace(hold, pattern);
+            holdTerminated = record.terminated;
+            break;
+          case "g":
+            pattern = hold;
+            record = { ...record, terminated: holdTerminated };
+            break;
+          case "G":
+            pattern = joinSpace(pattern, hold);
+            record = { ...record, terminated: holdTerminated };
+            break;
+          case "x": {
+            [pattern, hold] = [hold, pattern];
+            const terminated = record.terminated;
+            record = { ...record, terminated: holdTerminated };
+            holdTerminated = terminated;
+            break;
+          }
+          case "s": {
+            const expression = getPattern(instruction.pattern);
+            if (instruction.replacementGroupCount > expression.groupCount) throw new ProgramError("replacement references an undefined capture group");
+            if (!instruction.first && !instruction.second && !instruction.negate && !instruction.print && !instruction.file && pc + 1 < program.length) {
+              const nextInst = program[pc + 1];
+              if (nextInst.kind === "s" && !nextInst.first && !nextInst.second && !nextInst.negate && !nextInst.print && !nextInst.file && nextInst.pattern) {
+                const nextExpr = nextInst.pattern;
+                if (nextInst.replacementGroupCount <= nextExpr.groupCount) {
+                  const canPairAnchored = expression.getFastPrefixInfo()?.anchoredStart === true;
+                  if (canPairAnchored && pc === 0 && program.length === 2 && !quiet && !deleted && appended.length === 0 && record.terminated && !outputState.stdoutUnterminated) {
+                    if (!stdoutBuf) stdoutBuf = new Uint8Array(STDOUT_CAP2);
+                    const newPosOrPromise = trySubstitutePairToBufferSync(
+                      pattern,
+                      expression,
+                      instruction.replacement,
+                      instruction.global ?? false,
+                      instruction.occurrence ?? 1,
+                      nextExpr,
+                      nextInst.replacement,
+                      nextInst.global ?? false,
+                      nextInst.occurrence ?? 1,
+                      budget,
+                      stdoutBuf,
+                      stdoutLen,
+                      sepCode
+                    );
+                    const newPos = typeof newPosOrPromise === "number" ? newPosOrPromise : await newPosOrPromise;
+                    if (newPos >= 0) {
+                      lastPattern = nextExpr;
+                      stdoutLen = newPos;
+                      budget.step();
+                      if (!useBatches || stdoutLen >= STDOUT_FLUSH2) {
+                        const p = flushStdout();
+                        if (p) await p;
+                      }
+                      if (batchSource && currentBatch && followingRecord === void 0) {
+                        const batchText = currentBatch.text;
+                        const batchEnds = currentBatch.ends;
+                        const endsLen = batchEnds.length;
+                        const g1 = instruction.global ?? false;
+                        const o1 = instruction.occurrence ?? 1;
+                        const r1 = instruction.replacement;
+                        const g2 = nextInst.global ?? false;
+                        const o2 = nextInst.occurrence ?? 1;
+                        const r2 = nextInst.replacement;
+                        while (batchIndex < endsLen) {
+                          if (batchIndex === 0 && currentBatch.firstLinePrefix) break;
+                          const lStart = batchIndex === 0 ? 0 : batchEnds[batchIndex - 1] + 1;
+                          const lEnd = batchEnds[batchIndex];
+                          if (!stdoutBuf) stdoutBuf = new Uint8Array(STDOUT_CAP2);
+                          const nextPosOrPromise = trySubstitutePairToBufferSync(
+                            batchText,
+                            expression,
+                            r1,
+                            g1,
+                            o1,
+                            nextExpr,
+                            r2,
+                            g2,
+                            o2,
+                            budget,
+                            stdoutBuf,
+                            stdoutLen,
+                            sepCode,
+                            lStart,
+                            lEnd
+                          );
+                          const nextPos = typeof nextPosOrPromise === "number" ? nextPosOrPromise : await nextPosOrPromise;
+                          if (nextPos < 0) break;
+                          batchIndex++;
+                          number++;
+                          budget.step(3);
+                          if ((number & 31) === 0) {
+                            const pendingCheck = budget.checkpointSync();
+                            if (pendingCheck) await pendingCheck;
+                          }
+                          stdoutLen = nextPos;
+                          if (stdoutLen >= STDOUT_FLUSH2) {
+                            const p = flushStdout();
+                            if (p) await p;
+                          }
+                        }
+                      }
+                      deleted = true;
+                      pc += 2;
+                      continue;
+                    }
+                  }
+                  if (!canPairAnchored && pc === 0 && program.length === 2 && !quiet && !deleted && appended.length === 0 && record.terminated && !outputState.stdoutUnterminated && expression.canFindSync() && nextExpr.canFindSync()) {
+                    const g1 = instruction.global ?? false;
+                    const o1 = instruction.occurrence ?? 1;
+                    const r1 = instruction.replacement;
+                    const g2 = nextInst.global ?? false;
+                    const o2 = nextInst.occurrence ?? 1;
+                    const r2 = nextInst.replacement;
+                    const c1OrP = trySubstituteSync(pattern, expression, r1, budget, g1, o1);
+                    const c1 = c1OrP instanceof Promise ? await c1OrP : c1OrP;
+                    const c2OrP = trySubstituteSync(c1.text, nextExpr, r2, budget, g2, o2);
+                    const c2 = c2OrP instanceof Promise ? await c2OrP : c2OrP;
+                    lastPattern = nextExpr;
+                    appendStdout(c2.text);
+                    appendStdoutSep();
+                    if (!useBatches || stdoutLen >= STDOUT_FLUSH2) {
+                      const p = flushStdout();
+                      if (p) await p;
+                    }
+                    if (batchSource && currentBatch && followingRecord === void 0) {
+                      const batchText = currentBatch.text;
+                      const batchEnds = currentBatch.ends;
+                      const endsLen = batchEnds.length;
+                      while (batchIndex < endsLen) {
+                        if (batchIndex === 0 && currentBatch.firstLinePrefix) break;
+                        const lStart = batchIndex === 0 ? 0 : batchEnds[batchIndex - 1] + 1;
+                        const lEnd = batchEnds[batchIndex];
+                        const lineStr = batchText.slice(lStart, lEnd);
+                        const s1OrP = trySubstituteSync(lineStr, expression, r1, budget, g1, o1);
+                        const s1 = s1OrP instanceof Promise ? await s1OrP : s1OrP;
+                        const s2OrP = trySubstituteSync(s1.text, nextExpr, r2, budget, g2, o2);
+                        const s2 = s2OrP instanceof Promise ? await s2OrP : s2OrP;
+                        batchIndex++;
+                        number++;
+                        budget.step(3);
+                        if ((number & 31) === 0) {
+                          const pendingCheck = budget.checkpointSync();
+                          if (pendingCheck) await pendingCheck;
+                        }
+                        appendStdout(s2.text);
+                        appendStdoutSep();
+                        if (stdoutLen >= STDOUT_FLUSH2) {
+                          const p = flushStdout();
+                          if (p) await p;
+                        }
+                      }
+                    }
+                    deleted = true;
+                    pc += 2;
+                    continue;
+                  }
+                  const pairedOrPromise = !canPairAnchored ? void 0 : trySubstitutePairSync(
+                    pattern,
+                    expression,
+                    instruction.replacement,
+                    instruction.global ?? false,
+                    instruction.occurrence ?? 1,
+                    nextExpr,
+                    nextInst.replacement,
+                    nextInst.global ?? false,
+                    nextInst.occurrence ?? 1,
+                    budget
+                  );
+                  const paired = pairedOrPromise instanceof Promise ? await pairedOrPromise : pairedOrPromise;
+                  if (paired !== void 0) {
+                    lastPattern = nextExpr;
+                    pattern = paired.text;
+                    if (paired.substituted) substituted = true;
+                    budget.step();
+                    pc += 2;
+                    continue;
+                  }
+                }
+              }
+            }
+            const changedOrPromise = trySubstituteSync(pattern, expression, instruction.replacement, budget, instruction.global ?? false, instruction.occurrence ?? 1);
+            const changed = changedOrPromise instanceof Promise ? await changedOrPromise : changedOrPromise;
+            pattern = changed.text;
+            if (changed.count) {
+              substituted = true;
+              if (instruction.print) {
+                const p = print();
+                if (p) await p;
+              }
+              if (instruction.file) await writeFile(instruction.file);
+            }
+            break;
+          }
+          case "y": {
+            budget.step(pattern.length);
+            const translated = new Uint8Array(pattern.length);
+            for (let index = 0; index < pattern.length; index++) {
+              if (index % 256 === 0) await budget.checkpointSync();
+              translated[index] = (instruction.translation.get(pattern[index]) ?? pattern[index]).charCodeAt(0);
+            }
+            pattern = decodeBytes(translated, "latin1");
+            break;
+          }
+          case "b":
+            pc = instruction.jump;
+            continue;
+          case "t":
+          case "T": {
+            const branch = instruction.kind === "t" ? substituted : !substituted;
+            substituted = false;
+            if (branch) {
+              pc = instruction.jump;
+              continue;
+            }
+            break;
+          }
+          case "n":
+          case "N": {
+            if (instruction.kind === "n") {
+              const p = flush();
+              if (p) await p;
+            } else if (await peekNextRecord() !== void 0) {
+              const p = flush(false);
+              if (p) await p;
+            }
+            const next = await readNextRecord();
+            if (next === void 0) {
+              if (instruction.kind === "N") {
+                const p = flush(false);
+                if (p) await p;
+              }
+              return { status: 0, quit: false };
+            }
+            record = next.terminated || files.length < 2 ? next : await prepareRecord(next);
+            number++;
+            pattern = instruction.kind === "N" ? joinSpace(pattern, record.text) : record.text;
+            substituted = false;
+            break;
+          }
+        }
+        pc++;
+      }
+      const flushPending = flush();
+      if (flushPending) await flushPending;
+      if (quit) return { status, quit: true };
+      currentRecord = followingRecord === void 0 && batchSource && currentBatch && batchIndex < currentBatchLen ? fillFromBatch(currentBatch, batchIndex++, sharedBatchRecord) : await readNextRecord();
+    }
+    return { status: 0, quit: false };
+  } finally {
+    if (stdoutLen > 0) await flushStdout();
+    if (batchSource) await batchSource.return(void 0);
+    else if (singleSource) await singleSource.return(void 0);
+  }
+}
+function runSedPairBatchLoopSync(batchText, batchEnds, endsLen, expr0, r1, g1, o1, expr1, r2, g2, o2, budget, stdoutBuf) {
+  return trySubstitutePairBatchToBufferSync(
+    batchText,
+    batchEnds,
+    endsLen,
+    expr0,
+    r1,
+    g1,
+    o1,
+    expr1,
+    r2,
+    g2,
+    o2,
+    budget,
+    stdoutBuf,
+    10,
+    STDOUT_FLUSH
+  );
+}
+function tryExecutePairFastSync(program, context, file, quiet, budget, separator) {
+  if (program.length !== 2 || quiet || separator !== "\n" || file === "-") return void 0;
+  const inst0 = program[0];
+  const inst1 = program[1];
+  if (inst0.kind !== "s" || inst0.first || inst0.second || inst0.negate || inst0.print || inst0.file || !inst0.pattern || inst1.kind !== "s" || inst1.first || inst1.second || inst1.negate || inst1.print || inst1.file || !inst1.pattern) {
+    return void 0;
+  }
+  const expr0 = inst0.pattern;
+  const expr1 = inst1.pattern;
+  if (inst0.replacementGroupCount > expr0.groupCount || inst1.replacementGroupCount > expr1.groupCount) return void 0;
+  const stdoutSync = typeof context.stdout.writeSync === "function" ? context.stdout : void 0;
+  if (!stdoutSync) return void 0;
+  const fastMem = context._fastMemoryBackingFs;
+  if (!fastMem || fastMem.capabilitiesFor !== void 0 || context._cachedInputBudget !== void 0 || Object.prototype.hasOwnProperty.call(fastMem, "readStream") || Object.prototype.hasOwnProperty.call(fastMem, "readFile")) {
+    return void 0;
+  }
+  const path = pathOf(context, file);
+  if (path === "/dev" || path.startsWith("/dev/")) return void 0;
+  let rawBytes;
+  try {
+    rawBytes = tryReadMemoryFileViewSync(fastMem, path, void 0, context.signal, true);
+  } catch (e) {
+    console.error("SED_SYNC_ERR:", e);
+    return void 0;
+  }
+  if (!rawBytes || rawBytes.byteLength < 256) return void 0;
+  const cachedBatch = getCachedLatin1Batch(rawBytes);
+  if (!cachedBatch || cachedBatch.lastLineStart !== cachedBatch.text.length || cachedBatch.maxLineLen > budget.maxBufferBytes) {
+    return void 0;
+  }
+  const pending = budget.checkpointSync();
+  if (pending) {
+    pending.catch(() => {
+    });
+    return void 0;
+  }
+  budget.step();
+  const stdoutBuf = new Uint8Array(STDOUT_CAP);
+  const batchText = cachedBatch.text;
+  const batchEnds = cachedBatch.ends;
+  const endsLen = batchEnds.length;
+  const g1 = inst0.global ?? false;
+  const o1 = inst0.occurrence ?? 1;
+  const r1 = inst0.replacement;
+  const g2 = inst1.global ?? false;
+  const o2 = inst1.occurrence ?? 1;
+  const r2 = inst1.replacement;
+  const stdoutLen = runSedPairBatchLoopSync(
+    batchText,
+    batchEnds,
+    endsLen,
+    expr0,
+    r1,
+    g1,
+    o1,
+    expr1,
+    r2,
+    g2,
+    o2,
+    budget,
+    stdoutBuf
+  );
+  if (stdoutLen < 0) return void 0;
+  context._chargeFastFsOp?.();
+  if (stdoutLen > 0) {
+    context.signal.throwIfAborted();
+    if (typeof stdoutSync.writeRangeSync === "function") {
+      stdoutSync.writeRangeSync(stdoutBuf, stdoutLen);
+    } else {
+      stdoutSync.writeSync(new Uint8Array(stdoutBuf.buffer, stdoutBuf.byteOffset, stdoutLen));
+    }
+  }
+  return 0;
+}
+var SED_META_RE = /[\\^$.*+?()[\]{}|\n]/;
+function tryExecuteSimpleSedStdinSync(rawProg, context, options) {
+  if (rawProg.length < 4 || rawProg.length > 256 || rawProg.charCodeAt(0) !== 115) return void 0;
+  const delim = rawProg[1];
+  if (delim === "\\" || delim === "\n") return void 0;
+  const parts = rawProg.split(delim);
+  if (parts.length !== 4) return void 0;
+  const pat = parts[1];
+  const rep = parts[2];
+  const flags = parts[3];
+  if (pat.length === 0 || flags !== "" && flags !== "g") return void 0;
+  if (SED_META_RE.test(pat) || rep.includes("&") || rep.includes("\\") || rep.includes("\n")) return void 0;
+  for (let i = 0; i < rawProg.length; i++) {
+    if (rawProg.charCodeAt(i) >= 128) return void 0;
+  }
+  const stdinSync = context.stdin;
+  const stdoutSync = context.stdout;
+  if (typeof stdinSync.tryReadAllSync !== "function" || typeof stdoutSync.writeSync !== "function") return void 0;
+  const rawBytes = stdinSync.tryReadAllSync();
+  if (!rawBytes || rawBytes.byteLength > 16384) return void 0;
+  for (let i = 0; i < rawBytes.byteLength; i++) {
+    const b = rawBytes[i];
+    if (b >= 128 || b === 0) return void 0;
+  }
+  const budget = Budget.acquire(context, options);
+  try {
+    const pCheck = budget.checkpointSync();
+    if (pCheck) {
+      pCheck.catch(() => {
+      });
+      return void 0;
+    }
+    const text = decodeBytes(encodeBytes(rawBytes.buffer, rawBytes.byteOffset, rawBytes.byteLength), "latin1");
+    if (text.length === 0) {
+      budget.step(1);
+      return 0;
+    }
+    const hasTrailingNewline = text.charCodeAt(text.length - 1) === 10;
+    const body = hasTrailingNewline ? text.slice(0, -1) : text;
+    const lines = body.split("\n");
+    const isGlobal = flags === "g";
+    budget.step(1 + lines.length);
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.length > budget.maxBufferBytes) return void 0;
+      const idx = line.indexOf(pat);
+      if (idx !== -1) {
+        const nextLine = isGlobal ? line.split(pat).join(rep) : line.slice(0, idx) + rep + line.slice(idx + pat.length);
+        if (nextLine.length > budget.maxBufferBytes) return void 0;
+        lines[i] = nextLine;
+      }
+    }
+    const outText = lines.join("\n") + (hasTrailingNewline ? "\n" : "");
+    budget.check(outText);
+    const outBytes = encodeBytes(outText, "latin1");
+    if (!stdoutSync.writeSync(outBytes)) return void 0;
+    return 0;
+  } catch {
+    return void 0;
+  } finally {
+    Budget.release(budget);
+  }
+}
+function sedCommand(options = {}) {
+  const maxProgramInstructions = options.maxProgramInstructions === void 0 ? Infinity : options.maxProgramInstructions;
+  const definition = command("sed", (context) => {
+    if (maxProgramInstructions === Infinity && (context.args.length === 1 || context.args.length === 2 && context.args[0] === "-e")) {
+      const rawProg = context.args[context.args.length - 1];
+      const stdinRes = tryExecuteSimpleSedStdinSync(rawProg, context, options);
+      if (stdinRes !== void 0) return stdinRes;
+    }
+    if (maxProgramInstructions === Infinity && context.args.length === 2 && !context.args[0].startsWith("-") && context.args[0] !== "-" && !context.args[1].startsWith("-") && context.args[1] !== "-") {
+      const rawProg = context.args[0];
+      let cached = sedProgramCache.get(`0:
+:${Infinity}:${rawProg}`);
+      if (!cached) {
+        const parseBudget = Budget.acquire(context, options);
+        try {
+          cached = tryParseFastPairProgramSync(rawProg, parseBudget);
+        } finally {
+          Budget.release(parseBudget);
+        }
+      }
+      if (cached && cached.outputFiles.length === 0 && cached.readFiles.length === 0) {
+        const quiet = rawProg.charCodeAt(0) === 35 && rawProg.charCodeAt(1) === 110;
+        const budget = Budget.acquire(context, options);
+        try {
+          if (cached.steps > 0) budget.step(cached.steps);
+          const syncStatus = tryExecutePairFastSync(cached.program, context, context.args[1], quiet, budget, "\n");
+          if (syncStatus !== void 0) return syncStatus;
+        } finally {
+          Budget.release(budget);
+        }
+      }
+    }
+    return executeSedGeneral(context, options, maxProgramInstructions);
+  });
+  return { ...definition, filesystemRequirements: sedRequirements };
+}
+async function executeSedGeneral(context, options, maxProgramInstructions) {
+  if (maxProgramInstructions !== Infinity && !Number.isSafeInteger(maxProgramInstructions) || maxProgramInstructions < 1) throw new ProgramError("maxProgramInstructions must be a positive safe integer");
+  const budget = new Budget(context, options);
+  const sources = [];
+  const files = [];
+  let quiet = false;
+  let extended = false;
+  let separate = false;
+  let lineLength = 70;
+  const setLineLength = (value) => {
+    if (value === void 0 || !value.length || [...value].some((character) => character < "0" || character > "9") || !Number.isSafeInteger(Number(value))) {
+      throw new ProgramError("line length must be a nonnegative safe integer");
+    }
+    lineLength = Number(value);
+  };
+  let separator = "\n";
+  let inPlace;
+  let ended = false;
+  for (let index = 0; index < context.args.length; index++) {
+    const argument = context.args[index];
+    if (ended || argument === "-" || !argument.startsWith("-")) {
+      files.push(argument);
+      continue;
+    }
+    if (argument === "--") {
+      ended = true;
+      continue;
+    }
+    if (argument === "--null-data") {
+      separator = "\0";
+      continue;
+    }
+    if (argument === "--quiet" || argument === "--silent") {
+      quiet = true;
+      continue;
+    }
+    if (argument === "--unbuffered" || argument === "--posix") continue;
+    if (argument === "--regexp-extended") {
+      extended = true;
+      continue;
+    }
+    if (argument === "--in-place" || argument.startsWith("--in-place=")) {
+      inPlace = argument === "--in-place" ? "" : argument.slice("--in-place=".length);
+      continue;
+    }
+    if (argument === "--separate") {
+      separate = true;
+      continue;
+    }
+    if (argument === "--line-length" || argument.startsWith("--line-length=")) {
+      setLineLength(argument === "--line-length" ? context.args[++index] : argument.slice("--line-length=".length));
+      continue;
+    }
+    if (argument === "--expression" || argument.startsWith("--expression=")) {
+      const source = argument === "--expression" ? context.args[++index] : argument.slice("--expression=".length);
+      if (source === void 0) throw new ProgramError("--expression requires an argument");
+      sources.push(byteString(source));
+      continue;
+    }
+    if (argument === "--file" || argument.startsWith("--file=")) {
+      const source = argument === "--file" ? context.args[++index] : argument.slice("--file=".length);
+      if (source === void 0) throw new ProgramError("--file requires an argument");
+      await assertPathRequirements(context, sedRequirements, ["script-file"], [source]);
+      sources.push(await readProgram(context, source));
+      continue;
+    }
+    if (argument.startsWith("--")) throw new ProgramError(`unsupported option '${argument}'`);
+    for (let position = 1; position < argument.length; position++) {
+      const flag = argument[position];
+      if (flag === "n") quiet = true;
+      else if (flag === "u") {
+      } else if (flag === "z") separator = "\0";
+      else if (flag === "E" || flag === "r") extended = true;
+      else if (flag === "s") separate = true;
+      else if (flag === "l") {
+        setLineLength(argument.slice(position + 1) || context.args[++index]);
+        position = argument.length;
+      } else if (flag === "i") {
+        inPlace = argument.slice(position + 1);
+        if (!inPlace && context.args[index + 1] === "") index++;
+        position = argument.length;
+      } else if (flag === "e" || flag === "f") {
+        const source = argument.slice(position + 1) || context.args[++index];
+        if (source === void 0) throw new ProgramError(`-${flag} requires an argument`);
+        if (flag === "f") await assertPathRequirements(context, sedRequirements, ["script-file"], [source]);
+        sources.push(flag === "f" ? await readProgram(context, source) : byteString(source));
+        position = argument.length;
+      } else throw new ProgramError(`unsupported option '-${flag}'`);
+    }
+  }
+  if (!sources.length) {
+    if (!files.length) throw new ProgramError("missing program");
+    sources.push(byteString(files.shift()));
+  }
+  if (sources[0]?.startsWith("#n")) quiet = true;
+  const sourceText = sources.length === 1 ? sources[0] : sources.join("\n");
+  const canCache = sourceText.length <= 8192;
+  const cacheKey = canCache ? `${extended ? 1 : 0}:${separator}:${maxProgramInstructions}:${sourceText}` : "";
+  let cached = canCache ? sedProgramCache.get(cacheKey) : void 0;
+  if (cached) {
+    if (cached.steps > 0) budget.step(cached.steps);
+  } else {
+    const stepsBefore = budget.stepsUsed;
+    const parsedProgram = await parse(sourceText, extended, separator, maxProgramInstructions, budget);
+    const steps = budget.stepsUsed - stepsBefore;
+    let outFiles;
+    let rdFiles;
+    for (let i = 0; i < parsedProgram.length; i++) {
+      const inst = parsedProgram[i];
+      if (inst.file !== void 0) {
+        if (inst.kind === "r") (rdFiles ??= []).push(inst.file);
+        else (outFiles ??= []).push(inst.file);
+      }
+    }
+    cached = {
+      program: parsedProgram,
+      steps,
+      outputFiles: outFiles ?? EMPTY_STRINGS,
+      readFiles: rdFiles ?? EMPTY_STRINGS
+    };
+    if (canCache) {
+      if (sedProgramCache.size >= 64) sedProgramCache.delete(sedProgramCache.keys().next().value);
+      sedProgramCache.set(cacheKey, cached);
+    }
+  }
+  const { program, outputFiles, readFiles } = cached;
+  if (outputFiles.length > 0) {
+    await assertPathRequirements(context, sedRequirements, ["script-output"], outputFiles);
+  }
+  if (inPlace !== void 0 || outputFiles.length > 0) {
+    await assertPathRequirements(context, sedRequirements, ["file"], files.filter((file) => file !== "-"));
+    if (readFiles.length > 0) {
+      await assertPathRequirements(context, sedRequirements, ["script-read"], readFiles);
+    }
+  }
+  const prepareOutputs = async () => {
+    if (outputFiles.length === 0) return;
+    const paths = new Set(outputFiles.map((file) => virtualPath(context, file)));
+    for (const path of paths) await writeFileOutput(context, new Uint8Array(), (chunk) => context.fs.writeFile(path, chunk, { signal: context.signal }));
+  };
+  const outputState = { stdoutUnterminated: false, unterminatedFiles: outputFiles.length > 0 ? /* @__PURE__ */ new Set() : EMPTY_SET };
+  if (inPlace !== void 0) {
+    if (!files.length || files.includes("-")) throw new ProgramError("in-place editing requires named files");
+    if (inPlace.includes("/") || inPlace.includes("\0")) throw new ProgramError("backup suffix cannot contain '/' or NUL");
+    await assertPathRequirements(context, sedRequirements, ["in-place"], files);
+    if (inPlace) await assertPathRequirements(context, sedRequirements, ["backup"], files.flatMap((file) => [file, file + inPlace]));
+    const targets = await prepareInPlace(context, files, inPlace);
+    if (outputFiles.length > 0) await prepareOutputs();
+    for (const target of targets) {
+      const result = await editInPlace(context, target, inPlace, budget, async (stdin) => {
+        let rewritten = "";
+        const child = Object.assign(Object.create(Object.getPrototypeOf(context)), context, { stdin, stdout: { async write(chunk) {
+          rewritten = budget.check(rewritten + decodeBytes(encodeBytes(chunk), "latin1"));
+        } } });
+        outputState.stdoutUnterminated = false;
+        const result2 = await execute(program, child, ["-"], quiet, budget, separator, outputState, lineLength);
+        return { result: result2, data: bytes(rewritten) };
+      });
+      if (result.quit || result.status) return result.status;
+    }
+    return 0;
+  }
+  if (outputFiles.length > 0) await prepareOutputs();
+  if (separate) {
+    for (const file of files.length ? files : ["-"]) {
+      const result = await execute(program, context, [file], quiet, budget, separator, outputState, lineLength);
+      if (result.quit || result.status) return result.status;
+    }
+    return 0;
+  }
+  return (await execute(program, context, files, quiet, budget, separator, outputState, lineLength)).status;
+}
+
+export {
+  sedCommand
+};