@poe-platform/safe-bash 0.1.101 → 0.1.103

package/dist/safe-bash/browser.js

@@ -17231,6 +17231,82 @@ function command(name2, run) {
   };
 }
 
+// packages/safe-bash/src/commands/text-programs/replacement-buffer.ts
+init_platform();
+var ReplacementBuffer = class {
+  constructor(budget) {
+    this.budget = budget;
+  }
+  budget;
+  #segments = [];
+  #size = 0;
+  #allocated = 0;
+  #tailUsed = 0;
+  get remaining() {
+    return this.budget.maxBufferBytes - this.#size;
+  }
+  admit(length) {
+    this.budget.step(0);
+    if (!Number.isSafeInteger(length) || length < 0 || length > this.remaining) throw new ProgramError("text buffer limit exceeded");
+  }
+  async append(source, start = 0, end = source.length) {
+    this.admit(end - start);
+    let offset = start;
+    while (offset < end) {
+      await this.budget.checkpoint();
+      let tail = this.#segments.at(-1);
+      const available = tail ? tail.length - this.#tailUsed : 0;
+      const capacity = Math.min(1024, this.budget.maxBufferBytes - this.#allocated);
+      const length = Math.min(end - offset, available || capacity);
+      this.budget.step(length);
+      if (!available) {
+        this.budget.step();
+        tail = import_buffer.Buffer.allocUnsafeSlow(capacity);
+        this.#segments.push(tail);
+        this.#allocated += capacity;
+        this.#tailUsed = 0;
+      }
+      for (let index = 0; index < length; index++) tail[this.#tailUsed + index] = source.charCodeAt(offset + index);
+      this.#tailUsed += length;
+      this.#size += length;
+      offset += length;
+    }
+  }
+  async finish() {
+    this.budget.step(0);
+    if (!this.#size) return "";
+    this.budget.step(this.#size);
+    await this.budget.checkpoint();
+    this.budget.step(0);
+    if (this.#segments.length === 1) {
+      const text = this.#segments[0].toString("latin1", 0, this.#size);
+      this.clear();
+      return text;
+    }
+    this.budget.step(this.#size);
+    if (this.#allocated > this.budget.maxBufferBytes || this.#size > this.budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+    const result = import_buffer.Buffer.allocUnsafeSlow(this.#size);
+    let offset = 0;
+    for (const segment of this.#segments) {
+      await this.budget.checkpoint();
+      this.budget.step(0);
+      const length = Math.min(segment.length, this.#size - offset);
+      result.set(segment.subarray(0, length), offset);
+      offset += length;
+    }
+    this.clear();
+    await this.budget.checkpoint();
+    this.budget.step(0);
+    return result.toString("latin1");
+  }
+  clear() {
+    this.#segments = [];
+    this.#size = 0;
+    this.#allocated = 0;
+    this.#tailUsed = 0;
+  }
+};
+
 // packages/safe-bash/src/commands/text-programs/regex.ts
 var classes2 = {
   alpha: (character) => /^[A-Za-z]$/u.test(character),
@@ -17520,43 +17596,93 @@ var Pattern = class {
     return void 0;
   }
 };
-function replacementText(replacement, match) {
-  let result = "";
+async function replacementLength(replacement, match, budget, available) {
+  let length = 0;
+  let tokens2 = 0;
   for (let index = 0; index < replacement.length; index++) {
+    if (tokens2++ % 256 === 0) await budget.checkpoint();
+    budget.step();
     const character = replacement[index];
-    if (character === "&") result += match.groups[0] ?? "";
-    else if (character === "\\" && index + 1 < replacement.length) {
+    let size = 1;
+    if (character === "&") {
+      budget.step();
+      size = match.groups[0]?.length ?? 0;
+    } else if (character === "\\" && index + 1 < replacement.length) {
+      budget.step();
       const next = replacement[++index];
-      result += /^[1-9]$/u.test(next) ? match.groups[Number(next)] ?? "" : next === "n" ? "\n" : next === "t" ? "	" : next;
-    } else result += character;
+      if (next >= "1" && next <= "9") {
+        budget.step();
+        size = match.groups[Number(next)]?.length ?? 0;
+      }
+    }
+    if (size > available - length) throw new ProgramError("text buffer limit exceeded");
+    length += size;
   }
-  return result;
+  return length;
 }
-function substitute(text, pattern, replacement, budget, global, occurrence = 1) {
+async function replacementText(replacement, match, buffer, budget) {
+  let literal = 0;
+  let tokens2 = 0;
+  for (let index = 0; index < replacement.length; index++) {
+    if (tokens2++ % 256 === 0) await budget.checkpoint();
+    budget.step();
+    const character = replacement[index];
+    if (character !== "&" && (character !== "\\" || index + 1 === replacement.length)) continue;
+    await buffer.append(replacement, literal, index);
+    if (character === "&") {
+      budget.step();
+      await buffer.append(match.groups[0] ?? "");
+    } else {
+      budget.step();
+      const next = replacement[++index];
+      if (next >= "1" && next <= "9") {
+        budget.step();
+        await buffer.append(match.groups[Number(next)] ?? "");
+      } else await buffer.append(next === "n" ? "\n" : next === "t" ? "	" : next);
+    }
+    literal = index + 1;
+  }
+  await buffer.append(replacement, literal);
+}
+async function substitute(text, pattern, replacement, budget, global, occurrence = 1) {
   let search = 0;
   let consumed = 0;
   let previousEnd = -1;
   let encountered = 0;
   let count2 = 0;
-  let result = "";
-  while (search <= text.length) {
-    const match = pattern.find(text, budget, search);
-    if (!match) break;
-    if (match.start === match.end && match.start === previousEnd) {
-      search = match.end + 1;
-      continue;
-    }
-    encountered++;
-    if (encountered >= occurrence) {
-      result = budget.check(result + text.slice(consumed, match.start) + replacementText(replacement, match));
-      consumed = match.end;
-      count2++;
-      if (!global) break;
-    }
-    previousEnd = match.end > match.start ? match.end : -1;
-    search = match.end > match.start ? match.end : match.end + 1;
+  const result = new ReplacementBuffer(budget);
+  try {
+    while (search <= text.length) {
+      await budget.checkpoint();
+      budget.step();
+      const match = pattern.find(text, budget, search);
+      if (!match) break;
+      if (match.start === match.end && match.start === previousEnd) {
+        search = match.end + 1;
+        continue;
+      }
+      encountered++;
+      if (encountered >= occurrence) {
+        const prefix2 = match.start - consumed;
+        result.admit(prefix2);
+        const length = await replacementLength(replacement, match, budget, result.remaining - prefix2);
+        result.admit(prefix2 + length);
+        await result.append(text, consumed, match.start);
+        await replacementText(replacement, match, result, budget);
+        consumed = match.end;
+        count2++;
+        if (!global) break;
+      }
+      previousEnd = match.end > match.start ? match.end : -1;
+      search = match.end > match.start ? match.end : match.end + 1;
+    }
+    budget.step(0);
+    if (!count2) return { text: budget.check(text), count: count2 };
+    await result.append(text, consumed);
+    return { text: await result.finish(), count: count2 };
+  } finally {
+    result.clear();
   }
-  return { text: budget.check(result + text.slice(consumed)), count: count2 };
 }
 
 // packages/safe-bash/src/commands/text-programs/sed.ts
@@ -17935,7 +18061,7 @@ async function execute(program, context, files, quiet, budget) {
             [pattern, hold] = [hold, pattern];
             break;
           case "s": {
-            const changed = substitute(pattern, getPattern(instruction.pattern), instruction.replacement, budget, instruction.global ?? false, instruction.occurrence ?? 1);
+            const changed = await substitute(pattern, getPattern(instruction.pattern), instruction.replacement, budget, instruction.global ?? false, instruction.occurrence ?? 1);
             pattern = changed.text;
             if (changed.count) {
               substituted = true;