@poe-platform/safe-bash 0.1.799 → 0.1.800

package/dist/safe-bash-command-pdftk/index.js

@@ -997,11 +997,18 @@ function attachFilesToDocument(doc, filePaths, files, toPageSpec) {
     }
   }
 }
+function attachmentBasename(name) {
+  const leaf = name.split("/").at(-1).split("\\").at(-1);
+  if (!leaf || leaf === "." || leaf === ".." || leaf.includes("\0")) {
+    throw new Error("Invalid embedded attachment filename");
+  }
+  return leaf;
+}
 function unpackFilesFromDocument(doc, outDir, files) {
   const cleanDir = outDir.endsWith("/") ? outDir.slice(0, -1) : outDir;
   const writeSpecDict = (specDict, fallbackName = "attachment.bin") => {
     const ufNode = doc.cos.resolve(dictGet(specDict, "UF") ?? dictGet(specDict, "F"));
-    const fileName = ufNode?.kind === "string" ? decodePdfString(ufNode) : fallbackName;
+    const fileName = attachmentBasename(ufNode?.kind === "string" ? decodePdfString(ufNode) : fallbackName);
     const efDict = doc.cos.resolveDict(dictGet(specDict, "EF"));
     const fStream = efDict ? doc.cos.resolve(
       dictGet(efDict, "UF") ?? dictGet(efDict, "F") ?? dictGet(efDict, "DOS") ?? dictGet(efDict, "Mac") ?? dictGet(efDict, "Unix")
@@ -1829,11 +1836,29 @@ async function executePdftk(context) {
       }
       vfsFiles.set("-", buf);
     }
-    for (const token of argv) {
+    const inputPaths = [];
+    let operandIndex = 0;
+    while (operandIndex < argv.length && !PDFTK_OPERATIONS.has(argv[operandIndex].toLowerCase())) {
+      const token = argv[operandIndex++];
+      const eq = token.indexOf("=");
+      inputPaths.push(eq > 0 ? token.slice(eq + 1) : token);
+    }
+    while (argv[operandIndex]?.toLowerCase() === "input_pw") {
+      operandIndex++;
+      while (operandIndex < argv.length && !PDFTK_OPERATIONS.has(argv[operandIndex].toLowerCase())) operandIndex++;
+    }
+    const operation = argv[operandIndex++]?.toLowerCase();
+    if (["update_info", "update_info_utf8", "fill_form", "background", "multibackground", "stamp", "multistamp"].includes(operation ?? "")) {
+      if (argv[operandIndex]) inputPaths.push(argv[operandIndex]);
+    } else if (operation === "attach_files") {
+      while (operandIndex < argv.length && !PDFTK_OPERATIONS.has(argv[operandIndex].toLowerCase())) {
+        const token = argv[operandIndex++];
+        if (token.toLowerCase() === "to_page") operandIndex++;
+        else inputPaths.push(token);
+      }
+    }
+    for (const filePath of new Set(inputPaths)) {
       if (++cooperativeWork % 64 === 0) await yieldTurn(context.signal);
-      if (token.startsWith("-") && token !== "-") continue;
-      const eqIdx = token.indexOf("=");
-      const filePath = eqIdx > 0 ? token.slice(eqIdx + 1) : token;
       if (filePath === "-") continue;
       try {
         const bytes = await context.fs.readFile(resolveVfsPath(filePath), { signal: invocation.signal });
@@ -1863,12 +1888,15 @@ async function executePdftk(context) {
       if (key !== "-" && existingSnap.get(key) !== val) {
         chargeBytes(val.byteLength);
         const abs = resolveVfsPath(key);
-        const parentDir = abs.slice(0, abs.lastIndexOf("/")) || "/";
         try {
-          await context.fs.mkdir(parentDir, { recursive: true, signal: invocation.signal });
-        } catch {
+          await writeFileOutput(context, val, (data) => context.fs.writeFile(abs, data, { signal: invocation.signal }));
+        } catch (error) {
+          invocation.signal.throwIfAborted();
+          if (!(error instanceof Error) || !("code" in error)) throw error;
+          await writeBytes(context.stderr, new TextEncoder().encode(`Error: Failed to open output file '${key}': ${error.code}.
+`), invocation.signal);
+          return { exitCode: 1 };
         }
-        await writeFileOutput(context, val, (data) => context.fs.writeFile(abs, data, { signal: invocation.signal }));
       }
     }
     return { exitCode: res.exitCode };

package/dist/safe-bash-command-pdftoppm/index.js

@@ -42,6 +42,8 @@ var VALUE_FLAGS = /* @__PURE__ */ new Set([
   "-freetype",
   "-jpegopt"
 ]);
+var INTEGER_FLAGS = /* @__PURE__ */ new Set(["-scale-to", "-scale-to-x", "-scale-to-y", "-f", "-l", "-x", "-y", "-W", "-H", "-sz", "-setpageno"]);
+var RESOLUTION_FLAGS = /* @__PURE__ */ new Set(["-r", "-rx", "-ry"]);
 function extractPdftoppmPositionals(argv) {
   const pos = [];
   for (let i = 0; i < argv.length; i++) {
@@ -96,6 +98,24 @@ function* runPdftoppmCliSteps(argv, files, options = {}) {
     if (++cooperativeWork % 64 === 0)
       yield;
     const arg = argv[i];
+    if (VALUE_FLAGS.has(arg)) {
+      const value = argv[i + 1];
+      if (value === void 0) {
+        return { exitCode: 99, stdout: "", stderr: `Missing value for '${arg}'
+` };
+      }
+      const integer = INTEGER_FLAGS.has(arg);
+      const resolution = RESOLUTION_FLAGS.has(arg);
+      if (integer || resolution) {
+        const unsigned = value.startsWith("+") || value.startsWith("-") ? value.slice(1) : value;
+        const validInteger = [...unsigned].every((char) => char >= "0" && char <= "9");
+        const validResolution = [...unsigned].every((char) => "0123456789.eE+-".includes(char)) && (Number.isFinite(Number(value)) || unsigned === "" || unsigned === ".");
+        if (integer ? !validInteger : !validResolution) {
+          return { exitCode: 99, stdout: "", stderr: `Bad '${arg}' value on command line
+` };
+        }
+      }
+    }
     if (arg === "-v" || arg === "--version") {
       return { exitCode: 0, stdout: "pdftoppm version 24.08.0\n", stderr: "" };
     }
@@ -245,10 +265,13 @@ function* runPdftoppmCliSteps(argv, files, options = {}) {
       password = argv[++i] ?? "";
     } else if (!arg.startsWith("-") || arg === "-") {
       positionals.push(arg);
+    } else {
+      return { exitCode: 99, stdout: "", stderr: `Unknown option '${arg}'
+` };
     }
   }
   const inputPath = positionals[0] ?? (files.has("-") ? "-" : void 0);
-  if (!inputPath) {
+  if (!inputPath || positionals.length > 2) {
     return { exitCode: 99, stdout: "", stderr: "Usage: pdftoppm [options] [PDF-file [PPM-root]]\n" };
   }
   const pdfBytes = files.get(inputPath);
@@ -256,6 +279,9 @@ function* runPdftoppmCliSteps(argv, files, options = {}) {
     return { exitCode: 1, stdout: "", stderr: quiet ? "" : `I/O Error: Couldn't open file '${inputPath}'
 ` };
   }
+  if (pdfBytes.byteLength === 0) {
+    return { exitCode: 1, stdout: "", stderr: quiet ? "" : "Syntax Error: Document stream is empty\n" };
+  }
   let doc;
   try {
     doc = PdfDocument.load(pdfBytes, password ? { password } : void 0);
@@ -432,18 +458,16 @@ async function executePdftoppm(context) {
         total += chunk.byteLength;
         chargeBytes(chunk.byteLength);
       }
-      if (total > 0) {
-        const buf = new Uint8Array(total);
-        let off = 0;
-        for (const c of chunks) {
-          if (++cooperativeWork % 64 === 0) await yieldTurn(context.signal);
-          buf.set(c, off);
-          off += c.byteLength;
-        }
-        vfsFiles.set("-", buf);
+      const buf = new Uint8Array(total);
+      let off = 0;
+      for (const c of chunks) {
+        if (++cooperativeWork % 64 === 0) await yieldTurn(context.signal);
+        buf.set(c, off);
+        off += c.byteLength;
       }
+      vfsFiles.set("-", buf);
     }
-    for (const token of positionals) {
+    for (const token of positionals.slice(0, 1)) {
       if (++cooperativeWork % 64 === 0) await yieldTurn(context.signal);
       if (token === "-") continue;
       try {
@@ -470,12 +494,15 @@ async function executePdftoppm(context) {
       if (++cooperativeWork % 64 === 0) await yieldTurn(context.signal);
       if (key !== "-" && existingSnap.get(key) !== val) {
         const abs = resolveVfsPath(key);
-        const parentDir = abs.slice(0, abs.lastIndexOf("/")) || "/";
         try {
-          await context.fs.mkdir(parentDir, { recursive: true, signal: invocation.signal });
-        } catch {
+          await writeFileOutput(context, val, (data) => context.fs.writeFile(abs, data, { signal: invocation.signal }));
+        } catch (error) {
+          invocation.signal.throwIfAborted();
+          if (!(error instanceof Error) || !("code" in error)) throw error;
+          await writeBytes(context.stderr, new TextEncoder().encode(`Could not write image to ${key}; exiting
+`), invocation.signal);
+          return { exitCode: 1 };
         }
-        await writeFileOutput(context, val, (data) => context.fs.writeFile(abs, data, { signal: invocation.signal }));
       }
     }
     return { exitCode: res.exitCode };
@@ -862,7 +889,7 @@ function createPdftocairoCommand(options = {}) {
               vfsFiles.set("-", buf);
             }
           }
-          for (const token of positionals) {
+          for (const token of positionals.slice(0, 1)) {
             if (++cooperativeWork % 64 === 0) await yieldTurn(context2.signal);
             if (token === "-") continue;
             try {
@@ -889,12 +916,15 @@ function createPdftocairoCommand(options = {}) {
             if (++cooperativeWork % 64 === 0) await yieldTurn(context2.signal);
             if (key !== "-" && existingSnap.get(key) !== val) {
               const abs = resolveVfsPath(key);
-              const parentDir = abs.slice(0, abs.lastIndexOf("/")) || "/";
               try {
-                await context2.fs.mkdir(parentDir, { recursive: true, signal: invocation.signal });
-              } catch {
+                await writeFileOutput(context2, val, (data) => context2.fs.writeFile(abs, data, { signal: invocation.signal }));
+              } catch (error) {
+                invocation.signal.throwIfAborted();
+                if (!(error instanceof Error) || !("code" in error)) throw error;
+                await writeBytes(context2.stderr, new TextEncoder().encode(`Error opening output file ${key}
+`), invocation.signal);
+                return { exitCode: 2 };
               }
-              await writeFileOutput(context2, val, (data) => context2.fs.writeFile(abs, data, { signal: invocation.signal }));
             }
           }
           return { exitCode: res.exitCode };

package/dist/safe-bash-command-pdftotext/index.js

@@ -1272,7 +1272,7 @@ async function pdftohtml(context) {
         vfsFiles.set("-", buf);
       }
     }
-    for (const token of argv) {
+    for (const token of inputOperand && inputOperand !== "-" ? [inputOperand] : []) {
       if (++cooperativeWork % 64 === 0) await yieldTurn(context.signal);
       if (token.startsWith("-") && token !== "-") continue;
       try {
@@ -1299,7 +1299,15 @@ async function pdftohtml(context) {
       if (existingSnap.get(key) !== val) {
         chargeBytes(val.byteLength);
         const abs = resolveVfsPath(key);
-        await writeFileOutput(context, val, (data) => context.fs.writeFile(abs, data, { signal: invocation.signal }));
+        try {
+          await writeFileOutput(context, val, (data) => context.fs.writeFile(abs, data, { signal: invocation.signal }));
+        } catch (error) {
+          invocation.signal.throwIfAborted();
+          if (!(error instanceof Error) || !("code" in error)) throw error;
+          await writeBytes(context.stderr, new TextEncoder().encode(`I/O Error: Couldn't open html file '${key}'
+`), invocation.signal);
+          return { exitCode: 0 };
+        }
       }
     }
     return { exitCode: res.exitCode };

package/dist/safe-bash-command-pptx/index.d.ts

@@ -24,10 +24,10 @@ export interface PptxLimits {
     readonly maxArgumentBytes: number;
 }
 export interface PptxCommandsOptions {
-    readonly engine: PptxCommandEngine;
+    readonly engine?: PptxCommandEngine;
     readonly replace?: boolean;
     readonly limits?: Partial<PptxLimits>;
 }
-export declare function createPptxCommand(options: PptxCommandsOptions): CommandDefinition;
-export declare function createPptxCommands(options: PptxCommandsOptions): readonly CommandDefinition[];
-export declare function pptxCommands(options: PptxCommandsOptions): VirtualShellPlugin;
+export declare function createPptxCommand(options?: PptxCommandsOptions): CommandDefinition;
+export declare function createPptxCommands(options?: PptxCommandsOptions): readonly CommandDefinition[];
+export declare function pptxCommands(options?: PptxCommandsOptions): VirtualShellPlugin;

package/dist/safe-bash-command-pptx/index.js

@@ -1,3 +1,9 @@
+import {
+  createPptxCommandEngine
+} from "../safe-bash/command-chunks/chunk-AI5JAXQF.js";
+import "../safe-bash/command-chunks/chunk-6X2OX6IJ.js";
+import "../safe-bash/command-chunks/chunk-5LU4UCBR.js";
+import "../safe-bash/command-chunks/chunk-RDV7UCYZ.js";
 import {
   init_buffer
 } from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
@@ -10,14 +16,14 @@ import { writeFileOutput } from "../safe-bash-contracts/filesystem-output.js";
 import { compareObservedEntries } from "../safe-bash-contracts/filesystem-identity.js";
 import { pathOf } from "../safe-bash-io-engine/internal.js";
 import { inputRequirements } from "../safe-bash-io-engine/portable-requirements.js";
-function createPptxCommand(options) {
-  if (!options?.engine || typeof options.engine.execute !== "function") throw new TypeError("An explicit pptx command engine is required.");
+function createPptxCommand(options = {}) {
+  if (options.engine !== void 0 && typeof options.engine.execute !== "function") throw new TypeError("An explicit pptx command engine is required.");
   if (options.replace !== void 0 && typeof options.replace !== "boolean") throw new TypeError("pptx replace must be boolean");
   const maxArgumentBytes = options.limits?.maxArgumentBytes ?? Infinity;
   if (maxArgumentBytes !== Infinity && (!Number.isSafeInteger(maxArgumentBytes) || maxArgumentBytes < 0)) {
     throw new RangeError("maxArgumentBytes must be a nonnegative safe integer or Infinity");
   }
-  const engine = options.engine;
+  const engine = options.engine ?? createPptxCommandEngine();
   return { name: "pptx", filesystemRequirements: inputRequirements, async execute(context) {
     const arguments_ = getCommandArguments(context);
     let argumentBytes = 0;
@@ -126,10 +132,10 @@ function createPptxCommand(options) {
     return { exitCode: result.exitCode };
   } };
 }
-function createPptxCommands(options) {
+function createPptxCommands(options = {}) {
   return [createPptxCommand(options)];
 }
-function pptxCommands(options) {
+function pptxCommands(options = {}) {
   const commands = createPptxCommands(options);
   const replace = options.replace ?? false;
   return { name: "pptx-commands", setup(host) {

package/dist/safe-bash-command-pr/command.js

@@ -1,9 +1,9 @@
 import {
   createPrCommand
-} from "../safe-bash/command-chunks/chunk-B5BKA5WH.js";
+} from "../safe-bash/command-chunks/chunk-B5TAOCKD.js";
+import "../safe-bash/command-chunks/chunk-CPPGTBZF.js";
 import "../safe-bash/command-chunks/chunk-QAKKSRNV.js";
 import "../safe-bash/command-chunks/chunk-QNXI2UP6.js";
-import "../safe-bash/command-chunks/chunk-CPPGTBZF.js";
 import "../safe-bash/command-chunks/chunk-N5FGCXQJ.js";
 import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
 export {

package/dist/safe-bash-command-pr/index.js

@@ -1,6 +1,9 @@
 import {
   createPrCommand
-} from "../safe-bash/command-chunks/chunk-B5BKA5WH.js";
+} from "../safe-bash/command-chunks/chunk-B5TAOCKD.js";
+import {
+  parseOptions
+} from "../safe-bash/command-chunks/chunk-CPPGTBZF.js";
 import {
   Formatter
 } from "../safe-bash/command-chunks/chunk-QAKKSRNV.js";
@@ -8,9 +11,6 @@ import {
   Lifecycle,
   Reader
 } from "../safe-bash/command-chunks/chunk-QNXI2UP6.js";
-import {
-  parseOptions
-} from "../safe-bash/command-chunks/chunk-CPPGTBZF.js";
 import {
   Budget,
   settings

package/dist/safe-bash-command-qpdf/index.js

@@ -2391,15 +2391,20 @@ async function qpdf(context, options = {}) {
       argv.splice(i, 1, ...args);
       i += args.length - 1;
     }
-    for (const token of argv) {
+    const parsed = parseQpdfArguments(argv);
+    const inputs = parsed.options ? [
+      parsed.options.inputFile,
+      ...parsed.options.updateFromJsonFiles,
+      ...[
+        ...parsed.options.pageSpecs,
+        ...parsed.options.stampSpecs,
+        ...parsed.options.addAttachmentSpecs,
+        ...parsed.options.copyAttachmentsSpecs
+      ].map((spec) => spec.file)
+    ] : [];
+    for (const candidate of new Set(inputs)) {
       await yieldTurn(invocation.signal);
-      invocation.signal.throwIfAborted();
-      let candidate = token;
-      if (token.startsWith("--overlay=") || token.startsWith("--underlay=") || token.startsWith("--add-attachment=") || token.startsWith("--copy-attachments-from=") || token.startsWith("--update-from-json=")) {
-        candidate = token.slice(token.indexOf("=") + 1);
-      } else if (token.startsWith("-") || token === "--" || token === ".") {
-        continue;
-      }
+      if (!candidate || candidate === "-" || candidate === ".") continue;
       const abs = resolveVfsPath(candidate);
       let bytes;
       try {
@@ -2413,14 +2418,14 @@ async function qpdf(context, options = {}) {
     }
     if (argv.includes("--json-input") || argv.some((t) => t.startsWith("--update-from-json="))) {
       for (const fileBytes of [...vfsFiles.values()]) {
-        let parsed;
+        let parsed2;
         try {
-          parsed = JSON.parse(new TextDecoder().decode(fileBytes));
+          parsed2 = JSON.parse(new TextDecoder().decode(fileBytes));
         } catch {
           continue;
         }
-        if (!parsed || typeof parsed !== "object") continue;
-        const objs = Array.isArray(parsed.qpdf) && typeof parsed.qpdf[1] === "object" ? parsed.qpdf[1] : typeof parsed.objects === "object" && parsed.objects !== null ? parsed.objects : void 0;
+        if (!parsed2 || typeof parsed2 !== "object") continue;
+        const objs = Array.isArray(parsed2.qpdf) && typeof parsed2.qpdf[1] === "object" ? parsed2.qpdf[1] : typeof parsed2.objects === "object" && parsed2.objects !== null ? parsed2.objects : void 0;
         if (!objs) continue;
         for (const entry of Object.values(objs)) {
           if (typeof entry !== "object" || entry === null || !("stream" in entry)) continue;
@@ -2473,7 +2478,15 @@ async function qpdf(context, options = {}) {
           await writeBytes(stdout.output, fileBytes, invocation.signal);
         } else {
           const abs = resolveVfsPath(fileKey);
-          await writeFileOutput(context, fileBytes, (data) => context.fs.writeFile(abs, data, { signal: invocation.signal }));
+          try {
+            await writeFileOutput(context, fileBytes, (data) => context.fs.writeFile(abs, data, { signal: invocation.signal }));
+          } catch (error) {
+            invocation.signal.throwIfAborted();
+            if (!(error instanceof Error) || !("code" in error)) throw error;
+            await writeBytes(context.stderr, new TextEncoder().encode(`qpdf: open ${fileKey}: ${error.code === "ENOENT" ? "No such file or directory" : error.code}
+`), invocation.signal);
+            return { exitCode: 2 };
+          }
         }
       }
     }

package/dist/safe-bash-command-rg/index.d.ts

@@ -13,3 +13,4 @@ export interface RgLimits {
 export declare function createRgCommands(options?: SearchOptions): readonly CommandDefinition[];
 export declare function rgCommands(options?: SearchOptions): VirtualShellPlugin;
 export { createRgCommand as rgCommand };
+export * from "./sync.js";

package/dist/safe-bash-command-rg/index.js

@@ -1,6 +1,6 @@
 import {
   createRgCommand
-} from "../safe-bash/command-chunks/chunk-CU5RLO62.js";
+} from "../safe-bash/command-chunks/chunk-GLOZX57Y.js";
 import {
   init_buffer
 } from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
@@ -9,6 +9,226 @@ import {
 init_buffer();
 import { RegexExecutor } from "../safe-bash-regex-engine/execution/portable.js";
 import { createBoundedRegexProvider } from "../safe-bash-regex-engine/execution/bounded-provider.js";
+
+// packages/safe-bash-command-rg/src/sync.ts
+init_buffer();
+var syncRgDecoder = new TextDecoder("utf-8", { fatal: false });
+function evalSyncRg(stdinBytes, args, readFile, allowNullBytes = false) {
+  let fixed = false;
+  let ignoreCase = false;
+  let smartCase = false;
+  let invert = false;
+  let countOnly = false;
+  let onlyMatching = false;
+  let wordRegexp = false;
+  let lineRegexp = false;
+  let lineNumber;
+  let withFilename;
+  let filesWithMatches = false;
+  let filesWithoutMatch = false;
+  let quiet = false;
+  let nullTerminated = false;
+  let maxCount = Infinity;
+  const patterns = [];
+  let positionalPatternConsumed = false;
+  const paths = [];
+  let endOpts = false;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (!endOpts && a === "--") {
+      endOpts = true;
+      continue;
+    }
+    if (!endOpts && (a === "-e" || a === "--regexp")) {
+      if (i + 1 >= args.length) return void 0;
+      patterns.push(args[++i]);
+      positionalPatternConsumed = true;
+      continue;
+    }
+    if (!endOpts && a.startsWith("--regexp=")) {
+      patterns.push(a.slice(9));
+      positionalPatternConsumed = true;
+      continue;
+    }
+    if (!endOpts && (a === "-r" || a === "--replace")) {
+      return void 0;
+    }
+    if (!endOpts && a.startsWith("--replace=")) {
+      return void 0;
+    }
+    if (!endOpts && (a === "-m" || a === "--max-count")) {
+      if (i + 1 >= args.length || !/^\d+$/u.test(args[i + 1])) return void 0;
+      maxCount = Number(args[++i]);
+      continue;
+    }
+    if (!endOpts && a.startsWith("--max-count=")) {
+      const v = a.slice(12);
+      if (!/^\d+$/u.test(v)) return void 0;
+      maxCount = Number(v);
+      continue;
+    }
+    if (!endOpts && a.startsWith("--") && a.length > 2) {
+      if (a === "--fixed-strings") fixed = true;
+      else if (a === "--ignore-case") {
+        ignoreCase = true;
+        smartCase = false;
+      } else if (a === "--case-sensitive") {
+        ignoreCase = false;
+        smartCase = false;
+      } else if (a === "--smart-case") {
+        smartCase = true;
+        ignoreCase = false;
+      } else if (a === "--invert-match") invert = true;
+      else if (a === "--count") countOnly = true;
+      else if (a === "--only-matching") onlyMatching = true;
+      else if (a === "--word-regexp") wordRegexp = true;
+      else if (a === "--line-regexp") lineRegexp = true;
+      else if (a === "--line-number") lineNumber = true;
+      else if (a === "--no-line-number") lineNumber = false;
+      else if (a === "--with-filename") withFilename = true;
+      else if (a === "--no-filename") withFilename = false;
+      else if (a === "--files-with-matches") filesWithMatches = true;
+      else if (a === "--files-without-match") filesWithoutMatch = true;
+      else if (a === "--quiet") quiet = true;
+      else if (a === "--null") nullTerminated = true;
+      else return void 0;
+      continue;
+    }
+    if (!endOpts && a.startsWith("-") && a.length > 1) {
+      for (let j = 1; j < a.length; j++) {
+        const ch = a[j];
+        if (ch === "F") fixed = true;
+        else if (ch === "i") {
+          ignoreCase = true;
+          smartCase = false;
+        } else if (ch === "s") {
+          ignoreCase = false;
+          smartCase = false;
+        } else if (ch === "S") {
+          smartCase = true;
+          ignoreCase = false;
+        } else if (ch === "v") invert = true;
+        else if (ch === "c") countOnly = true;
+        else if (ch === "o") onlyMatching = true;
+        else if (ch === "w") wordRegexp = true;
+        else if (ch === "x") lineRegexp = true;
+        else if (ch === "n") lineNumber = true;
+        else if (ch === "N") lineNumber = false;
+        else if (ch === "H") withFilename = true;
+        else if (ch === "I") withFilename = false;
+        else if (ch === "l") filesWithMatches = true;
+        else if (ch === "q") quiet = true;
+        else if (ch === "0") nullTerminated = true;
+        else if (ch === "e") {
+          const rest = a.slice(j + 1);
+          if (rest) patterns.push(rest);
+          else {
+            if (i + 1 >= args.length) return void 0;
+            patterns.push(args[++i]);
+          }
+          positionalPatternConsumed = true;
+          break;
+        } else if (ch === "m") {
+          const rest = a.slice(j + 1);
+          const v = rest || args[++i];
+          if (!v || !/^\d+$/u.test(v)) return void 0;
+          maxCount = Number(v);
+          break;
+        } else if (ch === "r") {
+          return void 0;
+        } else return void 0;
+      }
+      continue;
+    }
+    if (!positionalPatternConsumed) {
+      patterns.push(a);
+      positionalPatternConsumed = true;
+    } else {
+      paths.push(a);
+    }
+  }
+  if (patterns.length === 0) return void 0;
+  if (nullTerminated && (!allowNullBytes || !filesWithMatches && !filesWithoutMatch)) return void 0;
+  if (onlyMatching && (invert || countOnly || filesWithMatches || filesWithoutMatch)) return void 0;
+  const effectiveIgnoreCase = ignoreCase || smartCase && !patterns.some((p) => /[A-Z]/u.test(p));
+  const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const rawSources = [];
+  for (const pat of patterns) {
+    if (fixed) {
+      rawSources.push(escapeRegex(pat));
+    } else {
+      if (!/^[a-zA-Z0-9_ :;,=.+*?^$\-[\]()|/{}\\]+$/u.test(pat) || /\([^)]*[+*][^)]*\)[+*?]/u.test(pat)) return void 0;
+      rawSources.push(pat);
+    }
+  }
+  const combinedSource = rawSources.length === 1 ? rawSources[0] : rawSources.map((s) => `(?:${s})`).join("|");
+  const wrappedSource = lineRegexp ? `^(?:${combinedSource})$` : wordRegexp ? `(?<![a-zA-Z0-9_])(?:${combinedSource})(?![a-zA-Z0-9_])` : combinedSource;
+  let reTest;
+  let reGlobal;
+  try {
+    reTest = new RegExp(wrappedSource, effectiveIgnoreCase ? "i" : "");
+    reGlobal = new RegExp(wrappedSource, effectiveIgnoreCase ? "gi" : "g");
+  } catch {
+    return void 0;
+  }
+  const targets = paths.length > 0 ? paths : ["-"];
+  const showFile = withFilename ?? targets.length > 1;
+  const showLine = lineNumber ?? false;
+  const outLines = [];
+  let anyMatched = false;
+  for (const t of targets) {
+    const b = t === "-" ? stdinBytes : readFile ? readFile(t) : void 0;
+    if (!b || b.byteLength > 65536 || b.includes(0)) return void 0;
+    const text = syncRgDecoder.decode(b);
+    const rawLines = text.length === 0 ? [] : text.endsWith("\n") ? text.slice(0, -1).split("\n") : text.split("\n");
+    let count = 0;
+    for (let idx = 0; idx < rawLines.length; idx++) {
+      const line = rawLines[idx];
+      const ok = reTest.test(line);
+      if (invert ? !ok : ok) {
+        count++;
+        if (filesWithoutMatch) {
+          break;
+        }
+        anyMatched = true;
+        if (filesWithMatches) {
+          outLines.push(t);
+          break;
+        }
+        if (!countOnly) {
+          let prefix = "";
+          if (showFile) prefix += `${t}:`;
+          if (showLine) prefix += `${idx + 1}:`;
+          if (onlyMatching) {
+            reGlobal.lastIndex = 0;
+            let m;
+            while ((m = reGlobal.exec(line)) !== null) {
+              outLines.push(prefix + m[0]);
+              if (m[0].length === 0) reGlobal.lastIndex++;
+            }
+          } else {
+            outLines.push(prefix + line);
+          }
+        }
+        if (count >= maxCount) break;
+      }
+    }
+    if (filesWithoutMatch) {
+      if (count === 0) {
+        anyMatched = true;
+        outLines.push(t);
+      }
+    } else if (countOnly && count > 0) {
+      outLines.push(showFile ? `${t}:${count}` : String(count));
+    }
+  }
+  if (!anyMatched) return void 0;
+  if (quiet) return "";
+  const sep = nullTerminated ? "\0" : "\n";
+  return outLines.length === 0 ? "" : `${outLines.join(sep)}${sep}`;
+}
+
+// packages/safe-bash-command-rg/src/index.ts
 function createRgCommand2(options = {}) {
   const provider = options.regexExecutor === void 0 ? createBoundedRegexProvider() : options.regexExecutor;
   return createRgCommand(new RegexExecutor(provider, options.regex), options);
@@ -28,6 +248,7 @@ function rgCommands(options = {}) {
 export {
   createRgCommand2 as createRgCommand,
   createRgCommands,
+  evalSyncRg,
   createRgCommand2 as rgCommand,
   rgCommands
 };

package/dist/safe-bash-command-rg/rg-command.js

@@ -2,7 +2,7 @@ import {
   clearRgFastRunnerPool,
   createRgCommand,
   preverifyMemoryRgTree
-} from "../safe-bash/command-chunks/chunk-CU5RLO62.js";
+} from "../safe-bash/command-chunks/chunk-GLOZX57Y.js";
 import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
 export {
   clearRgFastRunnerPool,

package/dist/safe-bash-command-rg/sync.d.ts

@@ -0,0 +1 @@
+export declare function evalSyncRg(stdinBytes: Uint8Array | undefined, args: readonly string[], readFile?: (path: string) => Uint8Array | undefined, allowNullBytes?: boolean): string | undefined;