@poe-platform/safe-bash 0.1.803 → 0.1.804

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

@@ -0,0 +1,296 @@
+import {
+  LineEndingError
+} from "./chunk-TOH3OF3O.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-line-ending-engine/src/io.ts
+init_buffer();
+var typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
+var viewBuffer = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer").get;
+var viewOffset = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteOffset").get;
+var viewLength = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength").get;
+var Lifecycle = class {
+  constructor(budget, output, captured, caller, admission) {
+    this.budget = budget;
+    this.captured = captured;
+    this.caller = caller;
+    this.admission = admission;
+    output.registerCleanup(() => this.close());
+  }
+  budget;
+  captured;
+  caller;
+  admission;
+  pending = /* @__PURE__ */ new Set();
+  cleanups = [];
+  closing;
+  diagnosticDestination;
+  diagnosticCancellation;
+  assertOpen() {
+    this.budget.assertOpen();
+    if (this.closing) throw new LineEndingError("command is closed");
+  }
+  assertDiagnosticOpen() {
+    this.caller.throwIfAborted();
+    const consumer = this.diagnosticDestination?.consumer;
+    if (consumer?.aborted) {
+      this.diagnosticCancellation = { reason: consumer.reason };
+      consumer.throwIfAborted();
+    }
+  }
+  cleanup(action) {
+    this.assertOpen();
+    this.cleanups.push(action);
+  }
+  async operation(action) {
+    this.assertOpen();
+    const pending = Promise.resolve().then(async () => {
+      {
+        const s = this.budget.step();
+        if (s) await s;
+      }
+      this.assertOpen();
+      return action();
+    });
+    this.pending.add(pending);
+    try {
+      const value = await pending;
+      this.assertOpen();
+      return value;
+    } finally {
+      this.pending.delete(pending);
+    }
+  }
+  close() {
+    return this.closing ??= Promise.resolve().then(async () => {
+      while (this.pending.size) await Promise.allSettled([...this.pending]);
+      const failures = [];
+      for (const close of this.cleanups) {
+        try {
+          await close();
+        } catch (error) {
+          failures.push(error);
+        }
+      }
+      if (failures.length === 1) throw failures[0];
+      if (failures.length > 1) throw new AggregateError(failures, "line-ending cleanup failed");
+    });
+  }
+  async stdout(bytes) {
+    await this.operation(async () => {
+      const write = this.captured.write;
+      this.assertOpen();
+      await Reflect.apply(write, this.captured, [bytes]);
+    });
+  }
+  async diagnostic(text) {
+    this.assertDiagnosticOpen();
+    if (this.closing || this.admission.closed) throw new LineEndingError("command is closed");
+    this.budget.check(text.length * 3, this.budget.limits.maxDiagnosticBytes, "diagnostic buffer bytes");
+    const bytes = new TextEncoder().encode(text);
+    this.budget.emitted(bytes.length, true);
+    const pending = Promise.resolve().then(async () => {
+      this.assertDiagnosticOpen();
+      if (!this.diagnosticDestination) {
+        const sink = this.budget.context.stderr;
+        this.assertDiagnosticOpen();
+        const capability = sink.ownedOutput;
+        this.assertDiagnosticOpen();
+        const consumer = capability?.consumerClosed;
+        this.diagnosticDestination = { destination: capability ?? sink, consumer };
+      }
+      this.assertDiagnosticOpen();
+      const destination = this.diagnosticDestination.destination;
+      const write = destination.write;
+      this.assertDiagnosticOpen();
+      await Reflect.apply(write, destination, [bytes]);
+    });
+    this.pending.add(pending);
+    try {
+      await pending;
+      this.assertDiagnosticOpen();
+    } finally {
+      this.pending.delete(pending);
+    }
+  }
+};
+var Reader = class {
+  constructor(life) {
+    this.life = life;
+    life.cleanup(() => this.close());
+  }
+  life;
+  iterator;
+  chunk = new Uint8Array();
+  offset = 0;
+  ended = false;
+  empties = 0;
+  snapshotBytes = 0;
+  closing;
+  close() {
+    return this.closing ??= (async () => {
+      try {
+        if (!this.ended && this.iterator) {
+          const iterator = this.iterator;
+          const close = iterator.return;
+          if (close) await Reflect.apply(close, iterator, []);
+        }
+      } finally {
+        this.iterator = void 0;
+        this.life.budget.retain(-this.chunk.length - this.snapshotBytes);
+        this.chunk = new Uint8Array();
+        this.snapshotBytes = 0;
+      }
+    })();
+  }
+  async open(path, stat) {
+    const { context, signal, limits } = this.life.budget;
+    await this.life.operation(async () => {
+      let source;
+      let acquisitionAborted = false;
+      if (path === void 0) source = context.stdin;
+      else {
+        const fs = context.fs;
+        const capabilitiesFor = fs.capabilitiesFor;
+        this.life.assertOpen();
+        const selected = capabilitiesFor ? await Reflect.apply(capabilitiesFor, fs, [path, { signal }]) : void 0;
+        this.life.assertOpen();
+        const capabilities = selected ?? fs.capabilities;
+        this.life.assertOpen();
+        const readStream = fs.readStream;
+        this.life.assertOpen();
+        const streaming = capabilities.streamingRead !== false;
+        this.life.assertOpen();
+        if (readStream && streaming) {
+          source = Reflect.apply(readStream, fs, [path, { signal, chunkSize: limits.chunkSize === Infinity ? 16384 : limits.chunkSize }]);
+          acquisitionAborted = signal.aborted || this.life.admission.closed;
+        } else {
+          const maximum = Math.min(limits.maxInputBytes, Math.floor(limits.maxBufferedBytes / 3));
+          const size = stat.size;
+          this.life.assertOpen();
+          this.life.budget.check(size, maximum, "buffered input bytes");
+          this.life.budget.retain(Number.isFinite(maximum) ? maximum : size);
+          this.snapshotBytes = Number.isFinite(maximum) ? maximum : size;
+          const readFile = fs.readFile;
+          this.life.assertOpen();
+          const bytes = await Reflect.apply(readFile, fs, [path, { signal, ...Number.isFinite(maximum) ? { maxBytes: maximum } : {} }]);
+          this.life.assertOpen();
+          if (!(bytes instanceof Uint8Array)) throw new TypeError("line-ending input requires bytes");
+          this.life.budget.check(viewLength.call(bytes), maximum, "buffered input bytes");
+          this.life.budget.retain(viewLength.call(bytes) - this.snapshotBytes);
+          this.snapshotBytes = viewLength.call(bytes);
+          source = { [Symbol.asyncIterator]: (async function* () {
+            try {
+              yield bytes;
+            } finally {
+              this.life.budget.retain(-this.snapshotBytes);
+              this.snapshotBytes = 0;
+            }
+          }).bind(this) };
+        }
+      }
+      if (!acquisitionAborted) this.life.assertOpen();
+      const factory = source[Symbol.asyncIterator];
+      if (!acquisitionAborted) this.life.assertOpen();
+      this.iterator = Reflect.apply(factory, source, []);
+    });
+  }
+  get() {
+    const step = this.life.budget.step();
+    if (!step && this.offset < this.chunk.length) {
+      this.life.assertOpen();
+      return this.chunk[this.offset++];
+    }
+    return this.getSlow(step);
+  }
+  beforeRead;
+  async getSlow(step) {
+    if (step) await step;
+    this.life.assertOpen();
+    while (this.offset === this.chunk.length) {
+      if (this.ended) return -1;
+      await this.beforeRead?.();
+      const next = await this.life.operation(() => {
+        const iterator = this.iterator;
+        const advance = iterator.next;
+        this.life.assertOpen();
+        return Reflect.apply(advance, iterator, []);
+      });
+      this.life.budget.retain(-this.chunk.length);
+      this.chunk = new Uint8Array();
+      this.offset = 0;
+      const done = next.done;
+      this.life.assertOpen();
+      if (done) {
+        this.ended = true;
+        this.iterator = void 0;
+        return -1;
+      }
+      const value = next.value;
+      this.life.assertOpen();
+      if (!(value instanceof Uint8Array)) throw new TypeError("line-ending input requires bytes");
+      const buffer = viewBuffer.call(value);
+      const offset = viewOffset.call(value);
+      const length = viewLength.call(value);
+      this.life.budget.incoming(length);
+      this.life.budget.retain(length);
+      try {
+        if (viewOffset.call(value) !== offset || viewLength.call(value) < length) throw new TypeError("line-ending input extent changed during admission");
+        this.chunk = new Uint8Array(new Uint8Array(buffer, offset, length));
+      } catch (error) {
+        this.life.budget.retain(-length);
+        throw error;
+      }
+      if (!this.chunk.length) this.life.budget.check(++this.empties, this.life.budget.limits.maxEmptyChunks, "empty input chunks");
+    }
+    return this.chunk[this.offset++];
+  }
+};
+var Writer = class {
+  constructor(life, publish) {
+    this.life = life;
+    this.publish = publish;
+    const { chunkSize, maxBufferedBytes } = life.budget.limits;
+    const size = Math.min(chunkSize === Infinity ? 16384 : chunkSize, maxBufferedBytes);
+    life.budget.retain(size);
+    this.buffer = new Uint8Array(size);
+    life.cleanup(async () => {
+      this.release();
+    });
+  }
+  life;
+  publish;
+  buffer;
+  used = 0;
+  release() {
+    this.life.budget.retain(-this.buffer.length);
+    this.buffer = new Uint8Array();
+    this.used = 0;
+  }
+  put(byte) {
+    const step = this.life.budget.step();
+    if (step) return step.then(() => this.putAfterStep(byte));
+    return this.putAfterStep(byte);
+  }
+  putAfterStep(byte) {
+    this.life.assertOpen();
+    this.life.budget.emitted(1);
+    this.buffer[this.used++] = byte;
+    if (this.used === this.buffer.length) return this.flush();
+  }
+  async flush() {
+    this.life.assertOpen();
+    if (this.used) {
+      await this.publish(this.buffer.slice(0, this.used));
+      this.used = 0;
+    }
+  }
+};
+
+export {
+  Lifecycle,
+  Reader,
+  Writer
+};

