poe-code 17.0.32 → 17.0.34

package/dist/{chunk-54JM3XZC.js → chunk-LYH24BKM.js}

@@ -1264,6 +1264,9 @@ var AvailableRecords = class {
 function foldAscii(code) {
   return code >= 65 && code <= 90 ? code + 32 : code;
 }
+function isAsciiWord(code) {
+  return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 95;
+}
 
 // packages/safe-bash/src/contracts/yield.ts
 var checkpoints = /* @__PURE__ */ new WeakMap();
@@ -9846,7 +9849,7 @@ async function matchEre(program, subject, ledger, signal) {
   await admitAscii(subject, ledger, signal);
   return runMatcher(program, subject, ledger, signal, 0, true);
 }
-async function prepareUtf8EreSubject(bytes8, ledger, signal) {
+async function prepareUtf8EreSubject(bytes8, ledger, signal, leftmostFirst = false, word = false) {
   ledger.check(signal);
   ledger.admitInput("subjectBytes", bytes8.length, signal);
   ledger.charge("allocationUnits", bytes8.length * 11 + 16, signal);
@@ -9857,7 +9860,7 @@ async function prepareUtf8EreSubject(bytes8, ledger, signal) {
   const offsets = [];
   for (let offset = 0; offset < owned.length; ) {
     const first = owned[offset];
-    const width = first < 128 ? 1 : first < 224 ? 2 : first < 240 ? 3 : 4;
+    const width = word || first < 128 ? 1 : first < 224 ? 2 : first < 240 ? 3 : 4;
     ledger.charge("work", width, signal);
     await ledger.checkpoint(signal);
     offsets.push(offset);
@@ -9882,14 +9885,14 @@ async function prepareUtf8EreSubject(bytes8, ledger, signal) {
         else upper = middle;
       }
       if (offsets[lower] !== start) throw new RangeError("UTF-8 ERE cursor must be a scalar boundary");
-      const span = await runMatcher(program, subject, ledger, signal, lower, false);
+      const span = await runMatcher(program, subject, ledger, signal, lower, false, leftmostFirst, word);
       if (!span) return void 0;
       ledger.charge("allocationUnits", 2, signal);
       return Object.freeze({ start: offsets[span.start], end: offsets[span.end] });
     };
   };
 }
-async function runMatcher(program, subject, ledger, signal, from, materialize) {
+async function runMatcher(program, subject, ledger, signal, from, materialize, leftmostFirst = false, word = false) {
   const root = resolveEreProgram(program, ledger);
   const width = program.groups + 1;
   ledger.charge("work", width * 2, signal);
@@ -9908,6 +9911,11 @@ async function runMatcher(program, subject, ledger, signal, from, materialize) {
     pending.push({ position, task: next, captures, histories });
   };
   for (let start = from; start <= subject.length; start++) {
+    if (word) {
+      ledger.charge("work", 1, signal);
+      await ledger.checkpoint(signal);
+      if (isAsciiWord(subject.charCodeAt(start - 1))) continue;
+    }
     push(start, task(() => ({ kind: "node", node: root, next: null })), emptyCaptures, emptyHistories);
     let best;
     while (pending.length > 0) {
@@ -9916,6 +9924,11 @@ async function runMatcher(program, subject, ledger, signal, from, materialize) {
       const state = pending.pop();
       const current = state.task;
       if (current === null) {
+        if (word && isAsciiWord(subject.charCodeAt(state.position))) continue;
+        if (leftmostFirst) {
+          best = state;
+          break;
+        }
         if (!best || await preferred(state, best, ledger, signal)) best = state;
         continue;
       }
@@ -9957,7 +9970,7 @@ async function runMatcher(program, subject, ledger, signal, from, materialize) {
         case "literal":
         case "set": {
           const code = subject.charCodeAt(state.position);
-          if (state.position < subject.length && (node.kind === "dot" || node.kind === "literal" && (node.insensitive ? foldAscii(node.code) === foldAscii(code) : node.code === code) || node.kind === "set" && (code < 128 ? node.members[code] : node.nonAscii))) {
+          if (state.position < subject.length && (node.kind === "dot" && (!leftmostFirst || code !== 10) || node.kind === "literal" && (node.insensitive ? foldAscii(node.code) === foldAscii(code) : node.code === code) || node.kind === "set" && (code < 128 ? node.members[code] : node.nonAscii))) {
             push(state.position + 1, current.next, state.captures, state.histories);
           }
           break;
@@ -10101,13 +10114,12 @@ function descriptor(value2, limits) {
   if (value2 === null || typeof value2 !== "object") fail("protocol", "invalid descriptor");
   const kind = Object.getOwnPropertyDescriptor(value2, "kind");
   if (!kind || !("value" in kind)) fail("protocol", "invalid descriptor kind");
-  if (kind.value !== "grep" && kind.value !== "rg") fail("unsupported", "only grep and fixed rg selection descriptors are supported");
+  if (kind.value !== "grep" && kind.value !== "rg") fail("unsupported", "only grep and rg selection descriptors are supported");
   const flags4 = kind.value === "grep" ? ["fixed", "extended", "insensitive", "whole", "word"] : ["fixed", "whole", "word", "nullData"];
   record(value2, ["kind", "patterns", ...flags4, ...kind.value === "rg" ? ["case"] : []]);
   for (const flag of flags4) if (typeof value2[flag] !== "boolean") fail("protocol", `invalid ${flag} flag`);
   if (kind.value === "rg" && !["sensitive", "insensitive", "smart"].includes(value2.case)) fail("protocol", "invalid case flag");
-  if (value2.word || kind.value === "rg" && value2.case !== "sensitive") fail("unsupported", "word matching and rg case-insensitive selection are unsupported");
-  if (kind.value === "rg" && !value2.fixed) fail("unsupported", "rg regex modes are unsupported; use fixed UTF-8 patterns");
+  if (kind.value === "rg" && (value2.word || value2.case !== "sensitive")) fail("unsupported", "rg word matching and case-insensitive selection are unsupported");
   array(value2.patterns, limits.maxPatterns, "pattern");
   let bytes8 = 0;
   for (let index = 0; index < value2.patterns.length; index++) {
@@ -10129,7 +10141,6 @@ function admit(input4, limits, signal) {
     record(row, ["bytes", "all", "terminated"], ["directory", "ancestors"]);
     if (!(row.bytes instanceof Uint8Array) || typeof row.all !== "boolean" || typeof row.terminated !== "boolean" || Object.hasOwn(row, "directory") && typeof row.directory !== "boolean" || Object.hasOwn(row, "ancestors") && typeof row.ancestors !== "boolean") fail("protocol", "invalid row");
     if (Object.hasOwn(row, "directory") || Object.hasOwn(row, "ancestors")) fail("unsupported", "glob row flags are unsupported");
-    if (row.all && selected.kind !== "grep") fail("unsupported", "rg all-match enumeration is unsupported");
     const length2 = byteLength.call(row.bytes);
     if (length2 > limits.maxInputBytes - bytes8) fail("limit", "aggregate input byte limit exceeded");
     bytes8 += length2;
@@ -10313,17 +10324,28 @@ async function compileLiteral(bytes8, ledger, signal, insensitive = false) {
   }
   return { bytes: bytes8, fallback, insensitive };
 }
-async function literalStart(program, subject, whole, ledger, signal, from = 0) {
+async function literalStart(program, subject, whole, word, ledger, signal, from = 0) {
   const { bytes: bytes8, fallback } = program;
   ledger.charge("work", 1, signal);
   await ledger.checkpoint(signal);
   if (whole && (from !== 0 || bytes8.length !== subject.length) || bytes8.length > subject.length - from) return -1;
-  if (bytes8.length === 0) return from;
+  if (bytes8.length === 0) {
+    for (let start = from; start <= subject.length; start++) {
+      ledger.charge("work", 1, signal);
+      await ledger.checkpoint(signal);
+      if (!word || !isAsciiWord(subject[start - 1] ?? -1) && !isAsciiWord(subject[start] ?? -1)) return start;
+    }
+    return -1;
+  }
   for (let index = from, prefix3 = 0; index < subject.length; ) {
     ledger.charge("work", 1, signal);
     if ((program.insensitive ? foldAscii(subject[index]) : subject[index]) === bytes8[prefix3]) {
       index++;
-      if (++prefix3 === bytes8.length) return index - prefix3;
+      if (++prefix3 === bytes8.length) {
+        const start = index - prefix3;
+        if (!word || !isAsciiWord(subject[start - 1] ?? -1) && !isAsciiWord(subject[index] ?? -1)) return start;
+        prefix3 = fallback[prefix3 - 1];
+      }
     } else if (prefix3 > 0) prefix3 = fallback[prefix3 - 1];
     else index++;
     await ledger.checkpoint(signal);
@@ -10335,6 +10357,9 @@ async function enumerate(input4, row, finders, usage3, signal) {
   ledger.charge("allocationUnits", finders.length + 2, signal);
   const cached = new Array(finders.length);
   const ranges2 = [];
+  const byteEmpty = input4.descriptor.kind === "rg" && !input4.descriptor.whole && input4.descriptor.patterns.length === 1 && input4.descriptor.patterns[0] === "";
+  const byteCursor = input4.descriptor.kind === "grep" && input4.descriptor.word;
+  let previousEnd = -1;
   for (let from = 0; from <= row.bytes.length; ) {
     let best;
     for (let index = 0; index < finders.length; index++) {
@@ -10345,9 +10370,14 @@ async function enumerate(input4, row, finders, usage3, signal) {
         candidate = await finders[index](from) ?? null;
         cached[index] = candidate;
       }
-      if (candidate && (!best || candidate.start < best.start || candidate.start === best.start && candidate.end > best.end)) best = candidate;
+      if (candidate && (!best || candidate.start < best.start || input4.descriptor.kind === "grep" && candidate.start === best.start && candidate.end > best.end)) best = candidate;
+    }
+    if (!best || byteEmpty && !row.terminated && best.start === row.bytes.length) break;
+    if (input4.descriptor.kind === "rg" && !byteEmpty && best.start === best.end && best.start === previousEnd) {
+      const byte = row.bytes[best.end];
+      from = best.end + (byte === void 0 || byte < 128 ? 1 : byte < 224 ? 2 : byte < 240 ? 3 : 4);
+      continue;
     }
-    if (!best) break;
     if (ranges2.length / 2 >= limits.maxMatchesPerLine) fail("limit", "matches per line limit exceeded");
     if (usage3.count >= limits.maxTotalMatches) fail("limit", "total match limit exceeded");
     if (usage3.count >= Math.floor(limits.maxResultBytes / 16)) fail("limit", "result byte limit exceeded");
@@ -10355,10 +10385,11 @@ async function enumerate(input4, row, finders, usage3, signal) {
     ledger.charge("allocationUnits", 24, signal);
     usage3.count++;
     ranges2.push(best.start, best.end);
+    previousEnd = best.end;
     if (best.end > best.start) from = best.end;
     else {
       const byte = row.bytes[best.end];
-      from = best.end + (byte === void 0 || byte < 128 ? 1 : byte < 224 ? 2 : byte < 240 ? 3 : 4);
+      from = best.end + (byteEmpty || byteCursor || byte === void 0 || byte < 128 ? 1 : byte < 224 ? 2 : byte < 240 ? 3 : 4);
     }
   }
   ledger.charge("work", ranges2.length, signal);
@@ -10379,7 +10410,7 @@ async function executeLiteral(input4, signal) {
     if (row.all) {
       ledger.charge("allocationUnits", programs2.length * 2, signal);
       const finders = programs2.map((program) => async (from) => {
-        const start2 = await literalStart(program, row.bytes, selected.whole, ledger, signal, from);
+        const start2 = await literalStart(program, row.bytes, selected.whole, selected.word, ledger, signal, from);
         if (start2 < 0) return void 0;
         ledger.charge("allocationUnits", 2, signal);
         return { start: start2, end: start2 + program.bytes.length };
@@ -10390,7 +10421,7 @@ async function executeLiteral(input4, signal) {
     let start = -1;
     let end = -1;
     for (const program of programs2) {
-      const candidate = await literalStart(program, row.bytes, selected.whole, ledger, signal);
+      const candidate = await literalStart(program, row.bytes, selected.whole, selected.word, ledger, signal);
       if (candidate < 0) continue;
       if (start < 0 || candidate < start) {
         start = candidate;
@@ -10409,7 +10440,19 @@ async function executeLiteral(input4, signal) {
 }
 async function execute(input4, signal) {
   const { descriptor: selected, rows: rows2, ledger } = input4;
-  if (selected.fixed) return executeLiteral(input4, signal);
+  let literal = selected.fixed;
+  if (!literal && selected.kind === "rg") {
+    literal = true;
+    patterns: for (const pattern of selected.patterns) {
+      ledger.charge("work", pattern.length, signal);
+      await ledger.checkpoint(signal);
+      for (const character of pattern) if ("\\.^$[]()|*+?{}".includes(character)) {
+        literal = false;
+        break patterns;
+      }
+    }
+  }
+  if (literal) return executeLiteral(input4, signal);
   const programs2 = [];
   for (const pattern of selected.patterns) {
     if (selected.kind === "rg" && !selected.nullData && pattern.includes("\n")) fail("unsupported", "rg multiline matching is unsupported");
@@ -10427,7 +10470,7 @@ async function execute(input4, signal) {
   const results = [];
   const usage3 = { count: 0 };
   for (const row of rows2) {
-    const subject = await prepareUtf8EreSubject(row.bytes, ledger, signal);
+    const subject = await prepareUtf8EreSubject(row.bytes, ledger, signal, selected.kind === "rg", selected.word);
     if (row.all) {
       ledger.charge("allocationUnits", programs2.length + 1, signal);
       const finders = [];
@@ -10727,8 +10770,9 @@ function options2(args, short, long = {}, stopAtOperand = false, onOperand, onVa
     if (argument2.startsWith("--")) {
       const equals = argument2.indexOf("=");
       const name2 = argument2.slice(2, equals < 0 ? void 0 : equals);
-      const key = long[name2];
-      if (!key || !specifications.has(key)) throw new UsageError(`unrecognized option '${argument2}'`);
+      const alias2 = long[name2];
+      const key = alias2 === false ? name2 : alias2;
+      if (!key || alias2 !== false && !specifications.has(key)) throw new UsageError(`unrecognized option '${argument2}'`);
       if (specifications.get(key)) {
         const value2 = equals >= 0 ? argument2.slice(equals + 1) : args[++index];
         if (value2 === void 0) throw new UsageError(`option '--${name2}' requires an argument`);
@@ -10908,7 +10952,8 @@ function replaceArgument(source2, pattern, replacement) {
   chunks.push(source2.subarray(start));
   return concatenate(chunks);
 }
-function escapeBytes(text4, zeroOctal = false, bareOctal = false) {
+function escapeBytes(text4, zeroOctal = false, bareOctal = false, unicode) {
+  if (unicode && typeof text4 === "string") text4 = encoder2.encode(text4);
   if (typeof text4 === "string") {
     const chunks = [];
     const control2 = { a: 7, b: 8, e: 27, E: 27, f: 12, n: 10, r: 13, t: 9, v: 11, "\\": 92 };
@@ -10945,7 +10990,7 @@ function escapeBytes(text4, zeroOctal = false, bareOctal = false) {
     return { bytes: concatenate(chunks), stop: false };
   }
   const source2 = text4;
-  const bytes8 = new Uint8Array(source2.length);
+  const bytes8 = new Uint8Array(source2.length * (unicode && !unicode.utf8 ? 3 : 1));
   const control = { 97: 7, 98: 8, 101: 27, 69: 27, 102: 12, 110: 10, 114: 13, 116: 9, 118: 11, 92: 92 };
   let size = 0;
   for (let index = 0; index < source2.length; ) {
@@ -10969,6 +11014,40 @@ function escapeBytes(text4, zeroOctal = false, bareOctal = false) {
       index = offset;
       continue;
     }
+    if (unicode && (next === 117 || next === 85)) {
+      const digits = next === 117 ? 4 : 8;
+      let offset = index + 2;
+      const end = Math.min(source2.length, offset + digits);
+      let value2 = 0;
+      while (offset < end) {
+        const digit4 = source2[offset];
+        const number8 = digit4 >= 48 && digit4 <= 57 ? digit4 - 48 : digit4 >= 65 && digit4 <= 70 ? digit4 - 55 : digit4 >= 97 && digit4 <= 102 ? digit4 - 87 : -1;
+        if (number8 < 0) break;
+        value2 = value2 * 16 + number8;
+        offset++;
+      }
+      if (offset === index + 2) unicode.missingDigit(String.fromCharCode(next));
+      else {
+        if (value2 < 2147483648) {
+          if (!unicode.utf8 && value2 > 127) {
+            const literal = encoder2.encode(`\\${value2 <= 65535 ? "u" : "U"}${value2.toString(16).toUpperCase().padStart(value2 <= 65535 ? 4 : 8, "0")}`);
+            bytes8.set(literal, size);
+            size += literal.length;
+          } else if (value2 < 128) bytes8[size++] = value2;
+          else {
+            const length2 = value2 < 2048 ? 2 : value2 < 65536 ? 3 : value2 < 2097152 ? 4 : value2 < 67108864 ? 5 : 6;
+            for (let position = length2 - 1; position > 0; position--) {
+              bytes8[size + position] = 128 | value2 & 63;
+              value2 = Math.floor(value2 / 64);
+            }
+            bytes8[size] = 255 << 8 - length2 & 255 | value2;
+            size += length2;
+          }
+        }
+        index = offset;
+        continue;
+      }
+    }
     if (next === 120) {
       let offset = index + 2;
       const end = Math.min(source2.length, offset + 2);
@@ -11068,6 +11147,11 @@ async function formatPrintf(context2) {
   let argument2 = 1;
   let exitCode = 0;
   let stopped = false;
+  const locale = context2.env.LC_ALL || context2.env.LC_CTYPE || context2.env.LANG || "C.UTF-8";
+  const unicodeErrors = [];
+  const unicode = { utf8: locale !== "C" && locale !== "POSIX", missingDigit: (escape2) => {
+    unicodeErrors.push(escape2);
+  } };
   do {
     const before = argument2;
     for (let offset = 0; offset < formatLength && !stopped; ) {
@@ -11075,7 +11159,9 @@ async function formatPrintf(context2) {
         const end = rawFormat ? rawFormat.indexOf(37, offset) : format3.indexOf("%", offset);
         const limit2 = end < 0 ? formatLength : end;
         const literal = rawFormat ? rawFormat.subarray(offset, limit2) : format3.slice(offset, limit2);
-        const escaped3 = escapeBytes(literal);
+        const escaped3 = escapeBytes(literal, false, false, unicode);
+        for (const escape2 of unicodeErrors.splice(0)) await writeDiagnostic(context2.stderr, `printf: missing unicode digit for \\${escape2}
+`, context2.signal);
         await output(context2, escaped3.bytes);
         stopped = escaped3.stop;
         offset += literal.length;
@@ -11104,7 +11190,9 @@ async function formatPrintf(context2) {
       if (specifier === "b" || specifier === "s") {
         const suppliedValue = arguments_.values[suppliedIndex] ?? "";
         const raw7 = specifier === "b" && typeof suppliedValue === "string" ? suppliedValue : arguments_.bytes(suppliedIndex) ?? new Uint8Array();
-        const escaped3 = specifier === "b" ? escapeBytes(raw7, true, true) : { bytes: raw7, stop: false };
+        const escaped3 = specifier === "b" ? escapeBytes(raw7, true, true, unicode) : { bytes: raw7, stop: false };
+        for (const escape2 of unicodeErrors.splice(0)) await writeDiagnostic(context2.stderr, `printf: missing unicode digit for \\${escape2}
+`, context2.signal);
         const bytes8 = escaped3.bytes.subarray(0, precision);
         const padding = " ".repeat(Math.max(0, width - bytes8.length));
         if (!flags4.includes("-")) await output(context2, padding);
@@ -15138,7 +15226,7 @@ async function* combinedInput(context2, names, state) {
     }
   }
 }
-async function prefix(context2, source2, count2, bytes8, skip) {
+async function prefix(context2, source2, count2, bytes8, skip, delimiter) {
   let remaining = count2;
   if (!remaining && !skip) return;
   for await (const chunk of source2) {
@@ -15149,7 +15237,7 @@ async function prefix(context2, source2, count2, bytes8, skip) {
         offset = Math.min(chunk.length, remaining);
         remaining -= offset;
       } else {
-        for (; offset < chunk.length && remaining; offset++) if (chunk[offset] === 10) remaining--;
+        for (; offset < chunk.length && remaining; offset++) if (chunk[offset] === delimiter) remaining--;
       }
     }
     if (skip) {
@@ -15160,12 +15248,12 @@ async function prefix(context2, source2, count2, bytes8, skip) {
     }
   }
 }
-async function suffix(context2, source2, count2, bytes8, omit) {
+async function suffix(context2, source2, count2, bytes8, omit, delimiter) {
   let pending = [];
   let start = 0;
   let size = 0;
   const records5 = bytes8 ? source2 : (async function* () {
-    for await (const line of lines(source2)) yield line.terminated ? concatenate([line.bytes, Uint8Array.of(10)]) : line.bytes;
+    for await (const line of lines(source2, delimiter)) yield line.terminated ? concatenate([line.bytes, Uint8Array.of(delimiter)]) : line.bytes;
   })();
   for await (const chunk of records5) {
     context2.signal.throwIfAborted();
@@ -15240,9 +15328,10 @@ function headTail(name2, maxTailFollowHandles = 64) {
   return define(name2, async (context2) => {
     const args = context2.args[0] && /^-[0-9]+$/u.test(context2.args[0]) ? ["-n", context2.args[0].slice(1), ...context2.args.slice(1)] : context2.args;
     const follow = name2 === "tail" ? parseTailFollow(args) : void 0;
-    const parsed = options2(follow?.args ?? args, "n:c:qv", { lines: "n", bytes: "c", quiet: "q", silent: "q", verbose: "v" });
+    const parsed = options2(follow?.args ?? args, "n:c:qvz", { lines: "n", bytes: "c", quiet: "q", silent: "q", verbose: "v", "zero-terminated": "z" });
     if (parsed.flags.has("n") && parsed.flags.has("c")) throw new UsageError("cannot combine line and byte counts");
     const bytes8 = parsed.flags.has("c");
+    const delimiter = parsed.flags.has("z") ? 0 : 10;
     const amount = value(parsed, bytes8 ? "c" : "n") ?? "10";
     const positive = amount.startsWith("+");
     const negative = amount.startsWith("-");
@@ -15256,7 +15345,7 @@ function headTail(name2, maxTailFollowHandles = 64) {
       bytes: bytes8,
       positive,
       headers: parsed.flags.has("v") || names.length > 1 && !parsed.flags.has("q")
-    }, maxTailFollowHandles, (target, source2) => positive ? prefix(target, source2, Math.max(0, count2 - 1), bytes8, true) : suffix(target, source2, count2, bytes8, false));
+    }, maxTailFollowHandles, (target, source2) => positive ? prefix(target, source2, Math.max(0, count2 - 1), bytes8, true, delimiter) : suffix(target, source2, count2, bytes8, false, delimiter));
     await assertInputRequirements(context2, names);
     assertCommandRequirements(context2, inspectedInputRequirements, [names.some((name3) => name3 !== "-") ? "file" : "stdin"]);
     let exitCode = 0;
@@ -15274,9 +15363,9 @@ function headTail(name2, maxTailFollowHandles = 64) {
 `);
           headerWritten = true;
         }
-        if (name2 === "head" && !negative) await prefix(context2, input(context2, file), count2, bytes8, false);
-        else if (name2 === "tail" && positive) await prefix(context2, input(context2, file), Math.max(0, count2 - 1), bytes8, true);
-        else await suffix(context2, input(context2, file), count2, bytes8, name2 === "head");
+        if (name2 === "head" && !negative) await prefix(context2, input(context2, file), count2, bytes8, false, delimiter);
+        else if (name2 === "tail" && positive) await prefix(context2, input(context2, file), Math.max(0, count2 - 1), bytes8, true, delimiter);
+        else await suffix(context2, input(context2, file), count2, bytes8, name2 === "head", delimiter);
       } catch (error) {
         await diagnostic(context2, error);
         exitCode = 1;
@@ -15345,7 +15434,26 @@ function streamCommands(maxTeeTargets = 64, maxTailFollowHandles = 64) {
   }
   return [
     define("cat", async (context2) => {
-      const parsed = options2(context2.args, "nbsvETAute", { number: "n", "number-nonblank": "b", "squeeze-blank": "s", "show-ends": "E", "show-tabs": "T", "show-nonprinting": "v", "show-all": "A" });
+      const parsed = options2(context2.args, "nbsvETAute", { help: false, number: "n", "number-nonblank": "b", "squeeze-blank": "s", "show-ends": "E", "show-tabs": "T", "show-nonprinting": "v", "show-all": "A" });
+      if (parsed.flags.has("help")) {
+        await output(context2, `Usage: cat [OPTION]... [FILE]...
+Concatenate FILEs to standard output. With no FILE, or FILE -, read standard input.
+
+  -n, --number             Number all output lines
+  -b, --number-nonblank    Number nonempty output lines (overrides -n)
+  -s, --squeeze-blank      Suppress repeated empty output lines
+  -E, --show-ends          Display $ at each line end
+  -T, --show-tabs          Display TAB characters as ^I
+  -v, --show-nonprinting   Display nonprinting characters
+  -A, --show-all           Equivalent to -vET
+  -e                      Equivalent to -vE
+  -t                      Equivalent to -vT
+  -u                      Accepted for compatibility; ignored
+      --help              Display this help and exit
+      --                  End options; remaining arguments are filenames
+`);
+        return { exitCode: 0 };
+      }
       await assertInputRequirements(context2, parsed.operands);
       if (parsed.flags.has("A")) for (const flag of ["v", "E", "T"]) parsed.flags.add(flag);
       if (parsed.flags.has("e")) {
@@ -25721,7 +25829,7 @@ async function execute2(program, context2, files, quiet, budget, separator, outp
               const character = pattern[offset];
               const lineEnd = character === "\n" && separator === "\n";
               const token = character === void 0 || lineEnd ? "$" : escapes3[character] ?? (character.charCodeAt(0) < 32 || character.charCodeAt(0) >= 127 ? `\\${character.charCodeAt(0).toString(8).padStart(3, "0")}` : character);
-              if (line.length + token.length >= 60) {
+              if (character !== void 0 && !lineEnd && line.length + token.length >= 70) {
                 await emit2(line + "\\" + separator);
                 line = "";
               }
@@ -25882,6 +25990,14 @@ function sedCommand(options3 = {}) {
         separator = "\0";
         continue;
       }
+      if (argument2 === "--quiet") {
+        quiet = true;
+        continue;
+      }
+      if (argument2 === "--regexp-extended") {
+        extended = true;
+        continue;
+      }
       if (argument2.startsWith("--")) throw new ProgramError(`unsupported option '${argument2}'`);
       for (let position = 1; position < argument2.length; position++) {
         const flag = argument2[position];
@@ -28513,6 +28629,21 @@ async function sortedKeys(value2, budget) {
   await stableSort(keys2, budget, (left, right) => stringCompare(left, right, budget));
   return keys2;
 }
+async function sortObjectKeys(value2, budget) {
+  await budget.tick();
+  if (Array.isArray(value2)) {
+    budget.collection(value2.length);
+    const result2 = [];
+    for (const item of value2) result2.push(await sortObjectKeys(item, budget));
+    return result2;
+  }
+  if (isObject(value2)) {
+    const result2 = object();
+    for (const key of await sortedKeys(value2, budget)) put(result2, key, await sortObjectKeys(value2[key], budget));
+    return result2;
+  }
+  return value2;
+}
 async function compare4(left, right, budget) {
   await budget.tick();
   const rank2 = (value2) => value2 === null ? 0 : value2 === false ? 1 : value2 === true ? 2 : isNumber(value2) ? 3 : typeof value2 === "string" ? 4 : Array.isArray(value2) ? 5 : 6;
@@ -29757,7 +29888,7 @@ function argumentsFor(args, budget) {
     argumentBytes += Buffer.byteLength(argument2);
     if (argumentBytes > budget.limits.maxInputBytes) throw new JqLimitError("maxInputBytes");
   }
-  const options3 = { raw: false, rawInput: false, joinOutput: false, compact: false, slurp: false, nullInput: false, exitStatus: false, source: void 0, programFile: void 0, files: [], variables: /* @__PURE__ */ new Map() };
+  const options3 = { raw: false, rawInput: false, joinOutput: false, compact: false, sortKeys: false, slurp: false, nullInput: false, exitStatus: false, source: void 0, programFile: void 0, files: [], variables: /* @__PURE__ */ new Map() };
   const named2 = object();
   let ended = false;
   let variableBytes = 0;
@@ -29798,10 +29929,10 @@ function argumentsFor(args, budget) {
       options3.programFile = operand();
       continue;
     }
-    const long = { "--raw-output": "r", "--raw-input": "R", "--join-output": "j", "--compact-output": "c", "--slurp": "s", "--null-input": "n", "--exit-status": "e" };
+    const long = { "--raw-output": "r", "--raw-input": "R", "--join-output": "j", "--compact-output": "c", "--sort-keys": "S", "--slurp": "s", "--null-input": "n", "--exit-status": "e" };
     if (!ended && argument2.startsWith("-") && argument2 !== "-") {
       const flags4 = Object.hasOwn(long, argument2) ? long[argument2] : argument2.startsWith("--") ? "" : argument2.slice(1);
-      if (!flags4 || !/^[rRjcsne]+$/u.test(flags4)) throw new JqError(`unsupported option ${argument2}`, 2);
+      if (!flags4 || [...flags4].some((flag) => !"rRjcSsne".includes(flag))) throw new JqError(`unsupported option ${argument2}`, 2);
       for (const flag of flags4) {
         if (flag === "r") options3.raw = true;
         else if (flag === "R") options3.rawInput = true;
@@ -29809,6 +29940,7 @@ function argumentsFor(args, budget) {
           options3.joinOutput = true;
           options3.raw = true;
         } else if (flag === "c") options3.compact = true;
+        else if (flag === "S") options3.sortKeys = true;
         else if (flag === "s") options3.slurp = true;
         else if (flag === "n") options3.nullInput = true;
         else options3.exitStatus = true;
@@ -29934,7 +30066,8 @@ async function execute3(context2, limits) {
           if (++budget.results > limits.maxResults) throw new JqLimitError("maxResults");
           const remaining = limits.maxOutputBytes - budget.outputBytes;
           const suffix2 = options3.joinOutput ? "" : "\n";
-          const text4 = options3.raw && typeof result2 === "string" ? result2 : await stringify(result2, budget, !options3.compact, Math.max(0, remaining - suffix2.length), "maxOutputBytes");
+          const output3 = options3.sortKeys ? await sortObjectKeys(result2, budget) : result2;
+          const text4 = options3.raw && typeof output3 === "string" ? output3 : await stringify(output3, budget, !options3.compact, Math.max(0, remaining - suffix2.length), "maxOutputBytes");
           const bytes8 = Buffer.from(`${text4}${suffix2}`);
           if (bytes8.byteLength > remaining) throw new JqLimitError("maxOutputBytes");
           budget.outputBytes += bytes8.byteLength;
@@ -30315,6 +30448,9 @@ function parse6(args) {
         return output3;
       };
       switch (flag) {
+        case "help":
+          result2.help = true;
+          break;
         case "e":
         case "regexp":
           result2.explicitPatterns = true;
@@ -30560,7 +30696,7 @@ function parse6(args) {
     }
   }
   if (result2.before > 1e5 || result2.after > 1e5) throw new SearchError("context limit exceeded");
-  if (result2.mode !== "files" && !result2.explicitPatterns) {
+  if (!result2.help && result2.mode !== "files" && !result2.explicitPatterns) {
     const pattern = operands.shift();
     if (pattern === void 0) throw new SearchError("a search pattern is required");
     result2.patterns.push(pattern);
@@ -31154,6 +31290,65 @@ function createRgCommand(executor, options3 = {}) {
         try {
           const limits = new Limits(context2, options3);
           args = parse6(context2.args);
+          if (args.help) {
+            await limits.output(Buffer.from(`Usage: rg [OPTIONS] PATTERN [PATH ...]
+Search files for PATTERN. PATH - reads standard input.
+Default input depends on shell configuration.
+
+  -e, --regexp=PATTERN     Add a pattern (repeatable)
+  -f, --file=FILE          Read patterns from FILE
+  -F, --fixed-strings      Use fixed strings
+  -i, --ignore-case        Ignore case distinctions
+  -s, --case-sensitive     Match case sensitively
+  -S, --smart-case         Infer case sensitivity from the pattern
+  -v, --invert-match       Select nonmatching lines
+  -w, --word-regexp        Match whole words
+  -x, --line-regexp        Match whole lines
+  -n, --line-number        Print line numbers
+  -N, --no-line-number     Suppress line numbers
+  -H, --with-filename      Print filenames
+  -I, --no-filename        Suppress filenames
+  -o, --only-matching      Print matching parts
+  -l, --files-with-matches Print filenames with matches
+      --files-without-match Print filenames without matches
+      --files             List files without searching
+  -c, --count              Print matching line counts
+      --count-matches     Print match counts
+      --json              Emit JSON events
+  -q, --quiet              Suppress normal output
+  -g, --glob=GLOB          Include or exclude paths (repeatable)
+      --iglob=GLOB        Case-insensitive glob
+  -t, --type=TYPE          Include a file type
+  -T, --type-not=TYPE      Exclude a file type
+  -., --hidden             Search hidden files
+  -L, --follow             Follow symbolic links
+      --no-ignore         Disable ignore-file filtering
+  -u, --unrestricted       Relax ignore, hidden and binary filtering (repeatable)
+  -a, --text               Search binary files as text
+  -A, --after-context=NUM  Print NUM lines after matches
+  -B, --before-context=NUM Print NUM lines before matches
+  -C, --context=NUM        Print NUM lines before and after matches
+  -m, --max-count=NUM      Limit matching lines per file
+      --max-depth=NUM     Limit directory traversal depth (maximum 128)
+      --column            Print columns
+  -b, --byte-offset        Print byte offsets
+  -0, --null               NUL-terminate filenames
+      --null-data         Use NUL-delimited records
+      --crlf              Handle CRLF line endings
+      --heading           Group output by filename
+      --sort=path         Sort paths
+      --color=never       Disable color
+      --help              Display this help and exit
+      --                  End options
+
+Exit status: 0 when a match is found, 1 when none is found, 2 on error.
+Regular expression support depends on the configured regex executor.
+The default supports UTF-8 literals and bounded ASCII regular expressions.
+Regex operators: . ^ $ [...] (...) | * + ? {n,m}; -F treats patterns literally.
+Word/case flags and extended regex syntax require a configured executor.
+`));
+            return { exitCode: 0 };
+          }
           if (args.mode !== "files" && args.patternFiles.includes("-") && args.paths.includes("-")) {
             throw new SearchError("cannot search stdin while also reading patterns from stdin");
           }
@@ -31211,7 +31406,51 @@ var maxPatternCount = 1024;
 function createGrepCommands(executor) {
   return [{ name: "grep", filesystemRequirements: grepRequirements, execute: (context2) => withRegexSession(context2, executor, async (session) => {
     try {
-      const parsed = options2(context2.args, "EFivnclLqhHowxae:f:m:sz", { "extended-regexp": "E", "fixed-strings": "F", "ignore-case": "i", "invert-match": "v", "line-number": "n", count: "c", "files-with-matches": "l", "files-without-match": "L", quiet: "q", silent: "q", "no-filename": "h", "with-filename": "H", "only-matching": "o", "word-regexp": "w", "line-regexp": "x", regexp: "e", file: "f", "max-count": "m", "no-messages": "s", text: "a", "null-data": "z" });
+      const contextLengths = /* @__PURE__ */ new Map();
+      const parsed = options2(context2.args, "EFivnclLqhHowxae:f:m:szA:B:C:", { help: false, "extended-regexp": "E", "fixed-strings": "F", "ignore-case": "i", "invert-match": "v", "line-number": "n", count: "c", "files-with-matches": "l", "files-without-match": "L", quiet: "q", silent: "q", "no-filename": "h", "with-filename": "H", "only-matching": "o", "word-regexp": "w", "line-regexp": "x", regexp: "e", file: "f", "max-count": "m", "no-messages": "s", text: "a", "null-data": "z", "after-context": "A", "before-context": "B", context: "C" }, false, void 0, (key, index, offset) => {
+        if (!["A", "B", "C"].includes(key)) return;
+        const text4 = context2.args[index].slice(offset);
+        try {
+          contextLengths.set(key, integer2(text4));
+        } catch {
+          throw new UsageError(`${text4}: invalid context length argument`);
+        }
+      });
+      if (parsed.flags.has("help")) {
+        await output(context2, `Usage: grep [OPTION]... PATTERN [FILE]...
+Print lines matching PATTERN. With no FILE, or FILE -, read standard input.
+
+  -E, --extended-regexp    Use extended regular expressions
+  -F, --fixed-strings      Use fixed strings
+  -e, --regexp=PATTERN     Add a pattern (repeatable)
+  -f, --file=FILE          Read patterns from FILE
+  -i, --ignore-case        Ignore case distinctions
+  -v, --invert-match       Select nonmatching lines
+  -w, --word-regexp        Match whole words
+  -x, --line-regexp        Match whole lines
+  -n, --line-number        Print line numbers
+  -H, --with-filename      Print filenames
+  -h, --no-filename        Suppress filenames
+  -o, --only-matching      Print only matching parts
+  -c, --count              Print matching line counts
+  -l, --files-with-matches Print filenames with matches
+  -L, --files-without-match Print filenames without matches
+  -q, --quiet, --silent    Suppress normal output
+  -m, --max-count=NUM      Stop after NUM selected lines per file
+  -A, --after-context=NUM  Print NUM lines after selected lines
+  -B, --before-context=NUM Print NUM lines before selected lines
+  -C, --context=NUM        Print NUM lines before and after selected lines
+  -s, --no-messages        Suppress file error messages
+  -a, --text               Process input as text
+  -z, --null-data          Use NUL-delimited records
+      --help              Display this help and exit
+      --                  End options
+
+Exit status: 0 when a line is selected, 1 when none is selected, 2 on error.
+Regular expression support depends on the configured regex executor.
+`);
+        return { exitCode: 0 };
+      }
       let positionalPattern;
       if (!parsed.flags.has("e") && !parsed.flags.has("f")) {
         if (!parsed.operands.length) throw new UsageError("missing pattern");
@@ -31273,13 +31512,30 @@ function createGrepCommands(executor) {
       const batchSize = Number.isFinite(maxCount) || parsed.flags.has("q") || parsed.flags.has("l") || parsed.flags.has("L") ? 1 : 128;
       const delimiter = parsed.flags.has("z") ? "\0" : "\n";
       const extractMatches = parsed.flags.has("o") && !["c", "q", "l", "L", "v"].some((flag) => parsed.flags.has(flag));
+      const displayLines = !["c", "q", "l", "L"].some((flag) => parsed.flags.has(flag));
+      const withContext = contextLengths.size > 0 && displayLines && !(parsed.flags.has("o") && parsed.flags.has("v"));
+      const before = withContext ? contextLengths.get("B") ?? contextLengths.get("C") ?? 0 : 0;
+      const after = withContext ? contextLengths.get("A") ?? contextLengths.get("C") ?? 0 : 0;
+      let emittedGroup = false;
       let anySelected = false;
       let failed = false;
       for (const name2 of names) {
         let count2 = 0;
         let number8 = 0;
+        let lastCovered = 0;
+        let remainingAfter = 0;
+        let pendingBytes = 0;
+        const pending = /* @__PURE__ */ new Map();
         const named2 = name2 === "-" ? "(standard input)" : name2;
-        const prefix3 = (lineNumber = false) => `${!parsed.flags.has("h") && (parsed.flags.has("H") || names.length > 1) ? `${named2}:` : ""}${lineNumber && parsed.flags.has("n") ? `${number8}:` : ""}`;
+        const prefix3 = (lineNumber = false, position = number8, separator = ":") => `${!parsed.flags.has("h") && (parsed.flags.has("H") || names.length > 1) ? `${named2}${separator}` : ""}${lineNumber && parsed.flags.has("n") ? `${position}${separator}` : ""}`;
+        const emitContext = async (line, position) => {
+          if (!parsed.flags.has("o")) {
+            await output(context2, prefix3(true, position, "-"));
+            await output(context2, line.bytes);
+            await output(context2, delimiter);
+          }
+          lastCovered = position;
+        };
         try {
           const available2 = new AvailableRecords(parsed.flags.has("z") ? 0 : 10, bufferLimit);
           const source2 = name2 === "-" ? input(context2) : requiredFileInput(context2, grepRequirements, "file", name2, bufferLimit);
@@ -31290,12 +31546,40 @@ function createGrepCommands(executor) {
               context2.signal.throwIfAborted();
               number8++;
               const found = results[index];
-              if (found.length > 0 === parsed.flags.has("v")) continue;
+              const selected = count2 < maxCount && found.length > 0 !== parsed.flags.has("v");
+              if (!selected) {
+                if (remainingAfter > 0) {
+                  await emitContext(line, number8);
+                  remainingAfter--;
+                  if (count2 >= maxCount && remainingAfter === 0) break records;
+                } else if (before > 0) {
+                  if (pending.size >= before) {
+                    const oldest = pending.keys().next().value;
+                    pendingBytes -= pending.get(oldest).bytes.length + 1;
+                    pending.delete(oldest);
+                  }
+                  const size = line.bytes.length + 1;
+                  if (size > bufferLimit - pendingBytes) throw new UsageError(`context byte limit exceeded (${bufferLimit} bytes)`);
+                  pending.set(number8, { bytes: Uint8Array.from(line.bytes), terminated: line.terminated });
+                  pendingBytes += size;
+                }
+                continue;
+              }
               count2++;
               if (!parsed.flags.has("L")) anySelected = true;
               if (parsed.flags.has("q")) return { exitCode: 0 };
               if (parsed.flags.has("l") || parsed.flags.has("L")) break records;
               if (!parsed.flags.has("c")) {
+                if (withContext) {
+                  const first = pending.keys().next().value ?? number8;
+                  if (emittedGroup && (lastCovered === 0 || first > lastCovered + 1)) await output(context2, "--\n");
+                  for (const [position, previous] of pending) await emitContext(previous, position);
+                  pending.clear();
+                  pendingBytes = 0;
+                  remainingAfter = after;
+                  lastCovered = number8;
+                  emittedGroup = true;
+                }
                 if (parsed.flags.has("o")) {
                   if (!parsed.flags.has("v")) {
                     let end = -1;
@@ -31313,7 +31597,7 @@ function createGrepCommands(executor) {
                   await output(context2, delimiter);
                 }
               }
-              if (count2 >= maxCount) break records;
+              if (count2 >= maxCount && remainingAfter === 0) break records;
             }
           }
           if (parsed.flags.has("l") && count2 > 0 || parsed.flags.has("L") && count2 === 0) {
@@ -37886,6 +38170,7 @@ async function parseOptions2(context2, limits) {
       if (values3.has(flag) && value2 === void 0) value2 = context2.args[++index];
       if (values3.has(flag) && value2 === void 0) fail2(`missing argument for --${name2}`);
       if (!values3.has(flag) && value2 !== void 0) fail2(`option --${name2} does not take an argument`);
+      if (flag === "help") return "help";
       await apply(flag, value2);
     } else if (!end && (argument2.startsWith("-") && argument2 !== "-" || index === 0 && /^[ctxzvfCT]+$/u.test(argument2))) {
       const old = !argument2.startsWith("-");
@@ -43621,6 +43906,33 @@ function createTarCommand(options3 = {}) {
     const context2 = { ...original, signal };
     try {
       const parsed = await parseOptions2(context2, limits);
+      if (parsed === "help") {
+        await writeBytes(context2.stdout, Buffer.from(`Usage: tar [OPTION]... [FILE]...
+Create, list or extract USTAR/PAX archives in the virtual filesystem.
+
+  -c, --create             Create an archive
+  -t, --list               List archive members
+  -x, --extract, --get      Extract archive members
+  -f, --file=ARCHIVE        Use ARCHIVE (default - for standard input/output)
+  -z, --gzip               Use gzip compression
+  -v, --verbose            List processed members
+  -C, --directory=DIR      Change directory for subsequent operands
+  -T, --files-from=FILE    Read filenames from FILE (- for standard input)
+      --null              Read NUL-delimited filenames; implies verbatim names
+      --no-null           Read newline-delimited filenames
+      --verbatim-files-from Treat file-list entries as literal filenames
+      --no-verbatim-files-from Enable supported file-list directory options
+      --exclude=PATTERN   Exclude paths (place before source operands)
+      --strip-components=NUM Remove leading components when reading archives
+      --format=FORMAT     Create pax (default), posix or ustar archives
+      --help              Display this help and exit
+      --                  End options; remaining arguments are filenames
+
+Exactly one of -c, -t or -x is required for archive operations.
+Examples: tar cf archive.tar file; tar tf archive.tar; tar xf archive.tar -C directory
+`), signal);
+        return { exitCode: 0 };
+      }
       const budget = new Budget18(context2, limits);
       if (parsed.mode === "c") {
         const prepared = await manifest(context2, parsed, budget);
@@ -87918,4 +88230,4 @@ export {
   isAbsolutePath3 as isAbsolutePath,
   posixPath2 as posixPath
 };
-//# sourceMappingURL=chunk-54JM3XZC.js.map
+//# sourceMappingURL=chunk-LYH24BKM.js.map