@poe-platform/safe-bash 0.1.798 → 0.1.800

package/dist/safe-bash/command-chunks/{chunk-CU5RLO62.js → chunk-GLOZX57Y.js}

@@ -308,6 +308,13 @@ async function patterns(context, args, limits) {
   }
   return patterns2;
 }
+function relativeMatch(match, offset) {
+  return {
+    start: match.start - offset,
+    end: match.end - offset,
+    ...match.captures ? { captures: new Map([...match.captures].map(([key, span]) => [key, { start: span.start - offset, end: span.end - offset }])) } : {}
+  };
+}
 async function searchFile(context, args, limits, matcher, printer, target, stdin, filename) {
   const totals = stats();
   totals.searches = 1;
@@ -320,7 +327,7 @@ async function searchFile(context, args, limits, matcher, printer, target, stdin
     const rawBytes = source instanceof Uint8Array ? source : await collectBytes(source, { maxBytes: limits.maxFileBytes, signal: context.signal });
     source = rawBytes;
     crossLineMatches = matcher.matchBuffer(rawBytes, true);
-    if (args.onlyMatching && !args.invert && args.mode === "lines") {
+    if (args.onlyMatching && args.replacement === void 0 && !args.invert && args.mode === "lines") {
       state.bytesRead = rawBytes.length;
       state.bytesSearched = rawBytes.length;
       const selectedOutput2 = !args.quiet;
@@ -343,18 +350,17 @@ async function searchFile(context, args, limits, matcher, printer, target, stdin
         totals.matches++;
         if (args.quiet && !args.stats) break;
         if (selectedOutput2) {
-          const rawBuf = bytesFrom(rawBytes);
           const syntheticLine = {
             number: lineNum,
             offset: lineStart,
-            rawBytes: rawBuf.subarray(m.start, m.end),
+            rawBytes: rawBytes.subarray(m.start, m.end),
             rawLength: m.end - m.start,
-            content: rawBuf,
-            bytes: rawBuf,
+            content: rawBytes.subarray(lineStart),
+            bytes: rawBytes.subarray(lineStart),
             all: true,
             terminated: true
           };
-          await printer.record(target.label, syntheticLine, [{ start: m.start, end: m.end }], true, filename);
+          await printer.record(target.label, syntheticLine, [relativeMatch(m, lineStart)], true, filename, true, endLine - lineNum + 1);
         }
       }
       if (limits.outPos > 0) await limits.flush();
@@ -372,6 +378,7 @@ async function searchFile(context, args, limits, matcher, printer, target, stdin
   let begun = false;
   let binaryPrinted = false;
   let lastSelectedEnd = 0;
+  let selectedCount = 0;
   let fileOutputStart = limits.outputBytes;
   const begin = async () => {
     if (begun) return;
@@ -383,7 +390,63 @@ async function searchFile(context, args, limits, matcher, printer, target, stdin
   const binaryOutput = selectedOutput && args.mode === "lines" && binary === "binary";
   const needAll = args.replacement !== void 0 || args.onlyMatching || args.mode === "json" || args.mode === "matches" || args.stats === true;
   const batchSize = () => Number.isFinite(args.maxCount) || args.quiet && args.mode !== "json" || args.mode === "with" || args.mode === "without" || binaryOutput && state.binaryOffset !== null ? 1 : 128;
-  const syncBatches = source instanceof Uint8Array ? trySyncLineBatches(source, limits, state, binary, args.nullData, batchSize, needAll, args.crlf) : void 0;
+  let syncBatches = source instanceof Uint8Array ? trySyncLineBatches(source, limits, state, binary, args.nullData, batchSize, needAll, args.crlf) : void 0;
+  let replacementGroups;
+  if (crossLineMatches && args.replacement !== void 0 && args.mode === "lines" && !args.invert && source instanceof Uint8Array) {
+    const records = syncBatches?.flat() ?? [];
+    if (syncBatches === void 0) {
+      for await (const batch of lineBatches(source, limits, state, binary, args.nullData, batchSize, needAll, args.crlf)) records.push(...batch);
+    }
+    replacementGroups = /* @__PURE__ */ new Map();
+    const grouped = [];
+    let matchIndex = 0;
+    let blocks = 0;
+    for (let index = 0; index < records.length; index++) {
+      const first = records[index];
+      let last = first;
+      let end = last.offset + last.rawLength;
+      const matches = [];
+      while (matchIndex < crossLineMatches.length) {
+        const match = crossLineMatches[matchIndex];
+        if (match.start >= end && !(match.start === end && !last.terminated)) break;
+        while (match.end > end && index + 1 < records.length) {
+          last = records[++index];
+          end = last.offset + last.rawLength;
+        }
+        matches.push(relativeMatch(match, first.offset));
+        matchIndex++;
+      }
+      if (matches.length === 0) {
+        grouped.push(first);
+        continue;
+      }
+      const previous = grouped.at(-1);
+      const previousGroup = previous && replacementGroups.get(previous);
+      const mergePrevious = previousGroup && previous.offset + previous.rawLength === first.offset && blocks < args.maxCount;
+      const start = mergePrevious ? previous : first;
+      const combinedMatches = mergePrevious ? previousGroup.matches : matches;
+      if (mergePrevious) for (const match of matches) combinedMatches.push(relativeMatch(match, previous.offset - first.offset));
+      const bytes = source.subarray(start.offset, end);
+      const line = {
+        number: start.number,
+        offset: start.offset,
+        rawBytes: bytes,
+        rawLength: bytes.length,
+        content: bytes,
+        bytes,
+        all: true,
+        terminated: last.terminated
+      };
+      if (mergePrevious) {
+        grouped.pop();
+        replacementGroups.delete(previous);
+      }
+      replacementGroups.set(line, { matches: combinedMatches, lines: last.number - start.number + 1, blocks: (mergePrevious ? previousGroup.blocks : 0) + 1 });
+      grouped.push(line);
+      blocks++;
+    }
+    syncBatches = [grouped];
+  }
   let syncIdx = 0;
   let asyncIter;
   let failure;
@@ -403,6 +466,8 @@ async function searchFile(context, args, limits, matcher, printer, target, stdin
         batch = next.value;
       }
       const batchRes = crossLineMatches !== void 0 ? batch.map((line) => {
+        const group = replacementGroups?.get(line);
+        if (group) return group.matches;
         const lineStart = line.offset;
         const lineEnd = line.offset + line.content.length;
         const lineMatches = [];
@@ -428,12 +493,15 @@ async function searchFile(context, args, limits, matcher, printer, target, stdin
           break records;
         }
         const matches = results[index];
-        const matchCount = crossLineMatches === void 0 ? matches.length : crossLineMatches.reduce((count, match) => count + Number(match.start >= line.offset && match.start <= line.offset + line.content.length), 0);
-        const limitedInvertedTail = args.invert && totals.matched_lines >= args.maxCount && after > 0 && line.rawLength === line.content.length;
+        const replacementGroup = replacementGroups?.get(line);
+        const lineCount = replacementGroup?.lines ?? 1;
+        const matchCount = crossLineMatches === void 0 || replacementGroup ? matches.length : crossLineMatches.reduce((count, match) => count + Number(match.start >= line.offset && match.start <= line.offset + line.content.length), 0);
+        const limitedInvertedTail = args.invert && selectedCount >= args.maxCount && after > 0 && line.rawLength === line.content.length;
         const selected = matches.length > 0 !== args.invert || limitedInvertedTail;
         if (selected) lastSelectedEnd = line.offset + line.rawLength;
-        if (selected && totals.matched_lines < args.maxCount) {
-          totals.matched_lines++;
+        if (selected && selectedCount < args.maxCount) {
+          selectedCount += replacementGroup?.blocks ?? 1;
+          totals.matched_lines += lineCount;
           totals.matches += args.invert ? 0 : matchCount;
           if (!args.stats && (args.quiet && args.mode !== "json" || args.mode === "with" || args.mode === "without")) break records;
           if (selectedOutput) {
@@ -451,21 +519,22 @@ async function searchFile(context, args, limits, matcher, printer, target, stdin
                 lastPrinted = previous.line.number;
               }
             }
-            await printer.record(target.label, line, args.invert ? [] : matches, true, filename);
-            lastPrinted = line.number;
+            await printer.record(target.label, line, args.invert ? [] : matches, true, filename, replacementGroup !== void 0, lineCount);
+            lastPrinted = line.number + lineCount - 1;
             after = args.after;
           }
         } else if (after && selectedOutput) {
           if (selected) {
-            totals.matched_lines++;
+            selectedCount += replacementGroup?.blocks ?? 1;
+            totals.matched_lines += lineCount;
             totals.matches += args.invert && !limitedInvertedTail ? 0 : matchCount;
           }
-          await printer.record(target.label, line, matches, selected, filename);
-          lastPrinted = line.number;
+          await printer.record(target.label, line, matches, selected, filename, replacementGroup !== void 0, lineCount);
+          lastPrinted = line.number + lineCount - 1;
           after--;
         }
         if (binaryOutput && args.before > 0 && state.binaryOffset !== null) break records;
-        if (totals.matched_lines >= args.maxCount && (!selectedOutput || after === 0)) {
+        if (selectedCount >= args.maxCount && (!selectedOutput || after === 0)) {
           state.bytesSearched = Math.max(lastSelectedEnd, args.invert || line.rawLength === line.content.length ? line.offset : 0);
           break records;
         }
@@ -655,6 +724,11 @@ function tryExecuteRgFastSync(context, executor, options) {
     runner.abortedToSlow = false;
     const walkRes = runner.walker.walkTargetsSyncOrAsync(selPaths, selImplicit, runner.boundOnTarget, true);
     if (runner.abortedToSlow || walkRes !== void 0) {
+      const pending = walkRes ?? limits.tick();
+      if (pending) {
+        pendingFlush = true;
+        return pending.finally(runner.release).then(() => executeRgSlow(context, executor, options));
+      }
       return void 0;
     }
     if (cArgs.length === 3 && cArgs[0] === "-c" && totals.searches === 64 && limits.outPos >= 0 && Date.now === defaultDateNowRg && cArgs[2].charCodeAt(0) === 47 && tryVerifyAndPopulate64Tree(fastMem, cArgs[2], false)) {
@@ -841,7 +915,7 @@ Default input depends on shell configuration.
 
   -e, --regexp=PATTERN     Add a pattern (repeatable)
   -f, --file=FILE          Read patterns from FILE
-  -r, --replace=TEXT       Replace matches with literal TEXT
+  -r, --replace=TEXT       Replace matches with text and capture references
       --trim              Trim leading ASCII whitespace
   -F, --fixed-strings      Use fixed strings
       --max-filesize=SIZE  Filter discovered files (bytes or K/M/G)

package/dist/safe-bash/command-chunks/chunk-GMIHJYDG.js

@@ -0,0 +1,331 @@
+import {
+  JqError,
+  JqLimitError
+} from "./chunk-QP4R6GLA.js";
+import {
+  isNumber,
+  numberValue
+} from "./chunk-UCL3PNXL.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-query-engine/src/dates.ts
+init_buffer();
+function fromDateIso8601(input) {
+  if (typeof input !== "string") throw new JqError("strptime/1 requires string inputs and arguments");
+  const mismatch = () => new JqError(`date ${JSON.stringify(input)} does not match format "%Y-%m-%dT%H:%M:%SZ"`);
+  const parts = input.split("T");
+  if (parts.length !== 2 || !parts[1].endsWith("Z")) throw mismatch();
+  const date = parts[0].split("-");
+  const time = parts[1].slice(0, -1).split(":");
+  const fields = [...date, ...time];
+  if (date.length !== 3 || time.length !== 3 || fields.some((field, index) => field.length === 0 || field.length > (index === 0 ? 4 : 2) || [...field].some((character) => !"0123456789".includes(character)))) throw mismatch();
+  const [year, month, day, hour, minute, second] = fields.map(Number);
+  if (month < 1 || month > 12 || day > 31 || hour > 23 || minute > 59 || second > 60) throw mismatch();
+  if (year < 1900) throw new JqError("invalid gmtime representation");
+  return Date.UTC(year, month - 1, day, hour, minute, second) / 1e3;
+}
+function toDateIso8601(input) {
+  if (!isNumber(input)) throw new JqError("strftime/1 requires parsed datetime inputs");
+  const date = new Date(Math.trunc(numberValue(input)) * 1e3);
+  if (!Number.isFinite(date.getTime())) throw new JqError("error converting number of seconds since epoch to datetime");
+  const year = String(date.getUTCFullYear()).padStart(4, "0");
+  const fields = [date.getUTCMonth() + 1, date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds()].map((value) => String(value).padStart(2, "0"));
+  return `${year}-${fields[0]}-${fields[1]}T${fields[2]}:${fields[3]}:${fields[4]}Z`;
+}
+var weekdays = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+var months = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+var compoundFormats = { F: "%Y-%m-%d", D: "%m/%d/%y", R: "%H:%M", T: "%H:%M:%S", r: "%I:%M:%S %p", c: "%a %b %e %T %Y", x: "%m/%d/%y", X: "%T", "+": "%a %b %e %T %Z %Y" };
+function utcDate(fields) {
+  const date = /* @__PURE__ */ new Date(0);
+  date.setUTCFullYear(fields[0], fields[1], fields[2]);
+  date.setUTCHours(fields[3], fields[4], Math.trunc(fields[5]), 0);
+  return date;
+}
+function datetime(input, name) {
+  if (!Array.isArray(input) || input.length < 8 || input.slice(0, 8).some((value) => !isNumber(value))) throw new JqError(`${name} requires parsed datetime inputs`);
+  return input.slice(0, 8).map((value) => {
+    if (!isNumber(value)) throw new JqError(`${name} requires parsed datetime inputs`);
+    return Math.trunc(numberValue(value));
+  });
+}
+function gmtime(input) {
+  if (!isNumber(input)) throw new JqError("gmtime() requires numeric inputs");
+  const seconds = numberValue(input);
+  const date = new Date(Math.trunc(seconds) * 1e3);
+  if (!Number.isFinite(date.getTime())) throw new JqError("error converting number of seconds since epoch to datetime");
+  const fields = [date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds() + seconds - Math.floor(seconds), date.getUTCDay()];
+  const start = utcDate([fields[0], 0, 1, 0, 0, 0]);
+  fields.push(Math.floor((date.getTime() - start.getTime()) / 864e5));
+  return fields;
+}
+function mktime(input) {
+  const fields = datetime(input, "mktime");
+  const seconds = utcDate(fields).getTime() / 1e3;
+  if (!Number.isFinite(seconds) || fields[0] < 1900 || seconds === -1) throw new JqError("invalid gmtime representation");
+  if (seconds === -2) throw new JqError("mktime not supported on this platform");
+  return seconds;
+}
+function strftime(input, format, budget) {
+  if (typeof format !== "string") throw new JqError("strftime/1 requires a string format");
+  const fields = isNumber(input) ? gmtime(input) : datetime(input, "strftime/1");
+  const [year, month, day, hour, minute, second, weekday, yearday] = fields;
+  const pad = (value, width = 2, fill = "0") => String(Math.trunc(value)).padStart(width, fill);
+  const date = utcDate(fields);
+  const thursday = new Date(date);
+  thursday.setUTCDate(date.getUTCDate() + 3 - (date.getUTCDay() + 6) % 7);
+  const isoYear = thursday.getUTCFullYear();
+  const isoWeek = 1 + Math.floor((thursday.getTime() - utcDate([isoYear, 0, 1, 0, 0, 0]).getTime()) / 6048e5);
+  const directives = {
+    Y: pad(year, 4),
+    y: pad(year % 100),
+    C: pad(Math.floor(year / 100)),
+    m: pad(month + 1),
+    d: pad(day),
+    e: pad(day, 2, " "),
+    H: pad(hour),
+    k: pad(hour, 2, " "),
+    I: pad(hour % 12 || 12),
+    l: pad(hour % 12 || 12, 2, " "),
+    M: pad(minute),
+    S: pad(second),
+    p: hour < 12 ? "AM" : "PM",
+    P: hour < 12 ? "am" : "pm",
+    a: weekdays[weekday]?.slice(0, 3) ?? "?",
+    A: weekdays[weekday] ?? "?",
+    b: months[month]?.slice(0, 3) ?? "?",
+    h: months[month]?.slice(0, 3) ?? "?",
+    B: months[month] ?? "?",
+    j: pad(yearday + 1, 3),
+    w: String(weekday),
+    u: String(weekday || 7),
+    U: pad(Math.floor((yearday + 7 - weekday) / 7)),
+    W: pad(Math.floor((yearday + 7 - (weekday + 6) % 7) / 7)),
+    G: pad(isoYear, 4),
+    g: pad(isoYear % 100),
+    V: pad(isoWeek),
+    s: String(date.getTime() / 1e3),
+    z: "+0000",
+    Z: "UTC",
+    "%": "%",
+    n: "\n",
+    t: "	"
+  };
+  const fragments = [];
+  let bytes = 2;
+  const emit = (text) => {
+    bytes += budget.value(text) - 2;
+    if (bytes > budget.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
+    fragments.push(text);
+  };
+  const append = (source) => {
+    for (let index = 0; index < source.length; index++) {
+      budget.step();
+      if (source[index] !== "%") {
+        const character = String.fromCodePoint(source.codePointAt(index));
+        emit(character);
+        index += character.length - 1;
+      } else {
+        let directive = source[++index] ?? "%";
+        if (directive === "E" || directive === "O") directive = source[++index] ?? "%";
+        if (Object.hasOwn(compoundFormats, directive)) append(compoundFormats[directive]);
+        else emit(directives[directive] ?? directive);
+      }
+    }
+  };
+  append(format);
+  return fragments.join("");
+}
+function strptime(input, format, budget) {
+  if (typeof input !== "string" || typeof format !== "string") throw new JqError("strptime/1 requires string inputs and arguments");
+  const mismatch = () => new JqError(`date ${JSON.stringify(input)} does not match format ${JSON.stringify(format)}`);
+  const fields = [1900, 0, 0, 0, 0, 0, 0, -1];
+  let position = 0;
+  let afternoon;
+  let ordinal;
+  let century;
+  let shortYear;
+  let week;
+  let hasDate = false;
+  let zoneMinutes;
+  const whitespace = (character) => " 	\r\n\v\f".includes(character);
+  const skipSpace = () => {
+    while (position < input.length && whitespace(input[position])) {
+      budget.step();
+      position++;
+    }
+  };
+  const numeric = (width, min, max) => {
+    skipSpace();
+    const start = position;
+    while (position - start < width && position < input.length && "0123456789".includes(input[position])) position++;
+    const value = Number(input.slice(start, position));
+    if (position === start || value < min || value > max) throw mismatch();
+    return value;
+  };
+  const named = (names) => {
+    for (let index = 0; index < names.length; index++) {
+      const name = names[index].toLowerCase();
+      for (const text of [name, name.slice(0, 3)]) if (input.slice(position, position + text.length).toLowerCase() === text) {
+        position += text.length;
+        return index;
+      }
+    }
+    throw mismatch();
+  };
+  const consume = (source) => {
+    for (let index = 0; index < source.length; index++) {
+      budget.step();
+      const character = source[index];
+      if (whitespace(character)) {
+        skipSpace();
+        continue;
+      }
+      if (character !== "%") {
+        if (input[position++] !== character) throw mismatch();
+        continue;
+      }
+      let directive = source[++index];
+      if (directive === "E" || directive === "O") directive = source[++index];
+      if (directive && Object.hasOwn(compoundFormats, directive)) {
+        consume(compoundFormats[directive]);
+        continue;
+      }
+      switch (directive) {
+        case "%":
+          if (input[position++] !== "%") throw mismatch();
+          break;
+        case "Y":
+          fields[0] = numeric(4, 0, 9999);
+          break;
+        case "y":
+          shortYear = numeric(2, 0, 99);
+          fields[0] = (shortYear <= 68 ? 2e3 : 1900) + shortYear;
+          break;
+        case "C":
+          century = numeric(2, 0, 99);
+          break;
+        case "m":
+          hasDate = true;
+          fields[1] = numeric(2, 1, 12) - 1;
+          break;
+        case "d":
+        case "e":
+          hasDate = true;
+          fields[2] = numeric(2, 1, 31);
+          break;
+        case "H":
+        case "k":
+          fields[3] = numeric(2, 0, 23);
+          break;
+        case "I":
+        case "l":
+          fields[3] = numeric(2, 1, 12) % 12;
+          break;
+        case "M":
+          fields[4] = numeric(2, 0, 59);
+          break;
+        case "S":
+          fields[5] = numeric(2, 0, 60);
+          break;
+        case "s": {
+          const seconds = numeric(16, 0, Number.MAX_SAFE_INTEGER);
+          fields.splice(0, 8, ...gmtime(seconds));
+          hasDate = true;
+          break;
+        }
+        case "U":
+        case "W":
+          week = { number: numeric(2, 0, 53), monday: directive === "W" };
+          break;
+        case "j":
+          ordinal = numeric(3, 1, 366) - 1;
+          break;
+        case "a":
+        case "A":
+          fields[6] = named(weekdays);
+          break;
+        case "b":
+        case "B":
+        case "h":
+          hasDate = true;
+          fields[1] = named(months);
+          break;
+        case "w":
+          fields[6] = numeric(1, 0, 6);
+          break;
+        case "u":
+          fields[6] = numeric(1, 1, 7) % 7;
+          break;
+        case "p": {
+          const text = input.slice(position, position + 2).toLowerCase();
+          if (text !== "am" && text !== "pm") throw mismatch();
+          afternoon = text === "pm";
+          position += 2;
+          break;
+        }
+        case "n":
+        case "t":
+          skipSpace();
+          break;
+        case "z": {
+          if (input[position] === "Z") {
+            position++;
+            zoneMinutes = 0;
+            break;
+          }
+          if (input[position] !== "+" && input[position] !== "-") throw mismatch();
+          const sign = input[position++] === "-" ? -1 : 1;
+          const hours = numeric(2, 0, 23);
+          if (input[position] === ":") position++;
+          zoneMinutes = sign * (hours * 60 + numeric(2, 0, 59));
+          break;
+        }
+        case "Z": {
+          while (position < input.length && "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".includes(input[position])) {
+            budget.step();
+            position++;
+          }
+          break;
+        }
+        default:
+          throw mismatch();
+      }
+    }
+  };
+  consume(format);
+  if (century !== void 0) fields[0] = century * 100 + (shortYear ?? 0);
+  if (afternoon) fields[3] += 12;
+  if (week) {
+    const janFirst = utcDate([fields[0], 0, 1, 0, 0, 0]).getUTCDay();
+    const shift = week.monday ? 6 : 0;
+    ordinal = week.number * 7 + (fields[6] + shift) % 7 - (janFirst + shift) % 7;
+    if ((janFirst + shift) % 7 === 0) ordinal -= 7;
+  }
+  if (ordinal !== void 0) {
+    hasDate = true;
+    const date2 = utcDate([fields[0], 0, ordinal + 1, 0, 0, 0]);
+    fields[1] = date2.getUTCMonth();
+    fields[2] = date2.getUTCDate();
+  }
+  const date = utcDate(fields);
+  if (hasDate) fields[6] = date.getUTCDay();
+  fields[7] = Math.floor((utcDate([fields[0], fields[1], fields[2], 0, 0, 0]).getTime() - utcDate([fields[0], 0, 1, 0, 0, 0]).getTime()) / 864e5);
+  if (zoneMinutes !== void 0) fields.splice(0, 8, ...gmtime(date.getTime() / 1e3 - zoneMinutes * 60));
+  const result = fields;
+  if (position < input.length) {
+    if (!whitespace(input[position])) throw mismatch();
+    result.push(input.slice(position));
+  }
+  return result;
+}
+
+export {
+  fromDateIso8601,
+  toDateIso8601,
+  gmtime,
+  mktime,
+  strftime,
+  strptime
+};

package/dist/safe-bash/command-chunks/chunk-H622NS6Z.js

@@ -0,0 +1,11 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-zip-engine/src/zip/crc.ts
+init_buffer();
+import { crcTable } from "../../safe-bash-compression-engine/crc.js";
+
+export {
+  crcTable
+};

package/dist/safe-bash/command-chunks/{chunk-QGVOS3EY.js → chunk-HFII3QYO.js}

@@ -1,6 +1,6 @@
 import {
   entities
-} from "./chunk-E6IYUYVA.js";
+} from "./chunk-7L24L4UO.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-5EWTQJSC.js → chunk-HHP343KT.js}

@@ -1,6 +1,6 @@
 import {
   Builder
-} from "./chunk-25BLI6S6.js";
+} from "./chunk-4Y3WVMK4.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-WBJKOTSP.js → chunk-HMOZ6XVJ.js}

@@ -1,7 +1,7 @@
 import {
   JqError,
   JqLimitError
-} from "./chunk-AC6X7Q4I.js";
+} from "./chunk-QP4R6GLA.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-AVSPNLWV.js → chunk-I237SNW5.js}

@@ -1,6 +1,6 @@
 import {
   SearchError
-} from "./chunk-J4PEQWSF.js";
+} from "./chunk-VGG2DL5Q.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-4MS5WZJC.js → chunk-IKS2YXZQ.js}

@@ -1,13 +1,13 @@
 import {
   help,
   parse
-} from "./chunk-JXU2N6GN.js";
+} from "./chunk-Q7Q5GM5S.js";
 import {
   settings
 } from "./chunk-EHVMZ2NP.js";
 import {
   matches
-} from "./chunk-HZCPWYWA.js";
+} from "./chunk-BZPAWTUL.js";
 import {
   TreeLimitError,
   UsageError,
@@ -15,7 +15,7 @@ import {
   escaped,
   escapedName,
   message
-} from "./chunk-HVI6ALJF.js";
+} from "./chunk-PFAADCB5.js";
 import {
   compareVersions
 } from "./chunk-N6TXEPXL.js";

package/dist/safe-bash/command-chunks/{chunk-CZVBYCB5.js → chunk-IL53SJL4.js}

@@ -6,7 +6,7 @@ import {
 init_buffer();
 import { getCommandArguments } from "../../safe-bash-contracts/index.js";
 import { shellValueByteLength, shellValueBytes } from "../../safe-bash-contracts/value.js";
-import { hasYieldCheckpoint, monotonicNow, runYieldCheckpoint, yieldTurn } from "../../safe-bash-contracts/yield.js";
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
 import { PublicDiagnostic } from "../../safe-bash-contracts/diagnostics.js";
 function settings(options) {
   const limits = {
@@ -114,8 +114,6 @@ var Budget = class {
   signal;
   work = 0;
   checkpoint = 0;
-  checkpointCount = 0;
-  lastYield = monotonicNow();
   retained = 0;
   input = 0;
   output = 0;
@@ -137,15 +135,7 @@ var Budget = class {
     this.assertSignalOpen();
     if (this.work - this.checkpoint < 4096) return;
     this.checkpoint = this.work;
-    const count = ++this.checkpointCount;
-    const now = monotonicNow();
-    if (count === 1 || count % 16 === 0 || now - this.lastYield >= 16 || hasYieldCheckpoint(this.signal)) {
-      this.lastYield = now;
-      return yieldTurn(this.signal).then(() => {
-        this.lastYield = monotonicNow();
-      });
-    }
-    return runYieldCheckpoint(this.signal);
+    return yieldTurn(this.signal);
   }
   retain(amount) {
     this.check(this.retained + amount, this.limits.maxBufferedBytes, "buffered bytes");