@poe-platform/safe-bash 0.1.718 → 0.1.720

package/dist/safe-bash/core.browser.js

@@ -24,7 +24,7 @@ import {
   createXmlCommands,
   defaultXmlQueryLimits,
   xmlCommands
-} from "./chunks/chunk-G5FT6GOL.js";
+} from "./chunks/chunk-RNWDFNH4.js";
 import {
   Interpreter,
   createYqCommand,
@@ -33,9 +33,10 @@ import {
   parse,
   parseJson,
   rawValues,
+  sortObjectKeys,
   stringify,
   yqCommands
-} from "./chunks/chunk-FXCEA7NR.js";
+} from "./chunks/chunk-IW6BX3VX.js";
 import {
   Budget,
   JqError,
@@ -61,7 +62,7 @@ import {
   curlCommands,
   defaultNetworkLimits,
   networkCommands
-} from "./chunks/chunk-B5Y7TH7K.js";
+} from "./chunks/chunk-NF3OGIG4.js";
 import {
   SafeJsCommandLimitError,
   createSafeJsNodeCommand,
@@ -72,7 +73,7 @@ import {
   safeJsNodeCommands,
   stringValue,
   withSignal
-} from "./chunks/chunk-4C5H4M64.js";
+} from "./chunks/chunk-M7GLXFPU.js";
 import {
   AvailableRecords,
   EreLedger,
@@ -92,7 +93,7 @@ import {
   exprMatchCeilings,
   matchEre,
   withRegexSession
-} from "./chunks/chunk-YOUOJRAP.js";
+} from "./chunks/chunk-ZHWEPWDW.js";
 import {
   openFileOutput,
   writeFileOutput
@@ -152,7 +153,7 @@ import {
 import {
   createLlmCommands,
   llmCommands
-} from "./chunks/chunk-SACGNKFN.js";
+} from "./chunks/chunk-UZUKVBCC.js";
 import {
   RecordBuffer,
   UsageError,
@@ -182,7 +183,7 @@ import {
   textOutputRequirements,
   value,
   writeDiagnostic
-} from "./chunks/chunk-N4PN6Z63.js";
+} from "./chunks/chunk-6G7AGS2B.js";
 import {
   PublicDiagnostic,
   publicDiagnosticMessage
@@ -699,6 +700,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: (escape) => {
+    unicodeErrors.push(escape);
+  } };
   do {
     const before = argument2;
     for (let offset = 0; offset < formatLength && !stopped; ) {
@@ -706,7 +712,9 @@ async function formatPrintf(context2) {
         const end = rawFormat ? rawFormat.indexOf(37, offset) : format3.indexOf("%", offset);
         const limit = end < 0 ? formatLength : end;
         const literal = rawFormat ? rawFormat.subarray(offset, limit) : format3.slice(offset, limit);
-        const escaped3 = escapeBytes(literal);
+        const escaped3 = escapeBytes(literal, false, false, unicode);
+        for (const escape of unicodeErrors.splice(0)) await writeDiagnostic(context2.stderr, `printf: missing unicode digit for \\${escape}
+`, context2.signal);
         await output(context2, escaped3.bytes);
         stopped = escaped3.stop;
         offset += literal.length;
@@ -735,7 +743,9 @@ async function formatPrintf(context2) {
       if (specifier === "b" || specifier === "s") {
         const suppliedValue = arguments_.values[suppliedIndex] ?? "";
         const raw = specifier === "b" && typeof suppliedValue === "string" ? suppliedValue : arguments_.bytes(suppliedIndex) ?? new Uint8Array();
-        const escaped3 = specifier === "b" ? escapeBytes(raw, true, true) : { bytes: raw, stop: false };
+        const escaped3 = specifier === "b" ? escapeBytes(raw, true, true, unicode) : { bytes: raw, stop: false };
+        for (const escape of unicodeErrors.splice(0)) await writeDiagnostic(context2.stderr, `printf: missing unicode digit for \\${escape}
+`, context2.signal);
         const bytes3 = escaped3.bytes.subarray(0, precision);
         const padding = " ".repeat(Math.max(0, width - bytes3.length));
         if (!flags3.includes("-")) await output(context2, padding);
@@ -4194,7 +4204,7 @@ async function* combinedInput(context2, names, state) {
     }
   }
 }
-async function prefix(context2, source2, count2, bytes3, skip) {
+async function prefix(context2, source2, count2, bytes3, skip, delimiter) {
   let remaining = count2;
   if (!remaining && !skip) return;
   for await (const chunk of source2) {
@@ -4205,7 +4215,7 @@ async function prefix(context2, source2, count2, bytes3, 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) {
@@ -4216,12 +4226,12 @@ async function prefix(context2, source2, count2, bytes3, skip) {
     }
   }
 }
-async function suffix(context2, source2, count2, bytes3, omit) {
+async function suffix(context2, source2, count2, bytes3, omit, delimiter) {
   let pending = [];
   let start = 0;
   let size = 0;
   const records5 = bytes3 ? 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();
@@ -4296,9 +4306,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 = options(follow?.args ?? args, "n:c:qv", { lines: "n", bytes: "c", quiet: "q", silent: "q", verbose: "v" });
+    const parsed = options(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 bytes3 = parsed.flags.has("c");
+    const delimiter = parsed.flags.has("z") ? 0 : 10;
     const amount = value(parsed, bytes3 ? "c" : "n") ?? "10";
     const positive = amount.startsWith("+");
     const negative = amount.startsWith("-");
@@ -4312,7 +4323,7 @@ function headTail(name2, maxTailFollowHandles = 64) {
       bytes: bytes3,
       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), bytes3, true) : suffix(target, source2, count2, bytes3, false));
+    }, maxTailFollowHandles, (target, source2) => positive ? prefix(target, source2, Math.max(0, count2 - 1), bytes3, true, delimiter) : suffix(target, source2, count2, bytes3, false, delimiter));
     await assertInputRequirements(context2, names);
     (0, command_requirements_exports.assertCommandRequirements)(context2, inspectedInputRequirements, [names.some((name3) => name3 !== "-") ? "file" : "stdin"]);
     let exitCode = 0;
@@ -4330,9 +4341,9 @@ function headTail(name2, maxTailFollowHandles = 64) {
 `);
           headerWritten = true;
         }
-        if (name2 === "head" && !negative) await prefix(context2, input(context2, file), count2, bytes3, false);
-        else if (name2 === "tail" && positive) await prefix(context2, input(context2, file), Math.max(0, count2 - 1), bytes3, true);
-        else await suffix(context2, input(context2, file), count2, bytes3, name2 === "head");
+        if (name2 === "head" && !negative) await prefix(context2, input(context2, file), count2, bytes3, false, delimiter);
+        else if (name2 === "tail" && positive) await prefix(context2, input(context2, file), Math.max(0, count2 - 1), bytes3, true, delimiter);
+        else await suffix(context2, input(context2, file), count2, bytes3, name2 === "head", delimiter);
       } catch (error) {
         await diagnostic(context2, error);
         exitCode = 1;
@@ -4401,7 +4412,26 @@ function streamCommands(maxTeeTargets = 64, maxTailFollowHandles = 64) {
   }
   return [
     define("cat", async (context2) => {
-      const parsed = options(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 = options(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")) {
@@ -12556,7 +12586,7 @@ async function execute(program, context2, files, quiet, budget, separator, outpu
               const character = pattern[offset];
               const lineEnd = character === "\n" && separator === "\n";
               const token = character === void 0 || lineEnd ? "$" : escapes2[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 = "";
               }
@@ -12717,6 +12747,14 @@ function sedCommand(options2 = {}) {
         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];
@@ -14485,7 +14523,7 @@ function argumentsFor(args, budget) {
     argumentBytes += import_buffer.Buffer.byteLength(argument2);
     if (argumentBytes > budget.limits.maxInputBytes) throw new JqLimitError("maxInputBytes");
   }
-  const options2 = { 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 options2 = { 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;
@@ -14526,10 +14564,10 @@ function argumentsFor(args, budget) {
       options2.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 flags3 = Object.hasOwn(long, argument2) ? long[argument2] : argument2.startsWith("--") ? "" : argument2.slice(1);
-      if (!flags3 || !/^[rRjcsne]+$/u.test(flags3)) throw new JqError(`unsupported option ${argument2}`, 2);
+      if (!flags3 || [...flags3].some((flag) => !"rRjcSsne".includes(flag))) throw new JqError(`unsupported option ${argument2}`, 2);
       for (const flag of flags3) {
         if (flag === "r") options2.raw = true;
         else if (flag === "R") options2.rawInput = true;
@@ -14537,6 +14575,7 @@ function argumentsFor(args, budget) {
           options2.joinOutput = true;
           options2.raw = true;
         } else if (flag === "c") options2.compact = true;
+        else if (flag === "S") options2.sortKeys = true;
         else if (flag === "s") options2.slurp = true;
         else if (flag === "n") options2.nullInput = true;
         else options2.exitStatus = true;
@@ -14662,7 +14701,8 @@ async function execute2(context2, limits) {
           if (++budget.results > limits.maxResults) throw new JqLimitError("maxResults");
           const remaining = limits.maxOutputBytes - budget.outputBytes;
           const suffix2 = options2.joinOutput ? "" : "\n";
-          const text3 = options2.raw && typeof result === "string" ? result : await stringify(result, budget, !options2.compact, Math.max(0, remaining - suffix2.length), "maxOutputBytes");
+          const output2 = options2.sortKeys ? await sortObjectKeys(result, budget) : result;
+          const text3 = options2.raw && typeof output2 === "string" ? output2 : await stringify(output2, budget, !options2.compact, Math.max(0, remaining - suffix2.length), "maxOutputBytes");
           const bytes3 = import_buffer.Buffer.from(`${text3}${suffix2}`);
           if (bytes3.byteLength > remaining) throw new JqLimitError("maxOutputBytes");
           budget.outputBytes += bytes3.byteLength;
@@ -15053,6 +15093,9 @@ function parse6(args) {
         return output2;
       };
       switch (flag) {
+        case "help":
+          result.help = true;
+          break;
         case "e":
         case "regexp":
           result.explicitPatterns = true;
@@ -15298,7 +15341,7 @@ function parse6(args) {
     }
   }
   if (result.before > 1e5 || result.after > 1e5) throw new SearchError("context limit exceeded");
-  if (result.mode !== "files" && !result.explicitPatterns) {
+  if (!result.help && result.mode !== "files" && !result.explicitPatterns) {
     const pattern = operands.shift();
     if (pattern === void 0) throw new SearchError("a search pattern is required");
     result.patterns.push(pattern);
@@ -15900,6 +15943,65 @@ function createRgCommand(executor, options2 = {}) {
         try {
           const limits = new Limits(context2, options2);
           args = parse6(context2.args);
+          if (args.help) {
+            await limits.output(import_buffer.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");
           }
@@ -15958,7 +16060,51 @@ var maxPatternCount = 1024;
 function createGrepCommands(executor) {
   return [{ name: "grep", filesystemRequirements: grepRequirements, execute: (context2) => withRegexSession(context2, executor, async (session) => {
     try {
-      const parsed = options(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 = options(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 text3 = context2.args[index].slice(offset);
+        try {
+          contextLengths.set(key, integer(text3));
+        } catch {
+          throw new UsageError(`${text3}: 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");
@@ -16020,13 +16166,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 number6 = 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") ? `${number6}:` : ""}`;
+        const prefix3 = (lineNumber = false, position = number6, 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);
@@ -16037,12 +16200,40 @@ function createGrepCommands(executor) {
               context2.signal.throwIfAborted();
               number6++;
               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, number6);
+                  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(number6, { 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 ?? number6;
+                  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 = number6;
+                  emittedGroup = true;
+                }
                 if (parsed.flags.has("o")) {
                   if (!parsed.flags.has("v")) {
                     let end = -1;
@@ -16060,7 +16251,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) {
@@ -25820,6 +26011,7 @@ async function parseOptions2(context2, limits) {
       if (values.has(flag) && value2 === void 0) value2 = context2.args[++index];
       if (values.has(flag) && value2 === void 0) fail(`missing argument for --${name2}`);
       if (!values.has(flag) && value2 !== void 0) fail(`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("-");
@@ -31590,6 +31782,33 @@ function createTarCommand(options2 = {}) {
     const context2 = { ...original, signal };
     try {
       const parsed = await parseOptions2(context2, limits);
+      if (parsed === "help") {
+        await (0, contracts_exports.writeBytes)(context2.stdout, import_buffer.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 Budget14(context2, limits);
       if (parsed.mode === "c") {
         const prepared = await manifest(context2, parsed, budget);