@poe-platform/safe-bash 0.1.510 → 0.1.511

package/dist/safe-bash/core.browser.js

@@ -1616,9 +1616,24 @@ async function resetDescendants(node, previous, ledger, signal) {
 }
 async function matchEre(program, subject, ledger, signal) {
   ledger.check(signal);
-  const root = resolveEreProgram(program, ledger);
+  resolveEreProgram(program, ledger);
+  ledger.admitInput("subjectBytes", subject.length, signal);
+  await admitAscii(subject, ledger, signal);
+  return runMatcher(program, subject, ledger, signal, 0, true);
+}
+async function createEreSpanMatcher(program, subject, ledger, signal) {
+  ledger.check(signal);
+  resolveEreProgram(program, ledger);
   ledger.admitInput("subjectBytes", subject.length, signal);
   await admitAscii(subject, ledger, signal);
+  ledger.charge("allocationUnits", 2, signal);
+  return async (start) => {
+    if (!Number.isSafeInteger(start) || start < 0 || start > subject.length) throw new RangeError("Invalid ERE search cursor");
+    return runMatcher(program, subject, ledger, signal, start, false);
+  };
+}
+async function runMatcher(program, subject, ledger, signal, from, materialize) {
+  const root = resolveEreProgram(program, ledger);
   const width = program.groups + 1;
   ledger.charge("work", width * 2, signal);
   ledger.charge("allocationUnits", width * 2 + 1, signal);
@@ -1635,7 +1650,7 @@ async function matchEre(program, subject, ledger, signal) {
     ledger.charge("allocationUnits", 5, signal);
     pending.push({ position, task: next, captures, histories });
   };
-  for (let start = 0; start <= subject.length; start++) {
+  for (let start = from; start <= subject.length; start++) {
     push(start, task(() => ({ kind: "node", node: root, next: null })), emptyCaptures, emptyHistories);
     let best;
     while (pending.length > 0) {
@@ -1720,6 +1735,11 @@ async function matchEre(program, subject, ledger, signal) {
       }
     }
     if (best) {
+      if (!materialize) {
+        ledger.charge("allocationUnits", 2, signal);
+        ledger.check(signal);
+        return Object.freeze({ start, end: best.position });
+      }
       ledger.charge("captureSlots", width, signal);
       let bytes3 = best.position - start;
       for (let group = 1; group < width; group++) {
@@ -1745,8 +1765,9 @@ async function matchEre(program, subject, ledger, signal) {
       return Object.freeze({ matched: true, captures: Object.freeze(captures), values: Object.freeze(values) });
     }
   }
-  ledger.charge("allocationUnits", 3, signal);
   ledger.check(signal);
+  if (!materialize) return void 0;
+  ledger.charge("allocationUnits", 3, signal);
   return Object.freeze({ matched: false, captures: Object.freeze([]), values: Object.freeze([]) });
 }
 
@@ -1760,7 +1781,9 @@ var defaults2 = Object.freeze({
   maxResultBytes: 2048,
   maxWork: 2e6,
   maxAllocationUnits: 1e6,
-  maxStates: 65536
+  maxStates: 65536,
+  maxMatchesPerLine: 128,
+  maxTotalMatches: 128
 });
 var ceilings = Object.freeze({
   maxWorkers: 32,
@@ -1771,7 +1794,9 @@ var ceilings = Object.freeze({
   maxResultBytes: 65536,
   maxWork: 33554432,
   maxAllocationUnits: 4e6,
-  maxStates: 65536
+  maxStates: 65536,
+  maxMatchesPerLine: 1e5,
+  maxTotalMatches: 1e5
 });
 var typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
 var byteLength = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength").get;
@@ -1847,7 +1872,7 @@ function admit(input3, limits, signal) {
     record(row, ["bytes", "all", "terminated"], ["directory", "ancestors"]);
     if (!(row.bytes instanceof Uint8Array) || typeof row.all !== "boolean" || typeof row.terminated !== "boolean" || Object.hasOwn(row, "directory") && typeof row.directory !== "boolean" || Object.hasOwn(row, "ancestors") && typeof row.ancestors !== "boolean") fail("protocol", "invalid row");
     if (Object.hasOwn(row, "directory") || Object.hasOwn(row, "ancestors")) fail("unsupported", "glob row flags are unsupported");
-    if (row.all) fail("unsupported", "all-match enumeration is unsupported");
+    if (row.all && selected.kind !== "grep") fail("unsupported", "rg all-match enumeration is unsupported");
     const length = byteLength.call(row.bytes);
     if (length > limits.maxInputBytes - bytes3) fail("limit", "aggregate input byte limit exceeded");
     bytes3 += length;
@@ -1869,9 +1894,9 @@ function admit(input3, limits, signal) {
     const source2 = new Uint8Array(byteBuffer.call(row.bytes), byteOffset.call(row.bytes), byteLength.call(row.bytes));
     const copy2 = new Uint8Array(source2.length);
     copy2.set(source2);
-    rows2.push({ bytes: copy2, all: false, terminated: row.terminated });
+    rows2.push({ bytes: copy2, all: row.all, terminated: row.terminated });
   }
-  return { id: input3.id, descriptor: ownedDescriptor, rows: rows2, ledger };
+  return { id: input3.id, descriptor: ownedDescriptor, rows: rows2, ledger, limits };
 }
 function admitExpr(input3, limits, signal) {
   signal.throwIfAborted();
@@ -2020,13 +2045,13 @@ async function compileLiteral(bytes3, ledger, signal) {
   }
   return { bytes: bytes3, fallback };
 }
-async function literalStart(program, subject, whole, ledger, signal) {
+async function literalStart(program, subject, whole, ledger, signal, from = 0) {
   const { bytes: bytes3, fallback } = program;
   ledger.charge("work", 1, signal);
   await ledger.checkpoint(signal);
-  if (whole && bytes3.length !== subject.length || bytes3.length > subject.length) return -1;
-  if (bytes3.length === 0) return 0;
-  for (let index = 0, prefix3 = 0; index < subject.length; ) {
+  if (whole && (from !== 0 || bytes3.length !== subject.length) || bytes3.length > subject.length - from) return -1;
+  if (bytes3.length === 0) return from;
+  for (let index = from, prefix3 = 0; index < subject.length; ) {
     ledger.charge("work", 1, signal);
     if (subject[index] === bytes3[prefix3]) {
       index++;
@@ -2037,15 +2062,63 @@ async function literalStart(program, subject, whole, ledger, signal) {
   }
   return -1;
 }
+async function enumerate(input3, row, finders, usage2, signal) {
+  const { ledger, limits } = input3;
+  ledger.charge("allocationUnits", finders.length + 2, signal);
+  const cached = new Array(finders.length);
+  const ranges = [];
+  for (let from = 0; from <= row.bytes.length; ) {
+    let best;
+    for (let index = 0; index < finders.length; index++) {
+      ledger.charge("work", 1, signal);
+      await ledger.checkpoint(signal);
+      let candidate = cached[index];
+      if (candidate === void 0 || candidate !== null && candidate.start < from) {
+        candidate = await finders[index](from) ?? null;
+        cached[index] = candidate;
+      }
+      if (candidate && (!best || candidate.start < best.start || candidate.start === best.start && candidate.end > best.end)) best = candidate;
+    }
+    if (!best) break;
+    if (ranges.length / 2 >= limits.maxMatchesPerLine) fail("limit", "matches per line limit exceeded");
+    if (usage2.count >= limits.maxTotalMatches) fail("limit", "total match limit exceeded");
+    if (usage2.count >= Math.floor(limits.maxResultBytes / 16)) fail("limit", "result byte limit exceeded");
+    ledger.charge("work", 2, signal);
+    ledger.charge("allocationUnits", 24, signal);
+    usage2.count++;
+    ranges.push(best.start, best.end);
+    if (best.end > best.start) from = best.end;
+    else {
+      const byte = row.bytes[best.end];
+      from = best.end + (byte === void 0 || byte < 128 ? 1 : byte < 224 ? 2 : byte < 240 ? 3 : 4);
+    }
+  }
+  ledger.charge("work", ranges.length, signal);
+  await ledger.checkpoint(signal);
+  return new Float64Array(ranges);
+}
 async function executeLiteral(input3, signal) {
   const { descriptor: selected, rows: rows2, ledger } = input3;
   const programs2 = [];
   for (const pattern of selected.patterns) {
     programs2.push(await compileLiteral(await literalBytes(pattern, selected, ledger, signal), ledger, signal));
   }
+  ledger.charge("allocationUnits", 3, signal);
   const results = [];
+  const usage2 = { count: 0 };
   for (const row of rows2) {
     await validateUtf8(row.bytes, ledger, signal);
+    if (row.all) {
+      ledger.charge("allocationUnits", programs2.length * 2, signal);
+      const finders = programs2.map((program) => async (from) => {
+        const start2 = await literalStart(program, row.bytes, selected.whole, ledger, signal, from);
+        if (start2 < 0) return void 0;
+        ledger.charge("allocationUnits", 2, signal);
+        return { start: start2, end: start2 + program.bytes.length };
+      });
+      results.push(await enumerate(input3, row, finders, usage2, signal));
+      continue;
+    }
     let start = -1;
     let end = -1;
     for (const program of programs2) {
@@ -2058,6 +2131,10 @@ async function executeLiteral(input3, signal) {
       if (selected.kind === "grep") break;
     }
     signal.throwIfAborted();
+    if (start >= 0) {
+      if (usage2.count >= input3.limits.maxTotalMatches || usage2.count >= Math.floor(input3.limits.maxResultBytes / 16)) fail("limit", "total match or result byte limit exceeded");
+      usage2.count++;
+    }
     results.push(start < 0 ? new Float64Array() : new Float64Array([start, end]));
   }
   return { id: input3.id, results };
@@ -2073,7 +2150,9 @@ async function execute(input3, signal) {
     const fragments = selected.whole ? [{ text: "^(", literal: false }, { text: pattern, literal: selected.fixed }, { text: ")$", literal: false }] : [{ text: pattern, literal: selected.fixed }];
     programs2.push(await compileEre(fragments, ledger, signal));
   }
+  ledger.charge("allocationUnits", 3, signal);
   const results = [];
+  const usage2 = { count: 0 };
   for (const row of rows2) {
     ledger.charge("allocationUnits", row.bytes.length * 2 + 2, signal);
     const characters = [];
@@ -2084,6 +2163,13 @@ async function execute(input3, signal) {
       await ledger.checkpoint(signal);
     }
     const subject = characters.join("");
+    if (row.all) {
+      ledger.charge("allocationUnits", programs2.length + 1, signal);
+      const finders = [];
+      for (const program of programs2) finders.push(await createEreSpanMatcher(program, subject, ledger, signal));
+      results.push(await enumerate(input3, row, finders, usage2, signal));
+      continue;
+    }
     let span;
     for (const program of programs2) {
       const match = await matchEre(program, subject, ledger, signal);
@@ -2096,6 +2182,10 @@ async function execute(input3, signal) {
       if (!span || candidate.start < span.start) span = candidate;
     }
     signal.throwIfAborted();
+    if (span) {
+      if (usage2.count >= input3.limits.maxTotalMatches || usage2.count >= Math.floor(input3.limits.maxResultBytes / 16)) fail("limit", "total match or result byte limit exceeded");
+      usage2.count++;
+    }
     results.push(span ? new Float64Array([span.start, span.end]) : new Float64Array());
   }
   return { id: input3.id, results };
@@ -10792,6 +10882,7 @@ function createGrepCommands(executor) {
       const maxCount = value(parsed, "m") === void 0 ? Infinity : integer(value(parsed, "m"));
       const batchSize = Number.isFinite(maxCount) || parsed.flags.has("q") || parsed.flags.has("l") || parsed.flags.has("L") ? 1 : 128;
       const delimiter = parsed.flags.has("z") ? "\0" : "\n";
+      const extractMatches = parsed.flags.has("o") && !["c", "q", "l", "L", "v"].some((flag) => parsed.flags.has(flag));
       let anySelected = false;
       let failed = false;
       for (const name2 of names) {
@@ -10803,7 +10894,7 @@ function createGrepCommands(executor) {
           const available2 = new AvailableRecords(parsed.flags.has("z") ? 0 : 10, bufferLimit);
           const source2 = name2 === "-" ? input(context2) : requiredFileInput(context2, grepRequirements, "file", name2, bufferLimit);
           records: if (maxCount > 0) for await (const batch of available2.batches(lines(available2.source(source2), parsed.flags.has("z") ? 0 : 10), (line) => line.bytes.length, () => batchSize)) {
-            const results = await session.run(descriptor2, batch.map((line) => ({ bytes: line.bytes, all: parsed.flags.has("o"), terminated: line.terminated })));
+            const results = await session.run(descriptor2, batch.map((line) => ({ bytes: line.bytes, all: extractMatches, terminated: line.terminated })));
             for (let index = 0; index < batch.length; index++) {
               const line = batch[index];
               context2.signal.throwIfAborted();