@poe-platform/safe-bash 0.1.800 → 0.1.802

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

@@ -0,0 +1,354 @@
+import {
+  HexdumpError,
+  raw
+} from "./chunk-DIEPXUM4.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-hexdump/src/options.ts
+init_buffer();
+
+// packages/safe-bash-command-hexdump/src/custom.ts
+init_buffer();
+
+// packages/safe-bash-command-hexdump/src/float.ts
+init_buffer();
+function formatFloat(number2, code, flags, precision, budget) {
+  const sign = number2 < 0 || Object.is(number2, -0) ? "-" : flags.includes("+") ? "+" : flags.includes(" ") ? " " : "";
+  if (!Number.isFinite(number2)) {
+    const special = Number.isNaN(number2) ? "nan" : "inf";
+    return sign + (code === code.toUpperCase() ? special.toUpperCase() : special);
+  }
+  const view = new DataView(new ArrayBuffer(8));
+  view.setFloat64(0, Math.abs(number2));
+  const bits = view.getBigUint64(0), exponentBits = Number(bits >> 52n & 2047n);
+  let coefficient = bits & (1n << 52n) - 1n;
+  if (exponentBits) coefficient |= 1n << 52n;
+  const binaryExponent = exponentBits ? exponentBits - 1023 - 52 : -1074;
+  const scale = binaryExponent < 0 ? -binaryExponent : 0;
+  budget.buffered((scale + 64) * 4);
+  budget.charge(scale + 64);
+  const decimal = (binaryExponent < 0 ? coefficient * 5n ** BigInt(scale) : coefficient << BigInt(binaryExponent)).toString();
+  const capacity = (length) => {
+    budget.outputCapacity(length + sign.length);
+    budget.buffered((length + decimal.length + sign.length) * 6);
+    budget.charge(length);
+  };
+  const round = (keep) => {
+    if (keep < 0) return "0";
+    if (keep >= decimal.length) {
+      capacity(keep);
+      return decimal.padEnd(keep, "0");
+    }
+    const head = decimal.slice(0, keep) || "0";
+    const next = decimal[keep];
+    let tailNonzero = false;
+    for (let index = keep + 1; index < decimal.length; index++) if (decimal[index] !== "0") {
+      tailNonzero = true;
+      break;
+    }
+    const up = next > "5" || next === "5" && (tailNonzero || Number(head.at(-1)) % 2 === 1);
+    return up ? (BigInt(head) + 1n).toString() : head;
+  };
+  const digits = precision ?? 6, alternate = flags.includes("#");
+  let result;
+  if (code === "f") {
+    capacity(Math.max(1, decimal.length - scale) + digits + (digits || alternate ? 1 : 0));
+    const rounded = round(decimal.length - scale + digits).padStart(digits + 1, "0");
+    result = digits ? rounded.slice(0, -digits) + "." + rounded.slice(-digits) : rounded + (alternate ? "." : "");
+  } else {
+    const general = code === "g" || code === "G";
+    const significant = general ? Math.max(1, digits) : digits + 1;
+    let exponent = coefficient === 0n ? 0 : decimal.length - scale - 1;
+    const keep = general && !alternate ? Math.min(significant, decimal.length) : significant;
+    let rounded = coefficient === 0n ? "0" : round(keep);
+    if (rounded.length > keep) {
+      exponent++;
+      rounded = rounded.slice(0, -1);
+    }
+    if (general && !alternate) {
+      while (rounded.length > 1 && rounded.endsWith("0")) rounded = rounded.slice(0, -1);
+    } else {
+      capacity(significant + 8);
+      rounded = rounded.padEnd(significant, "0");
+    }
+    if (!general || exponent < -4 || exponent >= significant) {
+      result = rounded[0] + (rounded.length > 1 || alternate ? "." + rounded.slice(1) : "") + (code === "E" || code === "G" ? "E" : "e") + (exponent < 0 ? "-" : "+") + Math.abs(exponent).toString().padStart(2, "0");
+    } else {
+      const point = exponent + 1;
+      capacity(Math.max(rounded.length, point) + Math.max(0, 1 - point));
+      result = point <= 0 ? "0." + "0".repeat(-point) + rounded : point < rounded.length ? rounded.slice(0, point) + "." + rounded.slice(point) : rounded.padEnd(point, "0") + (alternate ? "." : "");
+    }
+  }
+  return sign + result;
+}
+
+// packages/safe-bash-command-hexdump/src/custom.ts
+function parseCustom(text, budget) {
+  let at = 0;
+  const fail = () => {
+    throw new HexdumpError(`bad format: ${text}`);
+  };
+  const space = () => {
+    while (at < text.length && " 	\n\r".includes(text[at])) at++;
+  };
+  const integer = () => {
+    const start = at;
+    while (at < text.length && "0123456789".includes(text[at])) at++;
+    if (start === at) return void 0;
+    const value = Number(text.slice(start, at));
+    if (!Number.isSafeInteger(value)) fail();
+    return value;
+  };
+  const units = [];
+  while (at < text.length) {
+    space();
+    if (at === text.length) break;
+    const repeat = integer();
+    space();
+    let size2;
+    if (text[at] === "/") {
+      at++;
+      space();
+      size2 = integer() || void 0;
+      space();
+    }
+    if (text[at++] !== '"') fail();
+    const parts = [];
+    let literal = "";
+    while (at < text.length && text[at] !== '"') {
+      budget.charge();
+      let ch = text[at++];
+      if (ch === "\\") {
+        ch = text[at++] ?? fail();
+        literal += { a: "\x07", b: "\b", f: "\f", n: "\n", r: "\r", t: "	", v: "\v" }[ch] ?? ch;
+      } else if (ch !== "%") literal += ch;
+      else if (text[at] === "%") {
+        at++;
+        literal += "%";
+      } else {
+        if (literal) {
+          parts.push(literal);
+          literal = "";
+        }
+        let flags = "";
+        while (at < text.length && "#0- +".includes(text[at])) flags += text[at++];
+        const width = integer() ?? 0;
+        let precision;
+        if (text[at] === ".") {
+          at++;
+          precision = integer() ?? 0;
+        }
+        let code = text[at++] ?? fail();
+        if (code === "_") {
+          code += text[at++] ?? fail();
+          if (code === "_a" || code === "_A") code += text[at++] ?? fail();
+        }
+        if (!["d", "i", "o", "u", "x", "X", "c", "s", "e", "E", "f", "g", "G", "_c", "_p", "_u", "_ad", "_ao", "_ax", "_Ad", "_Ao", "_Ax"].includes(code)) fail();
+        const bytes2 = code.startsWith("_a") || code.startsWith("_A") ? 0 : size2 ?? (code === "s" ? precision ?? fail() : ["c", "_c", "_p", "_u"].includes(code) ? 1 : 4);
+        if (bytes2 < 0 || code !== "s" && ![0, 1, 2, 4, 8].includes(bytes2)) fail();
+        if (["c", "_c", "_p", "_u"].includes(code) && bytes2 !== 1) fail();
+        if (["e", "E", "f", "g", "G"].includes(code) && bytes2 !== 4 && bytes2 !== 8) fail();
+        budget.check(width, budget.limits.maxBufferedBytes, "format width");
+        budget.check(precision ?? 0, budget.limits.maxBufferedBytes, "format precision");
+        parts.push({ code, flags, width, ...precision === void 0 ? {} : { precision }, bytes: bytes2 });
+      }
+    }
+    if (text[at++] !== '"') fail();
+    if (literal) parts.push(literal);
+    const conversions = parts.filter((part) => typeof part !== "string" && part.bytes > 0);
+    if (size2 !== void 0 && conversions.length > 1) fail();
+    const bytes = size2 ?? conversions.reduce((total, part) => total + part.bytes, 0);
+    budget.check(bytes * (repeat ?? 1), budget.limits.maxBufferedBytes, "format block");
+    units.push({ repeat: repeat ?? 1, explicitRepeat: repeat !== void 0, bytes, parts });
+  }
+  const size = units.reduce((total, unit) => total + unit.bytes * unit.repeat, 0);
+  budget.check(size, budget.limits.maxBufferedBytes, "format block");
+  budget.retain(text.length * 2 + units.length * 64);
+  const finalUnit = units.findLast((unit) => unit.parts.some((part) => typeof part !== "string" && part.code.startsWith("_A")));
+  return { units, size, ...finalUnit ? { finalUnit } : {} };
+}
+var controls = ["nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel", "bs", "ht", "lf", "vt", "ff", "cr", "so", "si", "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb", "can", "em", "sub", "esc", "fs", "gs", "rs", "us"];
+function converted(part, block, offset, used, address, budget) {
+  const { code, flags, width, precision, bytes } = part;
+  budget.buffered(Math.max(width, precision ?? 0) * 6);
+  budget.outputCapacity(width);
+  budget.charge(width);
+  if (bytes && offset >= used) return " ".repeat(width);
+  let value = 0n;
+  for (let i = code === "s" || ["e", "E", "f", "g", "G"].includes(code) ? -1 : bytes - 1; i >= 0; i--) value = value * 256n + BigInt(offset + i < used ? block[offset + i] : 0);
+  let text;
+  if (code === "s") {
+    let end = Math.min(used, offset + bytes, offset + (precision ?? bytes));
+    for (let i = offset; i < end; i++) if (block[i] === 0) {
+      end = i;
+      break;
+    }
+    text = raw(block.subarray(offset, end));
+  } else if (["c", "_p", "_c", "_u"].includes(code)) {
+    const byte = Number(value);
+    text = code === "c" ? String.fromCharCode(byte) : code === "_p" ? byte >= 32 && byte <= 126 ? String.fromCharCode(byte) : "." : code === "_u" ? controls[byte] ?? (byte === 127 ? "del" : byte > 127 ? byte.toString(16) : String.fromCharCode(byte)) : { 0: "\\0", 7: "\\a", 8: "\\b", 9: "\\t", 10: "\\n", 11: "\\v", 12: "\\f", 13: "\\r" }[byte] ?? (byte >= 32 && byte <= 126 ? String.fromCharCode(byte) : byte.toString(8).padStart(3, "0"));
+  } else if (["e", "E", "f", "g", "G"].includes(code)) {
+    const copy = new Uint8Array(bytes);
+    copy.set(block.subarray(offset, Math.min(used, offset + bytes)));
+    const view = new DataView(copy.buffer), number2 = bytes === 4 ? view.getFloat32(0, true) : view.getFloat64(0, true);
+    text = formatFloat(number2, code, flags, precision, budget);
+    if (flags.includes("0") && !flags.includes("-") && Number.isFinite(number2)) {
+      const signed = text.startsWith("-") || text.startsWith("+") || text.startsWith(" ");
+      budget.buffered(Math.max(width, text.length) * 6);
+      budget.outputCapacity(Math.max(width, text.length));
+      text = signed ? text[0] + text.slice(1).padStart(Math.max(0, width - 1), "0") : text.padStart(width, "0");
+    }
+  } else {
+    const addressCode = code.startsWith("_");
+    if (addressCode) value = BigInt(address + offset);
+    else if ((code === "d" || code === "i") && value >= 1n << BigInt(bytes * 8 - 1)) value -= 1n << BigInt(bytes * 8);
+    const kind = code.at(-1);
+    const radix = kind === "x" || kind === "X" ? 16 : kind === "o" ? 8 : 10;
+    const sign = value < 0n ? "-" : (code === "d" || code === "i" || code.endsWith("d")) && flags.includes("+") ? "+" : (code === "d" || code === "i" || code.endsWith("d")) && flags.includes(" ") ? " " : "";
+    budget.outputCapacity(precision ?? 0);
+    budget.charge(precision ?? 0);
+    const digits = (value === 0n && precision === 0 ? "" : (value < 0n ? -value : value).toString(radix)).padStart(precision ?? 0, "0");
+    const prefix = flags.includes("#") ? radix === 16 && value !== 0n ? "0x" : radix === 8 && !digits.startsWith("0") ? "0" : "" : "";
+    text = sign + prefix + digits;
+    if (flags.includes("0") && !flags.includes("-") && precision === void 0) text = sign + prefix + digits.padStart(Math.max(0, width - sign.length - prefix.length), "0");
+    if (kind === "X") text = text.toUpperCase();
+  }
+  return flags.includes("-") ? text.padEnd(width, " ") : text.padStart(width, " ");
+}
+async function formatCustom(format, block, used, address, final, budget) {
+  let offset = 0, result = "";
+  const append = (text) => {
+    budget.buffered((result.length + text.length) * 6);
+    budget.outputCapacity(result.length + text.length);
+    budget.retain(text.length * 2);
+    result += text;
+  };
+  try {
+    for (const [index, unit] of format.units.entries()) {
+      if (final && unit !== format.finalUnit) continue;
+      const isFinal = unit.parts.some((part) => typeof part !== "string" && part.code.startsWith("_A"));
+      if (isFinal !== final) {
+        if (!final) offset += unit.bytes * unit.repeat;
+        continue;
+      }
+      const repeat = !final && index === format.units.length - 1 && !unit.explicitRepeat && unit.bytes && format.size < block.length ? unit.repeat + Math.floor((block.length - format.size) / unit.bytes) : unit.repeat;
+      for (let count = 0; count < repeat; count++) {
+        budget.charge(unit.bytes + 1);
+        const cp = budget.checkpointWork();
+        if (cp) await cp;
+        let position = offset;
+        for (let i = 0; i < unit.parts.length; i++) {
+          const part = unit.parts[i];
+          if (typeof part === "string") {
+            let end = part.length;
+            if (count === repeat - 1 && repeat > 1 && i === unit.parts.length - 1) while (end && " 	".includes(part[end - 1])) end--;
+            append(part.slice(0, end));
+          } else {
+            append(converted(part, block, position, used, address, budget));
+            position += part.bytes;
+          }
+        }
+        offset += unit.bytes;
+      }
+    }
+    return result;
+  } finally {
+    budget.retain(-result.length * 2);
+  }
+}
+
+// packages/safe-bash-command-hexdump/src/options.ts
+var usage = "usage: hexdump [-bcCdovx] [-e fmt] [-f fmt_file] [-n length]\n               [-s skip] [file ...]\n       hd      [-bcdovx]  [-e fmt] [-f fmt_file] [-n length]\n               [-s skip] [file ...]";
+function number(text, skip, dialect) {
+  let offset = 0;
+  while (offset < text.length && " 	\n\r\v\f".includes(text[offset])) offset++;
+  const negative = text[offset] === "-";
+  if (negative || text[offset] === "+") offset++;
+  let base = 10;
+  if ((skip || dialect === "util-linux") && text[offset] === "0") {
+    base = 8;
+    if ((text[offset + 1] === "x" || text[offset + 1] === "X") && "0123456789abcdef".includes((text[offset + 2] ?? "!").toLowerCase())) {
+      base = 16;
+      offset += 2;
+    }
+  }
+  let value = 0;
+  const start = offset;
+  for (; offset < text.length; offset++) {
+    const digit = "0123456789abcdef".indexOf(text[offset].toLowerCase());
+    if (digit < 0 || digit >= base) break;
+    value = value * base + digit;
+    if (!Number.isSafeInteger(value)) throw new HexdumpError(`${text}: numeric value exceeds safe integer range`);
+  }
+  if (negative && value !== 0) throw new HexdumpError(`${text}: bad ${skip ? "skip" : "length"} value`);
+  if (dialect === "util-linux") {
+    const suffix = text.slice(offset);
+    let multiplier = suffix === "b" ? 512 : 1;
+    if (suffix !== "" && suffix !== "b") {
+      const power = "KMGTPEZY".indexOf(suffix[0] === "k" ? "K" : suffix[0]) + 1;
+      const tail = suffix.slice(1);
+      if (!power || tail !== "" && tail !== "B" && tail !== "iB") throw new HexdumpError(`${text}: bad ${skip ? "skip" : "length"} value`);
+      multiplier = (tail === "B" ? 1e3 : 1024) ** power;
+    }
+    if (offset === start || negative) throw new HexdumpError(`${text}: bad ${skip ? "skip" : "length"} value`);
+    value *= multiplier;
+  } else if (skip) value *= { b: 512, k: 1024, m: 1048576 }[text[offset] ?? ""] ?? 1;
+  if (!Number.isSafeInteger(value)) throw new HexdumpError(`${text}: numeric value exceeds safe integer range`);
+  return value;
+}
+function parse(budget, name, dialect) {
+  const args = budget.arguments();
+  const files = [];
+  const custom = [];
+  const formats = name === "hd" ? ["C"] : [];
+  const ordered = [...formats];
+  let verbose = false, ended = false, skip = 0, count = Infinity;
+  for (let index = 0; index < args.length; index++) {
+    const argument = args[index];
+    if (!ended && argument === "--") {
+      ended = true;
+      continue;
+    }
+    if (ended || argument === "-" || !argument.startsWith("-")) {
+      files.push(argument);
+      if (budget.context.env.POSIXLY_CORRECT !== void 0) ended = true;
+      continue;
+    }
+    for (let offset = 1; offset < argument.length; offset++) {
+      budget.charge();
+      const flag = argument[offset];
+      if (flag === "v") verbose = true;
+      else if (flag === "C" || flag === "b" || flag === "c" || flag === "d" || flag === "o" || flag === "x") {
+        if (name === "hd" && flag === "C") throw new HexdumpError(usage, true);
+        budget.check(custom.length + formats.length + 1, budget.limits.maxFormats, "format count");
+        formats.push(flag);
+        ordered.push(flag);
+      } else if (flag === "n" || flag === "s") {
+        const parameter = argument.slice(offset + 1) || args[++index];
+        if (parameter === void 0) throw new HexdumpError(`${name}: option requires an argument -- '${flag}'
+${usage}`, true);
+        if (flag === "n") count = number(parameter, false, dialect);
+        else skip = number(parameter, true, dialect);
+        break;
+      } else if (flag === "e") {
+        const parameter = argument.slice(offset + 1) || args[++index];
+        if (parameter === void 0) throw new HexdumpError("-e requires a format");
+        budget.check(custom.length + formats.length + 1, budget.limits.maxFormats, "format count");
+        const format = parseCustom(parameter, budget);
+        custom.push(format);
+        ordered.push(format);
+        break;
+      } else if (flag === "f") throw new HexdumpError("-f: format files are not supported");
+      else throw new HexdumpError(`unsupported option -- '${flag}'`);
+    }
+  }
+  if (ordered.length === 0) ordered.push("default");
+  return { ordered, custom, files, formats: formats.length || custom.length ? formats : ["default"], verbose, skip, count, dialect };
+}
+
+export {
+  formatCustom,
+  parse
+};