package/dist/safe-bash/command-chunks/{chunk-WVHONVZ4.js → chunk-YMFUUPDX.js}

@@ -378,17 +378,19 @@ async function run(context, budget) {
     const oldBytes = await read(left, leftStat);
     const newBytes = await read(right, rightStat);
     const label = (name) => encoding === "latin1" ? decodeBytes(encodeBytes(name), "latin1") : name;
+    let incompleteEdLine = false;
     const reportSame = () => {
-      if (options.reportSame) append(`Files ${label(options.labels[0] ?? left)} and ${label(options.labels[1] ?? right)} are identical
+      if (options.reportSame && !incompleteEdLine) append(`Files ${label(options.labels[0] ?? left)} and ${label(options.labels[1] ?? right)} are identical
 `);
     };
-    if (options.format === "ed" && (options.text || !oldBytes.includes("\0") && !newBytes.includes("\0"))) {
+    if (options.format === "ed" && !options.brief && (options.text || !oldBytes.includes("\0") && !newBytes.includes("\0"))) {
       for (const [path, text] of [[left, oldBytes], [right, newBytes]]) {
         if (text && !text.endsWith("\n")) {
           await writeDiagnostic(context.stderr, `diff: ${path}: No newline at end of file
 
 `, context.signal);
           trouble = true;
+          incompleteEdLine = true;
         }
       }
     }
@@ -419,7 +421,7 @@ async function run(context, budget) {
       oldText = oldText.replaceAll("\r\n", "\n");
       newText = newText.replaceAll("\r\n", "\n");
     }
-    if (options.format === "ed") {
+    if (options.format === "ed" && !options.brief) {
       if (oldText && !oldText.endsWith("\n")) oldText += "\n";
       if (newText && !newText.endsWith("\n")) newText += "\n";
     }

package/dist/safe-bash/command-chunks/{chunk-IR2BY7EL.js → chunk-YYGIBXFZ.js}

@@ -1,9 +1,9 @@
 import {
   escape
-} from "./chunk-XJXU3VVH.js";
+} from "./chunk-LWOE65OE.js";
 import {
   XmlQueryError
-} from "./chunk-NXEQ3ESQ.js";
+} from "./chunk-7QD5YY4F.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-MSFXC3OC.js → chunk-Z4FO6OHE.js}

@@ -1,10 +1,10 @@
 import {
   blockTags
-} from "./chunk-LWS62ISU.js";
+} from "./chunk-N6DIASO2.js";
 import {
   destination,
   escapeText
-} from "./chunk-OQU6UT6X.js";
+} from "./chunk-OV3XREFN.js";
 import {
   htmlSpace,
   normalizeText,

package/dist/safe-bash/command-chunks/{chunk-WWIBP2ET.js → chunk-Z5ZZVDUD.js}

@@ -244,7 +244,10 @@ function extendedSource(source) {
     const character = source[offset];
     if (!bracket && character === "\\" && offset + 1 < source.length) {
       const next = source[++offset];
-      result += "()|+?{}".includes(next) ? next : `\\${next}`;
+      if (next === "(" && source.startsWith("?:", offset + 1)) {
+        result += "(?:";
+        offset += 2;
+      } else result += "()|+?{}".includes(next) ? next : `\\${next}`;
     } else if (bracket) {
       if (bracketFirst && character === "^") {
         result += character;
@@ -435,11 +438,24 @@ var Pattern = class {
     let offset = 0;
     let groups = 0;
     const closedGroups = /* @__PURE__ */ new Set();
-    const characterNode = (character) => ({
-      type: "character",
-      ...ignoreCase ? {} : { literal: character },
-      accepts: (candidate) => ignoreCase ? candidate.toLowerCase() === character.toLowerCase() : candidate === character
-    });
+    let insensitive = ignoreCase;
+    let multiline = false;
+    let dotAll = dialect !== "jq" || modifiers.includes("m");
+    const characterNode = (character) => {
+      const fold = insensitive;
+      return {
+        type: "character",
+        ...fold ? {} : { literal: character },
+        accepts: (candidate) => fold ? candidate.toLowerCase() === character.toLowerCase() : candidate === character
+      };
+    };
+    const shorthand = (reference) => {
+      const alphabet = reference.toLowerCase();
+      return (character) => {
+        const accepted = alphabet === "d" ? character >= "0" && character <= "9" : alphabet === "s" ? " 	\n\r\f\v".includes(character) : isWordChar(character);
+        return reference === alphabet ? accepted : !accepted;
+      };
+    };
     const escaped = () => {
       const character = offset < source.length ? String.fromCodePoint(source.codePointAt(offset)) : void 0;
       offset += character?.length ?? 1;
@@ -462,6 +478,7 @@ var Pattern = class {
       const negate = source[offset] === "^";
       if (negate) offset++;
       const tests = [];
+      const fold = insensitive;
       let first = true;
       while (offset < source.length && (source[offset] !== "]" || first)) {
         first = false;
@@ -474,6 +491,12 @@ var Pattern = class {
           continue;
         }
         if (source.startsWith("[.", offset) || source.startsWith("[=", offset)) throw new ProgramError("collating and equivalence classes are not supported");
+        if (source[offset] === "\\" && "dDsSwW".includes(source[offset + 1] ?? " ")) {
+          tests.push(shorthand(source[offset + 1]));
+          offset += 2;
+          if (source[offset] === "-" && source[offset + 1] !== "]") throw new ProgramError("character class cannot be a range endpoint");
+          continue;
+        }
         const readBracketChar = () => {
           const ch = String.fromCodePoint(source.codePointAt(offset));
           offset += ch.length;
@@ -491,6 +514,7 @@ var Pattern = class {
         const start = readBracketChar();
         if (source[offset] === "-" && source[offset + 1] !== "]" && source[offset + 1] !== void 0) {
           offset++;
+          if (source[offset] === "\\" && "dDsSwW".includes(source[offset + 1] ?? " ")) throw new ProgramError("character class cannot be a range endpoint");
           const end = readBracketChar();
           if (start > end) throw new ProgramError("reversed character range");
           tests.push((character) => character >= start && character <= end);
@@ -498,7 +522,7 @@ var Pattern = class {
       }
       if (source[offset++] !== "]") throw new ProgramError("unterminated bracket expression");
       return { type: "character", accepts: (character) => {
-        const accepted = tests.some((test) => test(character) || ignoreCase && (test(character.toLowerCase()) || test(character.toUpperCase())));
+        const accepted = tests.some((test) => test(character) || fold && (test(character.toLowerCase()) || test(character.toUpperCase())));
         return negate ? !accepted : accepted;
       } };
     };
@@ -512,7 +536,7 @@ var Pattern = class {
           const index = Number(reference);
           if (!closedGroups.has(index)) throw new ProgramError("pattern references an undefined or open capture group");
           offset++;
-          return { type: "backreference", index };
+          return { type: "backreference", index, ignoreCase: insensitive };
         }
         if (reference !== void 0 && "bByY<>".includes(reference)) {
           offset++;
@@ -528,17 +552,16 @@ var Pattern = class {
         }
         if ((dialect === "jq" || dialect === "sed" || dialect === "awk") && reference !== void 0 && "dDsSwW".includes(reference)) {
           offset++;
-          const alphabet = reference.toLowerCase();
-          return { type: "character", accepts: (character) => {
-            const accepted = alphabet === "d" ? character >= "0" && character <= "9" : alphabet === "s" ? " 	\n\r\f\v".includes(character) : character >= "a" && character <= "z" || character >= "A" && character <= "Z" || character >= "0" && character <= "9" || character === "_";
-            return reference === alphabet ? accepted : !accepted;
-          } };
+          return { type: "character", accepts: shorthand(reference) };
         }
         return characterNode(escaped());
       }
-      if (token === ".") return { type: "character", accepts: (character) => dialect !== "jq" || modifiers.includes("m") || character !== "\n" };
-      if (token === "^") return extended || atStart ? { type: "begin" } : characterNode(token);
-      if (token === "$") return extended || offset === source.length || source[offset] === ")" || source[offset] === "|" ? { type: "end" } : characterNode(token);
+      if (token === ".") {
+        const all = dotAll;
+        return { type: "character", accepts: (character) => all || character !== "\n" };
+      }
+      if (token === "^") return extended || atStart ? { type: "begin", multiline } : characterNode(token);
+      if (token === "$") return extended || offset === source.length || source[offset] === ")" || source[offset] === "|" ? { type: "end", multiline } : characterNode(token);
       if (token === "*" && !extended && (atStart || afterBegin)) return characterNode(token);
       if (token === void 0 || "*+?{}".includes(token)) throw new ProgramError("quantifier without an expression");
       return characterNode(token);
@@ -583,6 +606,7 @@ var Pattern = class {
         offset++;
         const inner = finish(frame);
         frames.pop();
+        if (frame.flags) ({ insensitive, multiline, dotAll } = frame.flags);
         closedGroups.add(frame.index);
         const node = frame.assertion ? { type: "assertion", node: inner, ...frame.assertion } : frame.index ? { type: "group", index: frame.index, lastCapture: groups, node: inner } : inner;
         frames[frames.length - 1].nodes.push(repeated(node));
@@ -590,6 +614,33 @@ var Pattern = class {
         if (frames.length > (limits.maxPatternDepth ?? Infinity)) throw new ProgramError(`${prefix}regular expression depth limit exceeded`);
         this.patternDepth = Math.max(this.patternDepth, frames.length);
         offset++;
+        const flags = { insensitive, multiline, dotAll };
+        if (dialect === "jq" && source[offset] === "?" && "ims-".includes(source[offset + 1] ?? " ")) {
+          offset++;
+          let enabled = true;
+          let count = 0;
+          while (offset < source.length && source[offset] !== ":" && source[offset] !== ")") {
+            const flag = source[offset++];
+            if (flag === "-" && enabled) {
+              enabled = false;
+              count = 0;
+              continue;
+            }
+            if (flag === "i") insensitive = enabled;
+            else if (flag === "m") multiline = enabled;
+            else if (flag === "s") dotAll = enabled;
+            else throw new ProgramError("unsupported inline regular expression flag");
+            count++;
+          }
+          if (!count) throw new ProgramError("empty inline regular expression flags");
+          if (source[offset] === ")") {
+            offset++;
+            continue;
+          }
+          if (source[offset++] !== ":") throw new ProgramError("unterminated inline regular expression flags");
+          frames.push({ nodes: [], alternatives: [], index: 0, flags });
+          continue;
+        }
         let name;
         let capturing = true;
         let assertion;
@@ -617,7 +668,7 @@ var Pattern = class {
         }
         const index = capturing ? ++groups : 0;
         if (name !== void 0) this.groupNames.set(name, index);
-        frames.push({ nodes: [], alternatives: [], index, assertion });
+        frames.push({ nodes: [], alternatives: [], index, assertion, flags });
       } else {
         frame.nodes.push(repeated(atom(frame.nodes.length === 0, frame.nodes.length === 1 && frame.nodes[0].type === "begin")));
       }
@@ -1424,9 +1475,60 @@ var Pattern = class {
     }
   }
 };
-async function replacementLength(replacement, match, budget, available, syntax) {
+function hasCaseConversion(replacement) {
+  return replacement.includes("\\U") || replacement.includes("\\L") || replacement.includes("\\u") || replacement.includes("\\l") || replacement.includes("\\E");
+}
+function* caseReplacement(replacement, match, encoding) {
+  const characterAt = (text, index) => {
+    if (encoding !== "utf8" || text.charCodeAt(index) < 128) return String.fromCodePoint(text.codePointAt(index));
+    const decoded = decodeByteText(text.slice(index, index + 4)).text;
+    return encodeByteText(String.fromCodePoint(decoded.codePointAt(0)));
+  };
+  let mode = "";
+  let once = "";
+  for (let index = 0; index < replacement.length; ) {
+    let piece = characterAt(replacement, index);
+    index += piece.length;
+    if (piece === "&") piece = match.groups[0] ?? "";
+    else if (piece === "\\" && index < replacement.length) {
+      const next = replacement[index++];
+      if (next === "U" || next === "L" || next === "E") {
+        mode = next === "E" ? "" : next;
+        once = "";
+        yield "";
+        continue;
+      }
+      if (next === "u" || next === "l") {
+        once = next.toUpperCase();
+        yield "";
+        continue;
+      }
+      piece = next >= "0" && next <= "9" ? match.groups[Number(next)] ?? "" : next === "n" ? "\n" : next === "t" ? "	" : next;
+    }
+    if (!piece) yield "";
+    for (let offset = 0; offset < piece.length; ) {
+      const raw = characterAt(piece, offset);
+      offset += raw.length;
+      const character = encoding === "utf8" ? decodeByteText(raw).text : raw;
+      const conversion = once || mode;
+      once = "";
+      const converted = encoding === "byte" && character.charCodeAt(0) >= 128 ? character : conversion === "U" ? character.toUpperCase() : conversion === "L" ? character.toLowerCase() : character;
+      yield encoding === "utf8" ? encodeByteText(converted) : converted;
+    }
+  }
+}
+async function replacementLength(replacement, match, budget, available, syntax, encoding) {
   let length = 0;
   let tokens = 0;
+  if (syntax === "sed" && hasCaseConversion(replacement)) {
+    for (const piece of caseReplacement(replacement, match, encoding)) {
+      if (tokens++ % 256 === 0) await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
+      budget.step();
+      if (piece.length > available - length) throw new ProgramError("text buffer limit exceeded");
+      length += piece.length;
+    }
+    return length;
+  }
   for (let index = 0; index < replacement.length; index++) {
     if (tokens++ % 256 === 0) await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
     budget.step();
@@ -1450,9 +1552,23 @@ async function replacementLength(replacement, match, budget, available, syntax)
   }
   return length;
 }
-async function replacementText(replacement, match, buffer, budget, syntax) {
+async function replacementText(replacement, match, buffer, budget, syntax, encoding) {
   let literal = 0;
   let tokens = 0;
+  if (syntax === "sed" && hasCaseConversion(replacement)) {
+    let chunk = "";
+    for (const piece of caseReplacement(replacement, match, encoding)) {
+      if (tokens++ % 256 === 0) await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
+      budget.step();
+      chunk += piece;
+      if (chunk.length >= 1024) {
+        await buffer.append(chunk);
+        chunk = "";
+      }
+    }
+    await buffer.append(chunk);
+    return;
+  }
   for (let index = 0; index < replacement.length; index++) {
     if (tokens++ % 256 === 0) await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
     budget.step();
@@ -1490,6 +1606,10 @@ function getSimpleReplacement(replacement, syntax) {
     SIMPLE_REPLACEMENT_CACHE.set(key, res);
     return res;
   }
+  if (syntax === "sed" && hasCaseConversion(replacement)) {
+    SIMPLE_REPLACEMENT_CACHE.set(key, null);
+    return null;
+  }
   if (syntax === "sed") {
     let prefix = "";
     let mid = "";
@@ -1635,7 +1755,7 @@ function appendReplacementFromOffsetsSync(out, replacement, text, matchStart, ma
   return out;
 }
 function trySubstituteSync(text, pattern, replacement, budget, global, occurrence = 1, syntax = "sed") {
-  if (pattern.canFindSync() && text.length <= 4096 && replacement.length <= 256) {
+  if (pattern.canFindSync() && text.length <= 4096 && replacement.length <= 256 && !(syntax === "sed" && hasCaseConversion(replacement))) {
     let search = 0;
     let consumed = 0;
     let previousEnd = -1;
@@ -1743,6 +1863,7 @@ async function substitute(text, pattern, replacement, budget, global, occurrence
   let previousEnd = -1;
   let encountered = 0;
   let count = 0;
+  const encoding = pattern instanceof BytePattern ? pattern.usesUnicode(budget) ? "utf8" : "byte" : void 0;
   const result = new ReplacementBuffer(budget);
   try {
     while (search <= text.length) {
@@ -1758,10 +1879,10 @@ async function substitute(text, pattern, replacement, budget, global, occurrence
       if (encountered >= occurrence) {
         const prefix = match.start - consumed;
         result.admit(prefix);
-        const length = await replacementLength(replacement, match, budget, result.remaining - prefix, syntax);
+        const length = await replacementLength(replacement, match, budget, result.remaining - prefix, syntax, encoding);
         result.admit(prefix + length);
         await result.append(text, consumed, match.start);
-        await replacementText(replacement, match, result, budget, syntax);
+        await replacementText(replacement, match, result, budget, syntax, encoding);
         consumed = match.end;
         count++;
         if (!global) break;

package/dist/safe-bash/command-chunks/{chunk-LOICUCHG.js → chunk-ZHN3QDCI.js}

@@ -1,6 +1,6 @@
 import {
   createCodec
-} from "./chunk-BXCXRYVU.js";
+} from "./chunk-JNANXVJV.js";
 import {
   CompressedDataError
 } from "./chunk-2UQSP2CE.js";

package/dist/safe-bash/commands/alias/index.d.ts

@@ -0,0 +1,2 @@
+export * from "../../../safe-bash-command-alias/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/safe-bash/commands/alias/index.js

@@ -0,0 +1,2 @@
+export * from "../../../safe-bash-command-alias/index.js";
+//# sourceMappingURL=index.js.map

package/dist/safe-bash/commands/apply-patch/index.browser.js

@@ -3,9 +3,8 @@ import {
   createApplyPatchCommand,
   createApplyPatchCommands,
   evalSyncApplyPatch
-} from "../../chunks/chunk-XAQMU6OY.js";
-import "../../chunks/chunk-IWDICZVK.js";
-import "../../chunks/chunk-B7TAL7S5.js";
+} from "../../chunks/chunk-EE5YGFIZ.js";
+import "../../chunks/chunk-PTAEWLSE.js";
 export {
   applyPatchCommands,
   createApplyPatchCommand,

package/dist/safe-bash/commands/apply-patch/index.d.ts

@@ -1,3 +1,2 @@
-import "../../portable-buffer.js";
 export * from "../../../safe-bash-command-apply-patch/index.js";
 //# sourceMappingURL=index.d.ts.map