@poe-platform/safe-bash 0.1.82 → 0.1.83

package/dist/safe-bash/browser.js

@@ -2623,6 +2623,69 @@ var predicateRequirements = [
   { id: "access", description: "Inspect path access permissions", capabilities: ["access"] }
 ];
 
+// packages/safe-bash/src/commands/record-buffer.ts
+init_platform();
+var segmentSize = 4096;
+var RecordBuffer = class {
+  constructor(capacity, finalizationCapacity = capacity * 2) {
+    this.capacity = capacity;
+    this.finalizationCapacity = finalizationCapacity;
+  }
+  capacity;
+  finalizationCapacity;
+  #segments = [];
+  #size = 0;
+  #allocated = 0;
+  get size() {
+    return this.#size;
+  }
+  #admit(length) {
+    if (length > this.capacity - this.#size) {
+      throw new FsError("EFBIG", { message: "line buffer limit exceeded" });
+    }
+  }
+  append(bytes2, start = 0, end = bytes2.length) {
+    this.#admit(end - start);
+    let offset = start;
+    while (offset < end) {
+      let segment = this.#segments.at(-1);
+      const used = this.#size % segmentSize;
+      if (!segment || used === 0) {
+        segment = new Uint8Array(Math.min(segmentSize, this.capacity - this.#allocated));
+        this.#segments.push(segment);
+        this.#allocated += segment.length;
+      }
+      const length = Math.min(end - offset, segment.length - used);
+      segment.set(bytes2.subarray(offset, offset + length), used);
+      this.#size += length;
+      offset += length;
+    }
+  }
+  finish(admit2, bytes2, start = 0, end = bytes2?.length ?? 0) {
+    this.#admit(end - start);
+    const size = this.#size + end - start;
+    admit2?.(size);
+    if (size > this.finalizationCapacity - this.#allocated) {
+      throw new FsError("EFBIG", { message: "line finalization buffer limit exceeded" });
+    }
+    const result = new Uint8Array(size);
+    let offset = 0;
+    for (const segment of this.#segments) {
+      const length = Math.min(segment.length, this.#size - offset);
+      result.set(segment.subarray(0, length), offset);
+      offset += length;
+    }
+    if (bytes2 && end > start) result.set(bytes2.subarray(start, end), offset);
+    this.clear();
+    return result;
+  }
+  clear() {
+    this.#segments = [];
+    this.#size = 0;
+    this.#allocated = 0;
+  }
+};
+
 // packages/safe-bash/src/commands/internal.ts
 var encoder2 = new TextEncoder();
 var decoder2 = new TextDecoder();
@@ -2796,29 +2859,22 @@ function concatenate(chunks, size = chunks.reduce((sum, chunk) => sum + chunk.le
   }
   return result;
 }
-async function* lines(source, separator = 10) {
-  let pending = [];
-  let size = 0;
-  for await (const chunk of source) {
-    let start = 0;
-    for (let offset = 0; offset < chunk.length; offset++) {
-      if (chunk[offset] !== separator) continue;
-      const part = chunk.slice(start, offset);
-      size += part.length;
-      if (size > bufferLimit) throw new FsError("EFBIG", { message: "line buffer limit exceeded" });
-      pending.push(part);
-      yield { bytes: concatenate(pending, size), terminated: true };
-      pending = [];
-      size = 0;
-      start = offset + 1;
-    }
-    if (start < chunk.length) {
-      pending.push(new Uint8Array(chunk.subarray(start)));
-      size += chunk.length - start;
-      if (size > bufferLimit) throw new FsError("EFBIG", { message: "line buffer limit exceeded" });
+async function* lines(source, separator = 10, admit2) {
+  const pending = new RecordBuffer(bufferLimit);
+  try {
+    for await (const chunk of source) {
+      let start = 0;
+      for (let offset = 0; offset < chunk.length; offset++) {
+        if (chunk[offset] !== separator) continue;
+        yield { bytes: pending.finish(admit2, chunk, start, offset), terminated: true };
+        start = offset + 1;
+      }
+      pending.append(chunk, start);
     }
+    if (pending.size) yield { bytes: pending.finish(admit2), terminated: false };
+  } finally {
+    pending.clear();
   }
-  if (size) yield { bytes: concatenate(pending, size), terminated: false };
 }
 function emptyInput() {
   return toByteSource("");
@@ -4939,40 +4995,27 @@ async function emitRecords(context, records, destination) {
   }
 }
 async function collectSortRecords(source, delimiter, budget, signal, accept) {
-  let pending = [];
-  let size = 0;
-  for await (const chunk of source) {
-    let start = 0;
-    for (let offset = 0; offset < chunk.length; offset++) {
-      if (chunk[offset] !== delimiter) continue;
-      size += offset - start;
-      if (size > bufferLimit) throw new FsError("EFBIG", { message: "line buffer limit exceeded" });
-      signal.throwIfAborted();
-      budget.admit(size);
-      const part = chunk.subarray(start, offset);
-      let record4;
-      if (pending.length) {
-        pending.push(part);
-        record4 = concatenate(pending, size);
-      } else record4 = new Uint8Array(part);
-      const accepted = accept(record4);
-      if ((accepted instanceof Promise ? await accepted : accepted) === false) return false;
-      pending = [];
-      size = 0;
-      start = offset + 1;
-    }
-    if (start < chunk.length) {
-      pending.push(new Uint8Array(chunk.subarray(start)));
-      size += chunk.length - start;
-      if (size > bufferLimit) throw new FsError("EFBIG", { message: "line buffer limit exceeded" });
-    }
-  }
-  if (size) {
+  const pending = new RecordBuffer(bufferLimit);
+  const admit2 = (length) => {
     signal.throwIfAborted();
-    budget.admit(size);
-    return await accept(concatenate(pending, size)) !== false;
+    budget.admit(length);
+  };
+  try {
+    for await (const chunk of source) {
+      let start = 0;
+      for (let offset = 0; offset < chunk.length; offset++) {
+        if (chunk[offset] !== delimiter) continue;
+        const accepted = accept(pending.finish(admit2, chunk, start, offset));
+        if ((accepted instanceof Promise ? await accepted : accepted) === false) return false;
+        start = offset + 1;
+      }
+      pending.append(chunk, start);
+    }
+    if (pending.size) return await accept(pending.finish(admit2)) !== false;
+    return true;
+  } finally {
+    pending.clear();
   }
-  return true;
 }
 function textCommands() {
   return [
@@ -5238,7 +5281,7 @@ function textCommands() {
                 if (start >= 0) await writer.write(line.bytes.subarray(start, end));
               }
             } else {
-              const decoder3 = new TextDecoder();
+              const decoder3 = new TextDecoder("utf-8", { ignoreBOM: true });
               let index = 0;
               let emitted = false;
               let previousIncluded = false;