@poe-platform/safe-bash 0.1.718 → 0.1.719

package/dist/safe-bash/chunks/{chunk-YOUOJRAP.js → chunk-ZHWEPWDW.js}

@@ -33,6 +33,9 @@ init_platform();
 function foldAscii(code) {
   return code >= 65 && code <= 90 ? code + 32 : code;
 }
+function isAsciiWord(code) {
+  return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 95;
+}
 
 // packages/safe-bash/src/commands/expr/bre-engine.ts
 init_platform();
@@ -8804,7 +8807,7 @@ async function matchEre(program, subject, ledger, signal) {
   await admitAscii(subject, ledger, signal);
   return runMatcher(program, subject, ledger, signal, 0, true);
 }
-async function prepareUtf8EreSubject(bytes2, ledger, signal) {
+async function prepareUtf8EreSubject(bytes2, ledger, signal, leftmostFirst = false, word = false) {
   ledger.check(signal);
   ledger.admitInput("subjectBytes", bytes2.length, signal);
   ledger.charge("allocationUnits", bytes2.length * 11 + 16, signal);
@@ -8815,7 +8818,7 @@ async function prepareUtf8EreSubject(bytes2, ledger, signal) {
   const offsets = [];
   for (let offset = 0; offset < owned.length; ) {
     const first = owned[offset];
-    const width = first < 128 ? 1 : first < 224 ? 2 : first < 240 ? 3 : 4;
+    const width = word || first < 128 ? 1 : first < 224 ? 2 : first < 240 ? 3 : 4;
     ledger.charge("work", width, signal);
     await ledger.checkpoint(signal);
     offsets.push(offset);
@@ -8840,14 +8843,14 @@ async function prepareUtf8EreSubject(bytes2, ledger, signal) {
         else upper = middle;
       }
       if (offsets[lower] !== start) throw new RangeError("UTF-8 ERE cursor must be a scalar boundary");
-      const span = await runMatcher(program, subject, ledger, signal, lower, false);
+      const span = await runMatcher(program, subject, ledger, signal, lower, false, leftmostFirst, word);
       if (!span) return void 0;
       ledger.charge("allocationUnits", 2, signal);
       return Object.freeze({ start: offsets[span.start], end: offsets[span.end] });
     };
   };
 }
-async function runMatcher(program, subject, ledger, signal, from, materialize) {
+async function runMatcher(program, subject, ledger, signal, from, materialize, leftmostFirst = false, word = false) {
   const root = resolveEreProgram(program, ledger);
   const width = program.groups + 1;
   ledger.charge("work", width * 2, signal);
@@ -8866,6 +8869,11 @@ async function runMatcher(program, subject, ledger, signal, from, materialize) {
     pending.push({ position, task: next, captures, histories });
   };
   for (let start = from; start <= subject.length; start++) {
+    if (word) {
+      ledger.charge("work", 1, signal);
+      await ledger.checkpoint(signal);
+      if (isAsciiWord(subject.charCodeAt(start - 1))) continue;
+    }
     push(start, task(() => ({ kind: "node", node: root, next: null })), emptyCaptures, emptyHistories);
     let best;
     while (pending.length > 0) {
@@ -8874,6 +8882,11 @@ async function runMatcher(program, subject, ledger, signal, from, materialize) {
       const state = pending.pop();
       const current = state.task;
       if (current === null) {
+        if (word && isAsciiWord(subject.charCodeAt(state.position))) continue;
+        if (leftmostFirst) {
+          best = state;
+          break;
+        }
         if (!best || await preferred(state, best, ledger, signal)) best = state;
         continue;
       }
@@ -8915,7 +8928,7 @@ async function runMatcher(program, subject, ledger, signal, from, materialize) {
         case "literal":
         case "set": {
           const code = subject.charCodeAt(state.position);
-          if (state.position < subject.length && (node.kind === "dot" || node.kind === "literal" && (node.insensitive ? foldAscii(node.code) === foldAscii(code) : node.code === code) || node.kind === "set" && (code < 128 ? node.members[code] : node.nonAscii))) {
+          if (state.position < subject.length && (node.kind === "dot" && (!leftmostFirst || code !== 10) || node.kind === "literal" && (node.insensitive ? foldAscii(node.code) === foldAscii(code) : node.code === code) || node.kind === "set" && (code < 128 ? node.members[code] : node.nonAscii))) {
             push(state.position + 1, current.next, state.captures, state.histories);
           }
           break;
@@ -9059,13 +9072,12 @@ function descriptor(value, limits) {
   if (value === null || typeof value !== "object") fail("protocol", "invalid descriptor");
   const kind = Object.getOwnPropertyDescriptor(value, "kind");
   if (!kind || !("value" in kind)) fail("protocol", "invalid descriptor kind");
-  if (kind.value !== "grep" && kind.value !== "rg") fail("unsupported", "only grep and fixed rg selection descriptors are supported");
+  if (kind.value !== "grep" && kind.value !== "rg") fail("unsupported", "only grep and rg selection descriptors are supported");
   const flags = kind.value === "grep" ? ["fixed", "extended", "insensitive", "whole", "word"] : ["fixed", "whole", "word", "nullData"];
   record(value, ["kind", "patterns", ...flags, ...kind.value === "rg" ? ["case"] : []]);
   for (const flag of flags) if (typeof value[flag] !== "boolean") fail("protocol", `invalid ${flag} flag`);
   if (kind.value === "rg" && !["sensitive", "insensitive", "smart"].includes(value.case)) fail("protocol", "invalid case flag");
-  if (value.word || kind.value === "rg" && value.case !== "sensitive") fail("unsupported", "word matching and rg case-insensitive selection are unsupported");
-  if (kind.value === "rg" && !value.fixed) fail("unsupported", "rg regex modes are unsupported; use fixed UTF-8 patterns");
+  if (kind.value === "rg" && (value.word || value.case !== "sensitive")) fail("unsupported", "rg word matching and case-insensitive selection are unsupported");
   array(value.patterns, limits.maxPatterns, "pattern");
   let bytes2 = 0;
   for (let index = 0; index < value.patterns.length; index++) {
@@ -9087,7 +9099,6 @@ function admit(input, 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 && selected.kind !== "grep") fail("unsupported", "rg all-match enumeration is unsupported");
     const length = byteLength.call(row.bytes);
     if (length > limits.maxInputBytes - bytes2) fail("limit", "aggregate input byte limit exceeded");
     bytes2 += length;
@@ -9271,17 +9282,28 @@ async function compileLiteral(bytes2, ledger, signal, insensitive = false) {
   }
   return { bytes: bytes2, fallback, insensitive };
 }
-async function literalStart(program, subject, whole, ledger, signal, from = 0) {
+async function literalStart(program, subject, whole, word, ledger, signal, from = 0) {
   const { bytes: bytes2, fallback } = program;
   ledger.charge("work", 1, signal);
   await ledger.checkpoint(signal);
   if (whole && (from !== 0 || bytes2.length !== subject.length) || bytes2.length > subject.length - from) return -1;
-  if (bytes2.length === 0) return from;
+  if (bytes2.length === 0) {
+    for (let start = from; start <= subject.length; start++) {
+      ledger.charge("work", 1, signal);
+      await ledger.checkpoint(signal);
+      if (!word || !isAsciiWord(subject[start - 1] ?? -1) && !isAsciiWord(subject[start] ?? -1)) return start;
+    }
+    return -1;
+  }
   for (let index = from, prefix = 0; index < subject.length; ) {
     ledger.charge("work", 1, signal);
     if ((program.insensitive ? foldAscii(subject[index]) : subject[index]) === bytes2[prefix]) {
       index++;
-      if (++prefix === bytes2.length) return index - prefix;
+      if (++prefix === bytes2.length) {
+        const start = index - prefix;
+        if (!word || !isAsciiWord(subject[start - 1] ?? -1) && !isAsciiWord(subject[index] ?? -1)) return start;
+        prefix = fallback[prefix - 1];
+      }
     } else if (prefix > 0) prefix = fallback[prefix - 1];
     else index++;
     await ledger.checkpoint(signal);
@@ -9293,6 +9315,9 @@ async function enumerate(input, row, finders, usage, signal) {
   ledger.charge("allocationUnits", finders.length + 2, signal);
   const cached = new Array(finders.length);
   const ranges = [];
+  const byteEmpty = input.descriptor.kind === "rg" && !input.descriptor.whole && input.descriptor.patterns.length === 1 && input.descriptor.patterns[0] === "";
+  const byteCursor = input.descriptor.kind === "grep" && input.descriptor.word;
+  let previousEnd = -1;
   for (let from = 0; from <= row.bytes.length; ) {
     let best;
     for (let index = 0; index < finders.length; index++) {
@@ -9303,9 +9328,14 @@ async function enumerate(input, row, finders, usage, signal) {
         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 (candidate && (!best || candidate.start < best.start || input.descriptor.kind === "grep" && candidate.start === best.start && candidate.end > best.end)) best = candidate;
+    }
+    if (!best || byteEmpty && !row.terminated && best.start === row.bytes.length) break;
+    if (input.descriptor.kind === "rg" && !byteEmpty && best.start === best.end && best.start === previousEnd) {
+      const byte = row.bytes[best.end];
+      from = best.end + (byte === void 0 || byte < 128 ? 1 : byte < 224 ? 2 : byte < 240 ? 3 : 4);
+      continue;
     }
-    if (!best) break;
     if (ranges.length / 2 >= limits.maxMatchesPerLine) fail("limit", "matches per line limit exceeded");
     if (usage.count >= limits.maxTotalMatches) fail("limit", "total match limit exceeded");
     if (usage.count >= Math.floor(limits.maxResultBytes / 16)) fail("limit", "result byte limit exceeded");
@@ -9313,10 +9343,11 @@ async function enumerate(input, row, finders, usage, signal) {
     ledger.charge("allocationUnits", 24, signal);
     usage.count++;
     ranges.push(best.start, best.end);
+    previousEnd = 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);
+      from = best.end + (byteEmpty || byteCursor || byte === void 0 || byte < 128 ? 1 : byte < 224 ? 2 : byte < 240 ? 3 : 4);
     }
   }
   ledger.charge("work", ranges.length, signal);
@@ -9337,7 +9368,7 @@ async function executeLiteral(input, 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);
+        const start2 = await literalStart(program, row.bytes, selected.whole, selected.word, ledger, signal, from);
         if (start2 < 0) return void 0;
         ledger.charge("allocationUnits", 2, signal);
         return { start: start2, end: start2 + program.bytes.length };
@@ -9348,7 +9379,7 @@ async function executeLiteral(input, signal) {
     let start = -1;
     let end = -1;
     for (const program of programs2) {
-      const candidate = await literalStart(program, row.bytes, selected.whole, ledger, signal);
+      const candidate = await literalStart(program, row.bytes, selected.whole, selected.word, ledger, signal);
       if (candidate < 0) continue;
       if (start < 0 || candidate < start) {
         start = candidate;
@@ -9367,7 +9398,19 @@ async function executeLiteral(input, signal) {
 }
 async function execute(input, signal) {
   const { descriptor: selected, rows, ledger } = input;
-  if (selected.fixed) return executeLiteral(input, signal);
+  let literal = selected.fixed;
+  if (!literal && selected.kind === "rg") {
+    literal = true;
+    patterns: for (const pattern of selected.patterns) {
+      ledger.charge("work", pattern.length, signal);
+      await ledger.checkpoint(signal);
+      for (const character of pattern) if ("\\.^$[]()|*+?{}".includes(character)) {
+        literal = false;
+        break patterns;
+      }
+    }
+  }
+  if (literal) return executeLiteral(input, signal);
   const programs2 = [];
   for (const pattern of selected.patterns) {
     if (selected.kind === "rg" && !selected.nullData && pattern.includes("\n")) fail("unsupported", "rg multiline matching is unsupported");
@@ -9385,7 +9428,7 @@ async function execute(input, signal) {
   const results = [];
   const usage = { count: 0 };
   for (const row of rows) {
-    const subject = await prepareUtf8EreSubject(row.bytes, ledger, signal);
+    const subject = await prepareUtf8EreSubject(row.bytes, ledger, signal, selected.kind === "rg", selected.word);
     if (row.all) {
       ledger.charge("allocationUnits", programs2.length + 1, signal);
       const finders = [];
@@ -12157,4 +12200,4 @@ export {
   createCsplitCommands,
   csplitCommands
 };
-//# sourceMappingURL=chunk-YOUOJRAP.js.map
+//# sourceMappingURL=chunk-ZHWEPWDW.js.map