@poe-platform/safe-bash 0.1.800 → 0.1.802

package/dist/safe-bash/command-chunks/{chunk-SAMH7SQE.js → chunk-6GWJUQAV.js}

@@ -1,18 +1,77 @@
 import {
   ReplacementBuffer
-} from "./chunk-N2F74VRO.js";
+} from "./chunk-VT6MJBEI.js";
 import {
   parseRustPattern
-} from "./chunk-T5H5UJQ3.js";
+} from "./chunk-YVNGTIJO.js";
 import {
   ProgramError
-} from "./chunk-HLGKIZ25.js";
+} from "./chunk-X54L3DBL.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";
 
 // packages/safe-bash-regex-engine/src/text/regex.ts
 init_buffer();
+
+// packages/safe-bash-regex-engine/src/text/byte-text.ts
+init_buffer();
+function decodeByteText(input, budget) {
+  budget?.step(input.length);
+  let ascii = true;
+  for (let i = 0; i < input.length; i++) if (input.charCodeAt(i) >= 128) {
+    ascii = false;
+    break;
+  }
+  if (ascii) return { text: input };
+  if (budget && (input.length + 1) * 6 > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+  const offsets = new Uint32Array(input.length + 1);
+  let text = "";
+  for (let index = 0; index < input.length; ) {
+    const first = input.charCodeAt(index);
+    let width = first < 128 ? 1 : first >= 194 && first <= 223 ? 2 : first >= 224 && first <= 239 ? 3 : first >= 240 && first <= 244 ? 4 : 0;
+    if (index + width > input.length) width = 0;
+    for (let next = 1; next < width; next++) {
+      const byte = input.charCodeAt(index + next);
+      if (byte < 128 || byte > 191 || next === 1 && (first === 224 && byte < 160 || first === 237 && byte > 159 || first === 240 && byte < 144 || first === 244 && byte > 143)) {
+        width = 0;
+        break;
+      }
+    }
+    let code = width === 0 ? 56320 + first : width === 1 ? first : first & 127 >> width;
+    for (let next = 1; next < width; next++) code = code * 64 + (input.charCodeAt(index + next) & 63);
+    const character = String.fromCodePoint(code);
+    if (character.length === 2) offsets[text.length + 1] = index;
+    index += width || 1;
+    text += character;
+    offsets[text.length] = index;
+  }
+  return { text, offsets: offsets.subarray(0, text.length + 1) };
+}
+function byteTextPosition(decoded, byteOffset) {
+  if (!decoded.offsets) return byteOffset;
+  let low = 0, high = decoded.offsets.length;
+  while (low < high) {
+    const mid = low + Math.floor((high - low) / 2);
+    if (decoded.offsets[mid] < byteOffset) low = mid + 1;
+    else high = mid;
+  }
+  return low;
+}
+function encodeByteText(text) {
+  let bytes = "";
+  for (const character of text) {
+    const code = character.codePointAt(0);
+    if (code < 128) bytes += character;
+    else if (code >= 56448 && code <= 56575) bytes += String.fromCharCode(code - 56320);
+    else if (code < 2048) bytes += String.fromCharCode(192 | code >> 6, 128 | code & 63);
+    else if (code < 65536) bytes += String.fromCharCode(224 | code >> 12, 128 | code >> 6 & 63, 128 | code & 63);
+    else bytes += String.fromCharCode(240 | code >> 18, 128 | code >> 12 & 63, 128 | code >> 6 & 63, 128 | code & 63);
+  }
+  return bytes;
+}
+
+// packages/safe-bash-regex-engine/src/text/regex.ts
 function isWordChar(ch) {
   if (ch === void 0) return false;
   const code = ch.charCodeAt(0);
@@ -307,16 +366,18 @@ function matchChainAt(steps, prefixLen, anchoredEnd, text, startPos, outOffsets,
       cursor += val.length;
     } else if (step.kind === "char") {
       if (cursor >= textEnd) return -1;
-      const code = text.charCodeAt(cursor);
-      if (code < 128 ? step.ascii[code] === 0 : !step.accepts(text[cursor])) return -1;
-      cursor++;
+      const code = text.codePointAt(cursor);
+      if (code < 128 ? step.ascii[code] === 0 : !step.accepts(String.fromCodePoint(code))) return -1;
+      cursor += code > 65535 ? 2 : 1;
     } else {
+      let count = 0;
       while (cursor < textEnd) {
-        const code = text.charCodeAt(cursor);
-        if (code < 128 ? step.ascii[code] === 0 : !step.accepts(text[cursor])) break;
-        cursor++;
+        const code = text.codePointAt(cursor);
+        if (code < 128 ? step.ascii[code] === 0 : !step.accepts(String.fromCodePoint(code))) break;
+        cursor += code > 65535 ? 2 : 1;
+        count++;
       }
-      if (cursor - stepStart < step.minimum) return -1;
+      if (count < step.minimum) return -1;
     }
     if (step.group > 0) {
       outOffsets[step.group * 2] = stepStart;
@@ -380,7 +441,8 @@ var Pattern = class {
       accepts: (candidate) => ignoreCase ? candidate.toLowerCase() === character.toLowerCase() : candidate === character
     });
     const escaped = () => {
-      const character = source[offset++];
+      const character = offset < source.length ? String.fromCodePoint(source.codePointAt(offset)) : void 0;
+      offset += character?.length ?? 1;
       if (character === void 0) throw new ProgramError("trailing backslash in regular expression");
       if (dialect === "awk") {
         const octal = "01234567".includes(character);
@@ -413,7 +475,8 @@ var Pattern = class {
         }
         if (source.startsWith("[.", offset) || source.startsWith("[=", offset)) throw new ProgramError("collating and equivalence classes are not supported");
         const readBracketChar = () => {
-          const ch = source[offset++];
+          const ch = String.fromCodePoint(source.codePointAt(offset));
+          offset += ch.length;
           if (ch !== "\\") return ch;
           if (dialect === "sed") {
             const next = source[offset];
@@ -440,7 +503,7 @@ var Pattern = class {
       } };
     };
     const atom = (atStart, afterBegin) => {
-      const token = dialect === "jq" && offset < source.length ? String.fromCodePoint(source.codePointAt(offset)) : source[offset];
+      const token = offset < source.length ? String.fromCodePoint(source.codePointAt(offset)) : source[offset];
       offset += token?.length ?? 1;
       if (token === "[") return bracket();
       if (token === "\\") {
@@ -872,18 +935,20 @@ var Pattern = class {
         let searchFrom = from;
         while (searchFrom < textEnd) {
           while (searchFrom < textEnd) {
-            const c = text.charCodeAt(searchFrom);
-            if (c < 128 ? headAscii[c] !== 0 : headAccepts(text[searchFrom])) break;
-            searchFrom++;
+            const c = text.codePointAt(searchFrom);
+            if (c < 128 ? headAscii[c] !== 0 : headAccepts(String.fromCodePoint(c))) break;
+            searchFrom += c > 65535 ? 2 : 1;
           }
           if (searchFrom >= textEnd) break;
-          let runEnd = searchFrom + 1;
+          let runEnd = searchFrom + (text.codePointAt(searchFrom) > 65535 ? 2 : 1);
+          let count = 1;
           while (runEnd < textEnd) {
-            const c = text.charCodeAt(runEnd);
-            if (c < 128 ? headAscii[c] === 0 : !headAccepts(text[runEnd])) break;
-            runEnd++;
+            const c = text.codePointAt(runEnd);
+            if (c < 128 ? headAscii[c] === 0 : !headAccepts(String.fromCodePoint(c))) break;
+            runEnd += c > 65535 ? 2 : 1;
+            count++;
           }
-          if (runEnd - searchFrom >= headMin) {
+          if (count >= headMin) {
             const end = matchChainAt(steps, 0, anchoredEnd2, text, searchFrom, outOffsets, this.groupCount, textEnd, 0);
             if (end >= 0) {
               found2 = searchFrom;
@@ -891,7 +956,7 @@ var Pattern = class {
               break;
             }
           }
-          searchFrom = runEnd + 1;
+          searchFrom = runEnd + ((text.codePointAt(runEnd) ?? 0) > 65535 ? 2 : 1);
         }
       }
       const positionsTried2 = anchoredStart2 ? 1 : found2 >= 0 ? found2 - from + 1 : textEnd - from + 1;
@@ -912,12 +977,14 @@ var Pattern = class {
         if (textStart + prefix.length <= textEnd && text.startsWith(prefix, textStart)) {
           const pos = textStart + prefix.length;
           let cursor = pos;
+          let count = 0;
           while (cursor < textEnd) {
-            const code = text.charCodeAt(cursor);
-            if (code < 128 ? ascii[code] === 0 : !accepts(text[cursor])) break;
-            cursor++;
+            const code = text.codePointAt(cursor);
+            if (code < 128 ? ascii[code] === 0 : !accepts(String.fromCodePoint(code))) break;
+            cursor += code > 65535 ? 2 : 1;
+            count++;
           }
-          if (cursor - pos >= minimum && (!anchoredEnd2 || cursor === textEnd)) {
+          if (count >= minimum && (!anchoredEnd2 || cursor === textEnd)) {
             found2 = textStart;
             matchEnd = cursor;
             groupStart = pos;
@@ -928,26 +995,28 @@ var Pattern = class {
         let searchFrom = from;
         const maxStart = textEnd - minimum;
         while (searchFrom <= maxStart) {
-          const c0 = text.charCodeAt(searchFrom);
-          if (c0 < 128 ? ascii[c0] === 0 : !accepts(text[searchFrom])) {
-            searchFrom++;
+          const c0 = text.codePointAt(searchFrom);
+          if (c0 < 128 ? ascii[c0] === 0 : !accepts(String.fromCodePoint(c0))) {
+            searchFrom += c0 > 65535 ? 2 : 1;
             continue;
           }
           const idx = searchFrom;
-          let cursor = idx + 1;
+          let cursor = idx + (c0 > 65535 ? 2 : 1);
+          let count = 1;
           while (cursor < textEnd) {
-            const code = text.charCodeAt(cursor);
-            if (code < 128 ? ascii[code] === 0 : !accepts(text[cursor])) break;
-            cursor++;
+            const code = text.codePointAt(cursor);
+            if (code < 128 ? ascii[code] === 0 : !accepts(String.fromCodePoint(code))) break;
+            cursor += code > 65535 ? 2 : 1;
+            count++;
           }
-          if (cursor - idx >= minimum && (!anchoredEnd2 || cursor === textEnd)) {
+          if (count >= minimum && (!anchoredEnd2 || cursor === textEnd)) {
             found2 = idx;
             matchEnd = cursor;
             groupStart = idx;
             groupEnd = cursor;
             break;
           }
-          searchFrom = cursor + 1;
+          searchFrom = cursor + ((text.codePointAt(cursor) ?? 0) > 65535 ? 2 : 1);
         }
       } else {
         let searchFrom = from;
@@ -956,12 +1025,14 @@ var Pattern = class {
           if (idx < 0 || idx > textEnd - prefix.length) break;
           const pos = idx + prefix.length;
           let cursor = pos;
+          let count = 0;
           while (cursor < textEnd) {
-            const code = text.charCodeAt(cursor);
-            if (code < 128 ? ascii[code] === 0 : !accepts(text[cursor])) break;
-            cursor++;
+            const code = text.codePointAt(cursor);
+            if (code < 128 ? ascii[code] === 0 : !accepts(String.fromCodePoint(code))) break;
+            cursor += code > 65535 ? 2 : 1;
+            count++;
           }
-          if (cursor - pos >= minimum && (!anchoredEnd2 || cursor === textEnd)) {
+          if (count >= minimum && (!anchoredEnd2 || cursor === textEnd)) {
             found2 = idx;
             matchEnd = cursor;
             groupStart = pos;
@@ -1107,12 +1178,14 @@ var Pattern = class {
       if (text.startsWith(prefix)) {
         const pos = prefix.length;
         let cursor = pos;
+        let count = 0;
         while (cursor < text.length) {
-          const code = text.charCodeAt(cursor);
-          if (code < 128 ? ascii[code] === 0 : !accepts(text[cursor])) break;
-          cursor++;
+          const code = text.codePointAt(cursor);
+          if (code < 128 ? ascii[code] === 0 : !accepts(String.fromCodePoint(code))) break;
+          cursor += code > 65535 ? 2 : 1;
+          count++;
         }
-        if (cursor - pos >= minimum && (!anchoredEnd || cursor === text.length)) {
+        if (count >= minimum && (!anchoredEnd || cursor === text.length)) {
           found = 0;
           matchEnd = cursor;
           groupStart = pos;
@@ -1126,19 +1199,21 @@ var Pattern = class {
         if (idx < 0) break;
         const pos = idx + prefix.length;
         let cursor = pos;
+        let count = 0;
         while (cursor < text.length) {
-          const code = text.charCodeAt(cursor);
-          if (code < 128 ? ascii[code] === 0 : !accepts(text[cursor])) break;
-          cursor++;
+          const code = text.codePointAt(cursor);
+          if (code < 128 ? ascii[code] === 0 : !accepts(String.fromCodePoint(code))) break;
+          cursor += code > 65535 ? 2 : 1;
+          count++;
         }
-        if (cursor - pos >= minimum && (!anchoredEnd || cursor === text.length)) {
+        if (count >= minimum && (!anchoredEnd || cursor === text.length)) {
           found = idx;
           matchEnd = cursor;
           groupStart = pos;
           groupEnd = cursor;
           break;
         }
-        searchFrom = idx + 1;
+        searchFrom = idx + ((text.codePointAt(idx) ?? 0) > 65535 ? 2 : 1);
       }
     }
     const positionsTried = anchoredStart ? 1 : found >= 0 ? found - from + 1 : text.length - from + 1;
@@ -1211,14 +1286,16 @@ var Pattern = class {
       return budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
     };
     if (this.linear) {
-      for (let start = from; start <= text.length && (!this.anchored || start === 0); start++) {
+      for (let start = from; start <= text.length && (!this.anchored || start === 0); start += (text.codePointAt(start) ?? 0) > 65535 ? 2 : 1) {
         let position = start;
         for (const instruction of this.code) {
           const paused = work(2);
           if (paused) await paused;
           if (instruction.kind === "character") {
-            if (position >= text.length || !instruction.accepts(text[position])) break;
-            position++;
+            if (position >= text.length) break;
+            const character = String.fromCodePoint(text.codePointAt(position));
+            if (!instruction.accepts(character)) break;
+            position += character.length;
           } else if (instruction.kind === "begin" && position !== 0 || instruction.kind === "end" && position !== text.length) break;
           else if (instruction.kind === "match") {
             if (position - start > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
@@ -1261,7 +1338,7 @@ var Pattern = class {
         }
         if (!pending && !positions.size) break;
         if (!pending) {
-          position++;
+          position += (text.codePointAt(position) ?? 0) > 65535 ? 2 : 1;
           continue;
         }
         const reversed = work(pending.length);
@@ -1320,7 +1397,10 @@ var Pattern = class {
             visited.set(state, thread.start);
             const instruction = this.code[thread.pc];
             if (instruction.kind === "character") {
-              if (position < text.length && instruction.accepts(text[position])) enqueue(position + 1, thread.pc + 1, thread.start, thread.captures);
+              if (position < text.length) {
+                const character = String.fromCodePoint(text.codePointAt(position));
+                if (instruction.accepts(character)) enqueue(position + character.length, thread.pc + 1, thread.start, thread.captures);
+              }
             } else if (instruction.kind === "backreference") {
               const begin = thread.captures[instruction.index * 2];
               const end = thread.captures[instruction.index * 2 + 1];
@@ -1382,8 +1462,9 @@ var Pattern = class {
         storage.release(stateBytes + 64);
         if (this.backreferences && !positions.size) {
           if (bestStart !== void 0 || this.anchored) break;
-          position = ++nextStart;
-        } else position++;
+          nextStart += (text.codePointAt(nextStart) ?? 0) > 65535 ? 2 : 1;
+          position = nextStart;
+        } else position += (text.codePointAt(position) ?? 0) > 65535 ? 2 : 1;
       }
       if (bestStart !== void 0 && bestEnd !== void 0) {
         let characters = bestEnd - bestStart;
@@ -1530,7 +1611,7 @@ function getSimpleReplacement(replacement, syntax) {
   SIMPLE_REPLACEMENT_CACHE.set(key, null);
   return null;
 }
-function appendReplacementFromOffsetsSync(out, replacement, text, matchStart, matchEnd, group1Start, group1End, budget, maxBufferBytes, syntax, simpleRep = getSimpleReplacement(replacement, syntax)) {
+function appendReplacementFromOffsetsSync(out, replacement, text, matchStart, matchEnd, group1Start, group1End, budget, maxBufferBytes, syntax, simpleRep = getSimpleReplacement(replacement, syntax), offsets = FAST_MATCH_OFFSETS) {
   if (simpleRep !== null) {
     if (simpleRep.kind === "literal") {
       budget.step(simpleRep.stepsPerExpansion);
@@ -1538,10 +1619,10 @@ function appendReplacementFromOffsetsSync(out, replacement, text, matchStart, ma
       return out ? out + simpleRep.prefix : simpleRep.prefix;
     }
     if (simpleRep.kind === "twoRefs") {
-      const g1Start = simpleRep.group === 0 ? matchStart : simpleRep.group === 1 ? group1Start : FAST_MATCH_OFFSETS[simpleRep.group * 2];
-      const g1End = simpleRep.group === 0 ? matchEnd : simpleRep.group === 1 ? group1End : FAST_MATCH_OFFSETS[simpleRep.group * 2 + 1];
-      const g2Start = simpleRep.group2 === 0 ? matchStart : simpleRep.group2 === 1 ? group1Start : FAST_MATCH_OFFSETS[simpleRep.group2 * 2];
-      const g2End = simpleRep.group2 === 0 ? matchEnd : simpleRep.group2 === 1 ? group1End : FAST_MATCH_OFFSETS[simpleRep.group2 * 2 + 1];
+      const g1Start = simpleRep.group === 0 ? matchStart : simpleRep.group === 1 ? group1Start : offsets[simpleRep.group * 2];
+      const g1End = simpleRep.group === 0 ? matchEnd : simpleRep.group === 1 ? group1End : offsets[simpleRep.group * 2 + 1];
+      const g2Start = simpleRep.group2 === 0 ? matchStart : simpleRep.group2 === 1 ? group1Start : offsets[simpleRep.group2 * 2];
+      const g2End = simpleRep.group2 === 0 ? matchEnd : simpleRep.group2 === 1 ? group1End : offsets[simpleRep.group2 * 2 + 1];
       const g1Len = g1Start >= 0 && g1End > g1Start ? g1End - g1Start : 0;
       const g2Len = g2Start >= 0 && g2End > g2Start ? g2End - g2Start : 0;
       const addedLen2 = simpleRep.prefix.length + g1Len + simpleRep.mid.length + g2Len + simpleRep.suffix.length;
@@ -1552,8 +1633,8 @@ function appendReplacementFromOffsetsSync(out, replacement, text, matchStart, ma
       const expanded2 = simpleRep.suffix ? simpleRep.prefix + g1Str + simpleRep.mid + g2Str + simpleRep.suffix : simpleRep.prefix + g1Str + simpleRep.mid + g2Str;
       return out ? out + expanded2 : expanded2;
     }
-    const gStart = simpleRep.group === 0 ? matchStart : simpleRep.group === 1 ? group1Start : FAST_MATCH_OFFSETS[simpleRep.group * 2];
-    const gEnd = simpleRep.group === 0 ? matchEnd : simpleRep.group === 1 ? group1End : FAST_MATCH_OFFSETS[simpleRep.group * 2 + 1];
+    const gStart = simpleRep.group === 0 ? matchStart : simpleRep.group === 1 ? group1Start : offsets[simpleRep.group * 2];
+    const gEnd = simpleRep.group === 0 ? matchEnd : simpleRep.group === 1 ? group1End : offsets[simpleRep.group * 2 + 1];
     const gLen = gStart >= 0 && gEnd > gStart ? gEnd - gStart : 0;
     const addedLen = simpleRep.prefix.length + gLen + simpleRep.suffix.length;
     budget.step(simpleRep.stepsPerExpansion + gLen);
@@ -1605,8 +1686,8 @@ function appendReplacementFromOffsetsSync(out, replacement, text, matchStart, ma
         if (g === 0) piece = matchEnd > matchStart ? text.slice(matchStart, matchEnd) : "";
         else if (g === 1 && group1Start >= 0) piece = group1End > group1Start ? text.slice(group1Start, group1End) : "";
         else if (g > 1) {
-          const gs = FAST_MATCH_OFFSETS[g * 2];
-          const ge = FAST_MATCH_OFFSETS[g * 2 + 1];
+          const gs = offsets[g * 2];
+          const ge = offsets[g * 2 + 1];
           if (gs >= 0 && ge > gs) piece = text.slice(gs, ge);
         }
       } else {
@@ -1769,34 +1850,9 @@ async function substitute(text, pattern, replacement, budget, global, occurrence
     result.clear();
   }
 }
-var PAIR_OFFSETS_1 = new Int32Array(4);
-var PAIR_OFFSETS_2 = new Int32Array(4);
+var PAIR_OFFSETS_1 = new Int32Array(20);
+var PAIR_OFFSETS_2 = new Int32Array(20);
 var SYNC_PAIR_RESULT = { text: "", substituted: false };
-function expandSimpleFromOffsets(simpleRep, text, matchStart, matchEnd, group1Start, group1End, budget) {
-  if (simpleRep.kind === "literal") {
-    budget.step(simpleRep.stepsPerExpansion);
-    return simpleRep.prefix;
-  }
-  const gStart = simpleRep.group === 0 ? matchStart : simpleRep.group === 1 ? group1Start : -1;
-  const gEnd = simpleRep.group === 0 ? matchEnd : simpleRep.group === 1 ? group1End : -1;
-  const gLen = gStart >= 0 && gEnd > gStart ? gEnd - gStart : 0;
-  budget.step(simpleRep.stepsPerExpansion + gLen);
-  if (gLen === 1) {
-    const c0 = text.charCodeAt(gStart) - 48;
-    if (c0 >= 0 && c0 <= 9) {
-      return simpleRep.smallInts[c0] ??= simpleRep.suffix ? simpleRep.prefix + String.fromCharCode(c0 + 48) + simpleRep.suffix : simpleRep.prefix + String.fromCharCode(c0 + 48);
-    }
-  } else if (gLen === 2) {
-    const c0 = text.charCodeAt(gStart) - 48;
-    const c1 = text.charCodeAt(gStart + 1) - 48;
-    if (c0 >= 1 && c0 <= 9 && c1 >= 0 && c1 <= 9) {
-      const num = c0 * 10 + c1;
-      return simpleRep.smallInts[num] ??= simpleRep.suffix ? simpleRep.prefix + String(num) + simpleRep.suffix : simpleRep.prefix + String(num);
-    }
-  }
-  const gStr = gLen > 0 ? text.slice(gStart, gEnd) : "";
-  return simpleRep.suffix ? simpleRep.prefix + gStr + simpleRep.suffix : simpleRep.prefix + gStr;
-}
 function trySubstitutePairSync(text, pat1, rep1, global1, occ1, pat2, rep2, global2, occ2, budget) {
   if (occ1 !== 1 || occ2 !== 1 || text.length > 4096) return void 0;
   if (!pat1.canFindSync() || !pat2.canFindSync()) return void 0;
@@ -1815,7 +1871,7 @@ function trySubstitutePairSync(text, pat1, rep1, global1, occ1, pat2, rep2, glob
     const e1 = PAIR_OFFSETS_1[1];
     if (e1 === 0) return void 0;
     matched1 = true;
-    exp1 = expandSimpleFromOffsets(sr1, text, 0, e1, PAIR_OFFSETS_1[2], PAIR_OFFSETS_1[3], budget);
+    exp1 = appendReplacementFromOffsetsSync("", rep1, text, 0, e1, PAIR_OFFSETS_1[2], PAIR_OFFSETS_1[3], budget, budget.maxBufferBytes, "sed", sr1, PAIR_OFFSETS_1);
     let commonSuffix = 0;
     const maxSuffix = Math.min(exp1.length, e1);
     while (commonSuffix < maxSuffix && exp1.charCodeAt(exp1.length - 1 - commonSuffix) === text.charCodeAt(e1 - 1 - commonSuffix)) {
@@ -1852,7 +1908,7 @@ function trySubstitutePairSync(text, pat1, rep1, global1, occ1, pat2, rep2, glob
     budget.step();
     if (pat2.findSyncFastInto(text, budget, e2, PAIR_OFFSETS_1)) return void 0;
   }
-  const exp2 = expandSimpleFromOffsets(sr2, text, s2, e2, g2s, g2e, budget);
+  const exp2 = appendReplacementFromOffsetsSync("", rep2, text, s2, e2, g2s, g2e, budget, budget.maxBufferBytes, "sed", sr2, PAIR_OFFSETS_2);
   const midLen = s2 - effectiveE1;
   const tailLen = text.length - e2;
   const totalLen = effectiveExp1Len + midLen + exp2.length + tailLen;
@@ -1882,7 +1938,7 @@ function trySubstitutePairToBufferSync(text, pat1, rep1, global1, occ1, pat2, re
   if (pat1.findSyncFastInto(text, budget, lineStart, PAIR_OFFSETS_1, lineEnd, lineStart)) {
     const e1 = PAIR_OFFSETS_1[1];
     if (e1 === lineStart) return -1;
-    exp1 = expandSimpleFromOffsets(sr1, text, lineStart, e1, PAIR_OFFSETS_1[2], PAIR_OFFSETS_1[3], budget);
+    exp1 = appendReplacementFromOffsetsSync("", rep1, text, lineStart, e1, PAIR_OFFSETS_1[2], PAIR_OFFSETS_1[3], budget, budget.maxBufferBytes, "sed", sr1, PAIR_OFFSETS_1);
     let commonSuffix = 0;
     const maxSuffix = Math.min(exp1.length, e1 - lineStart);
     while (commonSuffix < maxSuffix && exp1.charCodeAt(exp1.length - 1 - commonSuffix) === text.charCodeAt(e1 - 1 - commonSuffix)) {
@@ -1916,7 +1972,7 @@ function trySubstitutePairToBufferSync(text, pat1, rep1, global1, occ1, pat2, re
     budget.step();
     if (pat2.findSyncFastInto(text, budget, e2, PAIR_OFFSETS_1, lineEnd, lineStart)) return -1;
   }
-  const exp2 = expandSimpleFromOffsets(sr2, text, s2, e2, g2s, g2e, budget);
+  const exp2 = appendReplacementFromOffsetsSync("", rep2, text, s2, e2, g2s, g2e, budget, budget.maxBufferBytes, "sed", sr2, PAIR_OFFSETS_2);
   const midLen = s2 - effectiveE1;
   const tailLen = lineEnd - e2;
   const totalLen = effectiveExp1Len + midLen + exp2.length + tailLen;
@@ -1931,35 +1987,7 @@ function trySubstitutePairToBufferSync(text, pat1, rep1, global1, occ1, pat2, re
   outBuf[pos++] = sepCode;
   return pos;
 }
-var cachedPairOutBuf = new Uint8Array(65536);
-var cachedPairOutView = cachedPairOutBuf.subarray(0, 0);
-var lastPairBatchText = "";
-var lastPairBatchEnds;
-var lastPairEndsLen = -1;
-var lastPairPat1;
-var lastPairRep1 = "";
-var lastPairG1 = false;
-var lastPairPat2;
-var lastPairRep2 = "";
-var lastPairG2 = false;
-var lastPairSepCode = -1;
-var lastPairMaxLine = 0;
-var lastPairStepsCharged = 0;
-var lastPairOutPos = -1;
 function trySubstitutePairBatchToBufferSync(batchText, batchEnds, endsLen, pat1, rep1, global1, occ1, pat2, rep2, global2, occ2, budget, outBuf, sepCode, maxOutLen) {
-  if (lastPairOutPos >= 0 && batchText === lastPairBatchText && batchEnds === lastPairBatchEnds && endsLen === lastPairEndsLen && pat1 === lastPairPat1 && rep1 === lastPairRep1 && global1 === lastPairG1 && pat2 === lastPairPat2 && rep2 === lastPairRep2 && global2 === lastPairG2 && sepCode === lastPairSepCode && occ1 === 1 && occ2 === 1 && lastPairMaxLine <= budget.maxBufferBytes && lastPairOutPos <= maxOutLen && (budget.options.maxSteps ?? Infinity) >= budget.stepsUsed + lastPairStepsCharged) {
-    const pending = budget.checkpointSync ? budget.checkpointSync() : void 0;
-    if (pending) {
-      pending.catch(() => {
-      });
-      return -1;
-    }
-    budget.step(lastPairStepsCharged);
-    outBuf.set(cachedPairOutView, 0);
-    return lastPairOutPos;
-  }
-  const initialSteps = budget.stepsUsed;
-  let maxSeenLine = 0;
   if (occ1 !== 1 || occ2 !== 1) return -1;
   if (!pat1.canFindSync() || !pat2.canFindSync()) return -1;
   const info1 = pat1.getFastPrefixInfo();
@@ -2017,7 +2045,6 @@ function trySubstitutePairBatchToBufferSync(batchText, batchEnds, endsLen, pat1,
       if (s2 < 0) {
         const restLen = lEnd - effectiveE1;
         const outLen = exp1Len + restLen;
-        if (outLen > maxSeenLine) maxSeenLine = outLen;
         if (outLen > maxBuf) throw new ProgramError("text buffer limit exceeded");
         if (outPos2 + outLen + 1 >= maxOutLen) return -2;
         for (let i = 0; i < exp1Len; i++) outBuf[outPos2++] = r1Val.charCodeAt(i);
@@ -2036,7 +2063,6 @@ function trySubstitutePairBatchToBufferSync(batchText, batchEnds, endsLen, pat1,
         const midLen = s2 - effectiveE1;
         const tailLen = lEnd - e2;
         const totalLen = exp1Len + midLen + r2Len + tailLen;
-        if (totalLen > maxSeenLine) maxSeenLine = totalLen;
         if (totalLen > maxBuf) throw new ProgramError("text buffer limit exceeded");
         if (outPos2 + totalLen + 1 >= maxOutLen) return -2;
         for (let i = 0; i < exp1Len; i++) outBuf[outPos2++] = r1Val.charCodeAt(i);
@@ -2056,23 +2082,6 @@ function trySubstitutePairBatchToBufferSync(batchText, batchEnds, endsLen, pat1,
       }
       lStart2 = lEnd + 1;
     }
-    if (outPos2 <= 65536) {
-      lastPairBatchText = batchText;
-      lastPairBatchEnds = batchEnds;
-      lastPairEndsLen = endsLen;
-      lastPairPat1 = pat1;
-      lastPairRep1 = rep1;
-      lastPairG1 = global1;
-      lastPairPat2 = pat2;
-      lastPairRep2 = rep2;
-      lastPairG2 = global2;
-      lastPairSepCode = sepCode;
-      lastPairMaxLine = maxSeenLine;
-      lastPairStepsCharged = budget.stepsUsed - initialSteps;
-      lastPairOutPos = outPos2;
-      cachedPairOutBuf.set(outBuf.subarray(0, outPos2));
-      cachedPairOutView = cachedPairOutBuf.subarray(0, outPos2);
-    }
     return outPos2;
   }
   let outPos = 0;
@@ -2088,7 +2097,7 @@ function trySubstitutePairBatchToBufferSync(batchText, batchEnds, endsLen, pat1,
     if (pat1.findSyncFastInto(batchText, budget, lStart, PAIR_OFFSETS_1, lEnd, lStart)) {
       const e1 = PAIR_OFFSETS_1[1];
       if (e1 === lStart) return -1;
-      exp1 = expandSimpleFromOffsets(sr1, batchText, lStart, e1, PAIR_OFFSETS_1[2], PAIR_OFFSETS_1[3], budget);
+      exp1 = appendReplacementFromOffsetsSync("", rep1, batchText, lStart, e1, PAIR_OFFSETS_1[2], PAIR_OFFSETS_1[3], budget, budget.maxBufferBytes, "sed", sr1, PAIR_OFFSETS_1);
       let commonSuffix = 0;
       const maxSuffix = Math.min(exp1.length, e1 - lStart);
       while (commonSuffix < maxSuffix && exp1.charCodeAt(exp1.length - 1 - commonSuffix) === batchText.charCodeAt(e1 - 1 - commonSuffix)) {
@@ -2119,7 +2128,7 @@ function trySubstitutePairBatchToBufferSync(batchText, batchEnds, endsLen, pat1,
         budget.step();
         if (pat2.findSyncFastInto(batchText, budget, e2, PAIR_OFFSETS_1, lEnd, lStart)) return -1;
       }
-      const exp2 = expandSimpleFromOffsets(sr2, batchText, s2, e2, g2s, g2e, budget);
+      const exp2 = appendReplacementFromOffsetsSync("", rep2, batchText, s2, e2, g2s, g2e, budget, budget.maxBufferBytes, "sed", sr2, PAIR_OFFSETS_2);
       const midLen = s2 - effectiveE1;
       const tailLen = lEnd - e2;
       const totalLen = effectiveExp1Len + midLen + exp2.length + tailLen;
@@ -2144,6 +2153,88 @@ function trySubstitutePairBatchToBufferSync(batchText, batchEnds, endsLen, pat1,
   }
   return outPos;
 }
+var decodedByteSubjects = /* @__PURE__ */ new WeakMap();
+var BytePattern = class extends Pattern {
+  unicode;
+  constructor(...args) {
+    super(...args);
+    const [source, ...settings] = args;
+    this.unicode = new Pattern(decodeByteText(source).text, ...settings);
+  }
+  usesUnicode(budget) {
+    const owner = budget;
+    if (owner.regexByteMode) return false;
+    const env = owner.context?.env;
+    const locale = env?.LC_ALL || env?.LC_CTYPE || env?.LANG;
+    return locale !== "C" && locale !== "POSIX";
+  }
+  input(text, budget) {
+    const key = budget.context ?? budget;
+    const cached = decodedByteSubjects.get(key);
+    if (cached?.source === text) {
+      budget.step(0);
+      if (cached.value.offsets && (text.length + 1) * 6 > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+      return cached.value;
+    }
+    const value = decodeByteText(text, budget);
+    decodedByteSubjects.set(key, { source: text, value });
+    return value;
+  }
+  byteMatch(match, decoded, budget) {
+    if (!match || !decoded.offsets) return match;
+    budget.step(match.groups.reduce((count, group) => count + (group?.length ?? 0), 0));
+    return {
+      start: decoded.offsets[match.start],
+      end: decoded.offsets[match.end],
+      groups: match.groups.map((group) => group === void 0 ? void 0 : encodeByteText(group)),
+      ...match.captureOffsets ? { captureOffsets: match.captureOffsets.map((offset) => offset === void 0 || offset < 0 ? offset : decoded.offsets[offset]) } : {}
+    };
+  }
+  async prepare(budget) {
+    if (this.usesUnicode(budget)) await this.unicode.prepare(budget);
+    else await super.prepare(budget);
+  }
+  canFindSync() {
+    return super.canFindSync() && this.unicode.canFindSync();
+  }
+  getFastPrefixInfo() {
+    return void 0;
+  }
+  findSyncFastInto(text, budget, from, outOffsets, textEnd = text.length, textStart = 0) {
+    if (!this.usesUnicode(budget)) return super.findSyncFastInto(text, budget, from, outOffsets, textEnd, textStart);
+    const segment = textStart === 0 && textEnd === text.length ? text : text.slice(textStart, textEnd);
+    const decoded = this.input(segment, budget);
+    const found = this.unicode.findSyncFastInto(
+      decoded.text,
+      budget,
+      byteTextPosition(decoded, from - textStart),
+      outOffsets,
+      decoded.text.length,
+      0
+    );
+    if (found) {
+      for (let i = 0; i < (this.groupCount + 1) * 2; i++)
+        if (outOffsets[i] >= 0) outOffsets[i] = (decoded.offsets?.[outOffsets[i]] ?? outOffsets[i]) + textStart;
+    }
+    return found;
+  }
+  tryFindSync(text, budget, from = 0) {
+    if (!this.usesUnicode(budget)) return super.tryFindSync(text, budget, from);
+    const decoded = this.input(text, budget);
+    const result = this.unicode.tryFindSync(decoded.text, budget, byteTextPosition(decoded, from));
+    return result instanceof Promise ? result.then((match) => this.byteMatch(match, decoded, budget)) : this.byteMatch(result, decoded, budget);
+  }
+  async find(text, budget, from = 0, continuation = from) {
+    if (!this.usesUnicode(budget)) return super.find(text, budget, from, continuation);
+    const decoded = this.input(text, budget);
+    return this.byteMatch(await this.unicode.find(
+      decoded.text,
+      budget,
+      byteTextPosition(decoded, from),
+      byteTextPosition(decoded, continuation)
+    ), decoded, budget);
+  }
+};
 
 export {
   Pattern,
@@ -2151,5 +2242,6 @@ export {
   substitute,
   trySubstitutePairSync,
   trySubstitutePairToBufferSync,
-  trySubstitutePairBatchToBufferSync
+  trySubstitutePairBatchToBufferSync,
+  BytePattern
 };

package/dist/safe-bash/command-chunks/{chunk-JN7WIP6S.js → chunk-6KJ3LPI2.js}

@@ -1,9 +1,9 @@
 import {
   curlRequestTarget
-} from "./chunk-RVLO4DYT.js";
+} from "./chunk-N4PFUSRM.js";
 import {
   CurlError
-} from "./chunk-IYPAQ7PH.js";
+} from "./chunk-GRBWW4SG.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";