package/dist/safe-bash/command-chunks/{chunk-RVLO4DYT.js → chunk-N4PFUSRM.js}

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

package/dist/safe-bash/command-chunks/{chunk-WBNZ4PRE.js → chunk-NGG2XL56.js}

@@ -68,12 +68,15 @@ function createUnexpandWithSettings(limits) {
     const output = new ByteOutput(session);
     let column = 0, initial = true, active = true;
     let pendingStart = 0, pendingCount = 0, pendingTab = false;
-    const flushBlanksSlow = async (startPos, convertSingle, firstWait) => {
+    const flushBlanksSlow = async (startPos, convertSingle, firstWait, stepCharged = false) => {
       await firstWait;
       let position = startPos;
       while (position < column) {
-        const s = session.step();
-        if (s) await s;
+        if (!stepCharged) {
+          const s = session.step();
+          if (s) await s;
+        }
+        stepCharged = false;
         const stop = nextTab(position);
         if (stop !== void 0 && stop <= column && (stop - position > 1 || convertSingle)) {
           const b = output.byte(9);
@@ -94,7 +97,7 @@ function createUnexpandWithSettings(limits) {
       const convertSingle = initial || pendingCount > 1 || pendingTab;
       while (position < column) {
         const s = session.step();
-        if (s) return flushBlanksSlow(position, convertSingle, s);
+        if (s) return flushBlanksSlow(position, convertSingle, s, true);
         const stop = nextTab(position);
         if (stop !== void 0 && stop <= column && (stop - position > 1 || convertSingle)) {
           position = stop;

package/dist/safe-bash/command-chunks/{chunk-D4OP2BR3.js → chunk-NKFYQSES.js}

@@ -115,7 +115,7 @@ var functions = Object.freeze({
   limit: [2],
   range: [1, 2, 3],
   join: [1],
-  split: [1],
+  split: [1, 2],
   splits: [1, 2],
   sub: [2, 3],
   gsub: [2, 3],
@@ -577,7 +577,6 @@ jq: 1 compile error`, 3);
         } while (accept(";"));
         expect(")");
       }
-      if (token.text === "split" && args.length === 2) fail("unsupported function split/2");
       const definition2 = definitions.get(`${name}/${args.length}`);
       const parameter = parameters.get(name);
       if (parameter && !args.length) result = parameter;

package/dist/safe-bash/command-chunks/{chunk-NGWB2YBL.js → chunk-O4JQSB7O.js}

@@ -1,6 +1,6 @@
 import {
   SsconvertError
-} from "./chunk-DWFLVJC6.js";
+} from "./chunk-CCRHMAU5.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

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

@@ -5,14 +5,14 @@ import {
 // packages/safe-bash-command-rg/src/rg-command.ts
 init_buffer();
 import { utf8ByteLength, bytesFrom } from "../../safe-bash-byte-engine/index.js";
-import { tryGetMemoryDirectoryEntryNamesSync, tryReadMemoryFileViewSync } from "@poe-platform/safe-fs/core";
+import { tryReadMemoryFileViewSync } from "@poe-platform/safe-fs/core";
 import { assertCommandRequirements, collectBytes } from "../../safe-bash-contracts/index.js";
 import { hasYieldCheckpoint } from "../../safe-bash-contracts/yield.js";
 import { chargeRuntimeFileSystemOperation, getRuntimeBackingFileSystem } from "../../safe-bash-contracts/runtime-control.js";
 import { Matcher } from "../../safe-bash-search-engine/matcher.js";
 import { parse, ParsedArguments, SearchError } from "../../safe-bash-search-engine/options.js";
 import { data, elapsed, Printer, stats } from "../../safe-bash-search-engine/output.js";
-import { diagnostic, Limits, lineBatches, sharedOutBufGeneration, trySyncLineBatches, OutputClosed, pathFor } from "../../safe-bash-search-engine/shared.js";
+import { diagnostic, Limits, lineBatches, trySyncLineBatches, OutputClosed, pathFor } from "../../safe-bash-search-engine/shared.js";
 import { Walker } from "../../safe-bash-search-engine/walk.js";
 import { RegexExecutionError, withRegexSession } from "../../safe-bash-regex-engine/execution/portable.js";
 import { inProcessRegexProviders } from "../../safe-bash-regex-engine/execution/protocol.js";
@@ -20,69 +20,10 @@ import { assertPathRequirements, requiredFileInput, searchRequirements } from ".
 import { RESOLVED_EXIT_ONE, RESOLVED_EXIT_ZERO } from "../../safe-bash-io-engine/internal.js";
 var EMPTY_RG_LINES = Object.freeze([]);
 var EMPTY_PATTERNS = Object.freeze([]);
-var EMPTY_SEARCH_OPTIONS = Object.freeze({});
 var DEFAULT_CWD_PATHS = Object.freeze(["."]);
 var DEFAULT_STDIN_PATHS = Object.freeze(["-"]);
 var defaultLimitsTick = Limits.prototype.tick;
 var sharedReadState = { bytesRead: 0, bytesSearched: 0, binaryOffset: null, skipped: false };
-var srcRefSlotMap = /* @__PURE__ */ new WeakMap();
-var srcRefCountMap = /* @__PURE__ */ new WeakMap();
-var srcRefCacheLiteral = new Uint8Array(0);
-var defaultDateNowRg = Date.now;
-var lastRgTreePattern = "";
-var lastRgTreePath = "";
-var lastRgTreeCwd = "";
-var lastRgTreeOutLen = -1;
-var lastRgTreeFound = false;
-var lastRgTreeGen = -1;
-var lastRgTreeDirNames = new Array(8).fill("");
-var lastRgTreeFileNames = new Array(64).fill("");
-function preverifyMemoryRgTree(fastMem) {
-  const m = fastMem;
-  if (m && m.root?.entries?.size === 1 && m.root.entries._keys?.[0] === "src" && lastRgTreeOutLen >= 0 && lastRgTreePath === "/src") {
-    if (tryVerifyAndPopulate64Tree(fastMem, "/src", true)) {
-      m._rgTreeVerifiedTick = m.mutationTick ?? 0;
-      m._rgTreeVerifiedGen = lastRgTreeGen;
-    }
-  }
-}
-function tryVerifyAndPopulate64Tree(fastMem, rootPath, verifyOnly) {
-  if (verifyOnly && rootPath === "/src" && fastMem._rgTreeVerifiedTick !== void 0 && fastMem._rgTreeVerifiedTick === (fastMem.mutationTick ?? -1) && fastMem._rgTreeVerifiedGen === lastRgTreeGen) {
-    return true;
-  }
-  const rootEntries = tryGetMemoryDirectoryEntryNamesSync(fastMem, rootPath);
-  if (!rootEntries || rootEntries._next !== 8 || rootEntries.size !== 8) return false;
-  const rKeys = rootEntries._keys;
-  const rVals = rootEntries._vals;
-  for (let d = 0; d < 8; d++) {
-    const dName = rKeys[d];
-    if (verifyOnly) {
-      if (dName !== lastRgTreeDirNames[d]) return false;
-    } else {
-      lastRgTreeDirNames[d] = dName;
-    }
-    const dObj = rVals[d];
-    if (!dObj || dObj.type !== "directory" || dObj.mode === void 0 || (dObj.mode >> 6 & 4) !== 4) return false;
-    const sub = dObj.entries;
-    if (!sub || sub._next !== 8 || sub.size !== 8) return false;
-    const sKeys = sub._keys;
-    const sVals = sub._vals;
-    const base = d << 3;
-    for (let f = 0; f < 8; f++) {
-      const slot = base | f;
-      const fName = sKeys[f];
-      if (verifyOnly) {
-        if (fName !== lastRgTreeFileNames[slot]) return false;
-      } else {
-        lastRgTreeFileNames[slot] = fName;
-      }
-      const fObj = sVals[f];
-      if (!fObj || fObj.type !== "file" || fObj.mode === void 0 || (fObj.mode >> 6 & 4) !== 4 || fObj.revision !== 0) return false;
-      if (fObj.sourceRef === void 0 || srcRefSlotMap.get(fObj.sourceRef) !== slot) return false;
-    }
-  }
-  return true;
-}
 var BATCH_SIZE_1 = () => 1;
 var BATCH_SIZE_128 = () => 128;
 var RETURN_TRUE = () => true;
@@ -114,6 +55,7 @@ function trySearchFileSync(context, args, limits, matcher, printer, target, file
   const maxBytes = limits.hasFiniteMaxFileBytes ? limits.maxFileBytes : void 0;
   const view = target.memoryView ?? tryReadMemoryFileViewSync(backing, target.canonicalPath, maxBytes, context.signal);
   if (view === void 0) return void 0;
+  context.inputBudget?.check(view.byteLength);
   if (!args.hasInfiniteMaxCount && args.maxCount === 0) {
     totals.searches++;
     return false;
@@ -122,7 +64,7 @@ function trySearchFileSync(context, args, limits, matcher, printer, target, file
   const needAll = args.replacement !== void 0 || args.onlyMatching || args.mode === "matches" || args.stats === true;
   const hasExtYield = hasYieldCheckpoint(context.signal);
   const lit = matcher.literalAsciiBytes;
-  if (lit !== void 0 && !args.invert && args.replacement === void 0 && !args.onlyMatching && args.mode !== "matches" && !args.nullData && !args.crlf && binary === "skip" && args.hasInfiniteMaxCount !== false && !hasExtYield && (view.length <= limits.maxLineBytesSmi || view.length <= limits.maxLineBytes) && (target.sourceRef !== void 0 && srcRefSlotMap.get(target.sourceRef) === (totals.searches & 63) || view.indexOf(0) === -1)) {
+  if (lit !== void 0 && !args.invert && args.replacement === void 0 && !args.onlyMatching && args.mode !== "matches" && !args.nullData && !args.crlf && binary === "skip" && args.hasInfiniteMaxCount !== false && !hasExtYield && (view.length <= limits.maxLineBytesSmi || view.length <= limits.maxLineBytes) && view.indexOf(0) === -1) {
     const firstByte = lit[0];
     const litLen = lit.length;
     let matchedLines2 = 0;
@@ -130,43 +72,27 @@ function trySearchFileSync(context, args, limits, matcher, printer, target, file
     let bytesSearched2 = 0;
     if (!args.stats && !limits.hasExtYield && (args.mode === "count" || args.mode === "with" || args.mode === "without" || args.quiet) && lit.indexOf(10) === -1) {
       bytesSearched2 = view.length;
-      const slot = totals.searches & 63;
-      const srcRef = target.sourceRef;
-      if (srcRefCacheLiteral.length !== litLen || !srcRefCacheLiteral.every((byte, index) => byte === lit[index])) {
-        srcRefCacheLiteral = new Uint8Array(lit);
-        srcRefSlotMap = /* @__PURE__ */ new WeakMap();
-        srcRefCountMap = /* @__PURE__ */ new WeakMap();
-      }
-      if (srcRef !== void 0 && srcRefSlotMap.get(srcRef) === slot && args.mode === "count") {
-        matchedLines2 = srcRefCountMap.get(srcRef);
-        matchesCount2 = matchedLines2;
-      } else {
-        const searchEnd = view.length - litLen;
-        let pos = 0;
-        while (pos <= searchEnd) {
-          const index = view.indexOf(firstByte, pos);
-          if (index < 0 || index > searchEnd) break;
-          let equal = true;
-          for (let offset = 1; offset < litLen; offset++) {
-            if (view[index + offset] !== lit[offset]) {
-              equal = false;
-              break;
-            }
-          }
-          if (equal) {
-            matchedLines2++;
-            matchesCount2++;
-            if (args.quiet || args.mode === "with" || args.mode === "without") break;
-            const nl = view.indexOf(10, index + litLen);
-            if (nl < 0) break;
-            pos = nl + 1;
-          } else {
-            pos = index + 1;
+      const searchEnd = view.length - litLen;
+      let pos = 0;
+      while (pos <= searchEnd) {
+        const index = view.indexOf(firstByte, pos);
+        if (index < 0 || index > searchEnd) break;
+        let equal = true;
+        for (let offset = 1; offset < litLen; offset++) {
+          if (view[index + offset] !== lit[offset]) {
+            equal = false;
+            break;
           }
         }
-        if (srcRef !== void 0 && args.mode === "count") {
-          srcRefSlotMap.set(srcRef, slot);
-          srcRefCountMap.set(srcRef, matchedLines2);
+        if (equal) {
+          matchedLines2++;
+          matchesCount2++;
+          if (args.quiet || args.mode === "with" || args.mode === "without") break;
+          const nl = view.indexOf(10, index + litLen);
+          if (nl < 0) break;
+          pos = nl + 1;
+        } else {
+          pos = index + 1;
         }
       }
     } else {
@@ -684,14 +610,6 @@ function tryExecuteRgFastSync(context, executor, options) {
     const limits = runner.limits;
     limits.resetForRun(context, options);
     limits.speculative = true;
-    const cArgs = context.args;
-    if (cArgs.length === 3 && cArgs[0] === "-c" && cArgs[1] === lastRgTreePattern && cArgs[2] === lastRgTreePath && context.cwd === lastRgTreeCwd && sharedOutBufGeneration === lastRgTreeGen && lastRgTreeOutLen >= 0 && Date.now === defaultDateNowRg && options.regexExecutor === void 0 && tryVerifyAndPopulate64Tree(fastMem, lastRgTreePath, true)) {
-      committing = true;
-      if (lastRgTreeOutLen === 0 || limits.flushCachedSharedSync(lastRgTreeOutLen)) {
-        return lastRgTreeFound ? RESOLVED_EXIT_ZERO : RESOLVED_EXIT_ONE;
-      }
-      committing = false;
-    }
     const args = parse(context.args, runner.args);
     if (args.help || args.version || args.patternFiles.length !== 0 || args.mode === "json" || !args.quiet && args.mode === "lines" || args.before > 0 || args.after > 0 || args.stats || args.globs.length !== 0 || args.types.length !== 0 || args.ignoreFiles && args.ignorePaths.length !== 0) {
       return void 0;
@@ -731,14 +649,6 @@ function tryExecuteRgFastSync(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)) {
-      lastRgTreePattern = cArgs[1];
-      lastRgTreePath = cArgs[2];
-      lastRgTreeCwd = context.cwd;
-      lastRgTreeOutLen = limits.outPos;
-      lastRgTreeFound = runner.found;
-      lastRgTreeGen = sharedOutBufGeneration;
-    }
     committing = true;
     const flushRes = limits.flushSyncOrAsync();
     if (flushRes === void 0) return runner.found ? RESOLVED_EXIT_ZERO : RESOLVED_EXIT_ONE;
@@ -1128,7 +1038,6 @@ function createRgCommand(executor, options = {}) {
 }
 
 export {
-  preverifyMemoryRgTree,
   clearRgFastRunnerPool,
   createRgCommand
 };

package/dist/safe-bash/command-chunks/{chunk-7L24L4UO.js → chunk-OQU6UT6X.js}

@@ -1,9 +1,9 @@
 import {
   htmlSpace
-} from "./chunk-HHP343KT.js";
+} from "./chunk-WTECBRU4.js";
 import {
   Builder
-} from "./chunk-4Y3WVMK4.js";
+} from "./chunk-PV66YWHB.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";
@@ -117,24 +117,6 @@ async function escapeText(text, budget, maximum, edges = [false, false], precedi
 }
 async function destination(value, image, budget) {
   if (value === void 0) return void 0;
-  if (value.length >= 10 && value.length <= 2048 && (value.startsWith("https://") || value.startsWith("http://"))) {
-    let cleanUrl = true;
-    for (let i = 0; i < value.length; i++) {
-      const c = value.charCodeAt(i);
-      if (c <= 32 || c >= 127 || c === 37 || c === 38 || c === 92 || c === 40 || c === 41 || c === 60 || c === 62) {
-        cleanUrl = false;
-        break;
-      }
-    }
-    if (cleanUrl && /^https?:\/\/[A-Za-z0-9]+(?:\.[A-Za-z0-9]+)+(?:\/[A-Za-z0-9._~:@!$'*,;=-]*)?$/u.test(value)) {
-      budget.work(value.length * 2);
-      {
-        const c = budget.checkpoint();
-        if (c) await c;
-      }
-      return value;
-    }
-  }
   let first = 0, last = value.length, reference = "none";
   for (let offset = 0; offset < value.length; offset++) {
     budget.work(1);