@poe-platform/safe-bash 0.1.799 → 0.1.801

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

@@ -0,0 +1,363 @@
+import {
+  Extraction
+} from "./chunk-NFGI5IGF.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-unzip/src/unzip.ts
+init_buffer();
+import { withInputByteBudget } from "../../safe-bash-contracts/index.js";
+import { collectBytes, dirname, readBytes, resolvePath, writeBytes } from "../../safe-bash-contracts/index.js";
+import { PublicDiagnostic, publicDiagnosticMessage } from "../../safe-bash-contracts/diagnostics.js";
+import { writeFileOutput } from "../../safe-bash-contracts/filesystem-output.js";
+import { createOutputOperation } from "../../safe-bash-contracts/output.js";
+import { byteLength, concatBytes, encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+import { bounded, Budget, checkPath, display, fail, invocationLimits, settings, text, vfsPath } from "../../safe-bash-io-engine/commands/archive/internal.js";
+import { Answers, parseArguments, Selection } from "../../safe-bash-zip-engine/unzip/arguments.js";
+import { decodeZipEntry, readZipArchive } from "../../safe-bash-zip-engine/zip-format.js";
+import { readZipPassword } from "../../safe-bash-zip-engine/zip/crypto.js";
+import { resolveZipVolumes } from "../../safe-bash-zip-engine/zip/volumes.js";
+function filtered(name) {
+  let output = "";
+  for (const character of name) {
+    const code = character.charCodeAt(0);
+    output += code < 32 ? `^${String.fromCharCode(code + 64)}` : character;
+  }
+  return output;
+}
+function padded(name) {
+  return name + " ".repeat(Math.max(0, 22 - byteLength(name)));
+}
+function date(entry) {
+  const modified = entry.modified;
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${modified.getFullYear()}-${pad(modified.getMonth() + 1)}-${pad(modified.getDate())} ${pad(modified.getHours())}:${pad(modified.getMinutes())}`;
+}
+async function comment(bytes, budget) {
+  if (!bytes.length) return;
+  const output = [];
+  let length = 0;
+  for (const byte of bytes) {
+    if (!byte) break;
+    if (byte !== 13 && byte !== 19) length += byte === 27 ? 2 : 1;
+    if (length > budget.limits.maxTextBytes - budget.textBytes) fail("text output limit exceeded");
+  }
+  for (const byte of bytes) {
+    if (!byte) break;
+    if (byte === 13 || byte === 19) continue;
+    if (byte === 27) output.push(94, 91);
+    else output.push(byte);
+  }
+  if (output.length && output.at(-1) !== 10) output.push(10);
+  const value = Uint8Array.from(output);
+  if (value.length > budget.limits.maxTextBytes - budget.textBytes) fail("text output limit exceeded");
+  budget.textBytes += value.length;
+  await writeBytes(budget.context.stdout, value, budget.context.signal);
+}
+function createUnzipCommand(options = {}) {
+  const configured = settings(options);
+  return { name: "unzip", description: "List, stream or safely extract ZIP archives in the virtual filesystem", execute: withInputByteBudget(async (original) => {
+    const limits = invocationLimits(configured, original);
+    original.signal.throwIfAborted();
+    const controller = new AbortController();
+    const context = { ...original, signal: AbortSignal.any([original.signal, controller.signal]) };
+    const extraction = new Extraction(context, limits);
+    let output;
+    let answers;
+    let closing;
+    const close = () => closing ??= (async () => {
+      controller.abort(new Error("unzip command closed"));
+      await Promise.all([extraction.close(), output?.close()]);
+      await answers?.close().catch(() => {
+      });
+    })();
+    original.registerCleanup?.(close);
+    const budget = new Budget(context, limits);
+    try {
+      const parsed = parseArguments(context, limits);
+      if (parsed.pipe) output = createOutputOperation(context, context.stdout);
+      if (parsed.pipe && parsed.destination !== void 0) await budget.output("caution:  not extracting; -d ignored\n", true);
+      const selection = new Selection(parsed.patterns, limits, context.signal, { caseInsensitive: parsed.caseInsensitive });
+      const exclusions = new Selection(parsed.exclusions, limits, context.signal, { caseInsensitive: parsed.caseInsensitive });
+      let archive = parsed.archive;
+      let archiveStat;
+      for (const candidate of [archive, `${archive}.zip`, `${archive}.ZIP`]) {
+        checkPath(candidate, limits);
+        const candidateStat = await extraction.stat(vfsPath(context.cwd, candidate));
+        if (candidateStat) {
+          archive = candidate;
+          archiveStat = candidateStat;
+          break;
+        }
+      }
+      if (!archiveStat) {
+        if (!parsed.pipe) await budget.output(`unzip:  cannot find or open ${archive}, ${archive}.zip or ${archive}.ZIP.
+`, true);
+        return { exitCode: 9 };
+      }
+      const archivePath = await extraction.operation(() => context.fs.realpath(vfsPath(context.cwd, archive), { signal: context.signal }));
+      archiveStat = await extraction.operation(() => context.fs.stat(archivePath, { signal: context.signal }));
+      if (archiveStat.type !== "file") fail("input archive is not a regular file");
+      if (!Number.isSafeInteger(archiveStat.size) || archiveStat.size < 0 || archiveStat.size > limits.maxArchiveBytes) fail("archive byte limit exceeded");
+      const bytes = await collectBytes(bounded(extraction.input(archivePath), limits.maxArchiveBytes, context.signal, limits.chunkSize), { signal: context.signal, ...Number.isFinite(limits.maxArchiveBytes) ? { maxBytes: limits.maxArchiveBytes } : {}, ...Number.isFinite(limits.maxInputMemoryBytes) ? { maxMemoryBytes: limits.maxInputMemoryBytes } : {} });
+      if ((!parsed.pipe || parsed.pipeHeaders) && !parsed.names && !parsed.quiet) await budget.output(`Archive:  ${filtered(archive)}
+`);
+      const resolved = await resolveZipVolumes({ context, limits, operation: (action) => extraction.operation(async () => action()), stat: (path) => extraction.stat(path), input: (path) => extraction.input(path) }, archivePath, bytes, options.zipHost);
+      extraction.inputVolumes = resolved.volumes ?? [];
+      const zip = await readZipArchive(resolved.bytes, limits, context.signal, resolved.disks ? { disks: resolved.disks } : { prefix: true });
+      if (parsed.archiveComment || (!parsed.pipe || parsed.pipeHeaders) && !parsed.names && !parsed.quiet) await comment(zip.comment, budget);
+      if (parsed.archiveComment) return { exitCode: 0 };
+      if (!zip.entries.length) {
+        await budget.output(`warning [${filtered(archive)}]:  zipfile is empty
+`, true);
+        return { exitCode: 1 };
+      }
+      if (parsed.names) {
+        let selected2 = 0;
+        for (const entry of zip.entries) {
+          await budget.member(entry.size);
+          checkPath(entry.name, limits);
+          if (!await selection.matches(entry.name, true)) continue;
+          if (parsed.exclusions.length && await exclusions.matches(entry.name, true)) continue;
+          await budget.output(`${filtered(entry.name)}
+`);
+          selected2++;
+        }
+        let unmatched = false;
+        for (let index = 0; index < parsed.patterns.length; index++) if (!selection.matched.has(index)) {
+          await budget.output(`caution: filename not matched:  ${filtered(parsed.patterns[index])}
+`, true);
+          unmatched = true;
+        }
+        return { exitCode: selected2 && !unmatched ? 0 : 11 };
+      }
+      if (parsed.list) await budget.output(parsed.verbose ? " Length   Method    Size  Cmpr    Date    Time   CRC-32   Name\n--------  ------  ------- ---- ---------- ----- --------  ----\n" : "  Length      Date    Time    Name\n---------  ---------- -----   ----\n");
+      const rootRaw = parsed.destination === void 0 ? context.cwd : vfsPath(context.cwd, parsed.destination);
+      const root = parsed.list || parsed.pipe || parsed.test ? resolvePath(rootRaw) : await extraction.directory(rootRaw, true);
+      if (!parsed.list && !parsed.pipe && !parsed.test) answers = new Answers(extraction.source(context.stdin), limits, context.signal);
+      let overwrite = parsed.neverOverwrite ? "none" : parsed.overwrite ? "all" : "ask";
+      let exitCode = 0;
+      let selected = 0;
+      let badPasswords = 0;
+      let total = 0;
+      let compressedTotal = 0;
+      let actualTotal = 0;
+      let password = parsed.password;
+      const payload = async function* (entry) {
+        let actual = 0;
+        const signal = output?.signal ?? context.signal;
+        if (entry.flags & 1) {
+          for (let attempt = password !== void 0 && parsed.password === void 0 ? -1 : 0; attempt < 3; attempt++) {
+            if (password === void 0) password = await extraction.operation(() => readZipPassword(options.zipHost, limits.maxArgumentBytes, signal, false));
+            try {
+              const verified = await collectBytes(decodeZipEntry(entry, limits, signal, password), { ...Number.isFinite(Math.min(limits.maxEntryBytes, limits.maxTotalBytes - actualTotal)) ? { maxBytes: Math.min(limits.maxEntryBytes, limits.maxTotalBytes - actualTotal) } : {}, signal });
+              actualTotal += verified.length;
+              yield verified;
+              return;
+            } catch (error) {
+              signal.throwIfAborted();
+              if (parsed.password !== void 0 || !(error instanceof PublicDiagnostic) || error.message !== "ZIP incorrect password") throw error;
+              password = void 0;
+            }
+          }
+          fail("ZIP incorrect password");
+        }
+        for await (const chunk of readBytes(decodeZipEntry(entry, limits, signal, password), signal)) {
+          if (chunk.length > limits.maxEntryBytes - actual || chunk.length > limits.maxTotalBytes - actualTotal) fail("actual decompressed byte limit exceeded");
+          actual += chunk.length;
+          actualTotal += chunk.length;
+          yield chunk;
+        }
+      };
+      const links = [];
+      const directories = [];
+      for (const entry of zip.entries) {
+        await budget.member(entry.size);
+        checkPath(entry.name, limits);
+        if (!await selection.matches(entry.name, true)) continue;
+        if (parsed.exclusions.length && await exclusions.matches(entry.name, true)) continue;
+        selected++;
+        total += entry.size;
+        try {
+          if (parsed.test) {
+            for await (const chunk of payload(entry)) {
+              if (chunk.length) context.signal.throwIfAborted();
+            }
+            if (!parsed.quiet) await budget.output(`    testing: ${padded(filtered(entry.name))} OK
+`);
+            continue;
+          }
+          if (parsed.pipe) {
+            if (parsed.pipeHeaders && !parsed.quiet) await budget.output(`${entry.method === 0 ? " extracting" : "  inflating"}: ${padded(filtered(entry.name))}  
+`);
+            for await (const chunk of payload(entry)) await output.output.write(chunk);
+            if (parsed.pipeHeaders && !parsed.quiet) await budget.output("\n");
+            continue;
+          }
+          if (parsed.list) {
+            const size = entry.compressedSize ?? entry.data.length;
+            compressedTotal += size;
+            const method = entry.method === 0 ? "Stored" : entry.method === 8 ? "Defl:N" : entry.method === 12 ? "BZip2" : entry.method === 14 ? "LZMA" : `m${entry.method}`;
+            const ratio = entry.size ? Math.round(100 * (entry.size - size) / entry.size) : 0;
+            await budget.output(parsed.verbose ? `${String(entry.size).padStart(8)}  ${method.padEnd(6)} ${String(size).padStart(8)} ${String(ratio).padStart(3)}% ${date(entry)} ${entry.crc32.toString(16).padStart(8, "0")}  ${filtered(entry.name)}
+` : `${String(entry.size).padStart(9)}  ${date(entry)}   ${filtered(entry.name)}
+`);
+            if (entry.comment) await comment(entry.comment, budget);
+            continue;
+          }
+          let path = extraction.member(root, entry.name);
+          const fileType = entry.mode & 61440;
+          if (fileType && fileType !== 32768 && fileType !== 16384 && fileType !== 40960 && fileType !== 4096) fail("unsupported special ZIP entry");
+          if (path === root && !entry.directory) fail("entry would replace extraction root");
+          if (parsed.junkPaths && entry.directory) continue;
+          const name = parsed.junkPaths ? entry.name.split("/").at(-1) : entry.name;
+          if (parsed.junkPaths) path = extraction.member(root, name);
+          if (path === root && !entry.directory) fail("entry would replace extraction root");
+          let shown = parsed.destination === void 0 ? name : `${parsed.destination.endsWith("/") ? parsed.destination : `${parsed.destination}/`}${name}`;
+          if (parsed.freshen && !await extraction.stat(path)) continue;
+          await extraction.parents(root, path, true);
+          if (entry.directory) {
+            if (entry.size) fail("directory has nonempty payload");
+            for await (const chunk of payload(entry)) {
+              await writeFileOutput(context, chunk, async () => {
+                if (chunk.length) fail("directory has nonempty payload");
+              });
+            }
+            const parent2 = await extraction.operation(() => context.fs.lstat(dirname(path), { signal: context.signal }));
+            const existing2 = await extraction.stat(path);
+            let identity = existing2;
+            if (existing2 && existing2.type !== "directory") fail("directory destination is not a directory");
+            if (!existing2) {
+              identity = await extraction.createDirectory(path, parent2);
+              if (!parsed.quiet) await budget.output(`   creating: ${filtered(shown)}
+`);
+            }
+            if (!identity || identity.type !== "directory") fail("directory changed during creation");
+            directories.push({ path, entry, identity, parent: parent2 });
+            continue;
+          }
+          let parent = await extraction.operation(() => context.fs.lstat(dirname(path), { signal: context.signal }));
+          let existing = await extraction.destination(path, archivePath, archiveStat);
+          if (parsed.update && existing && Math.ceil(Math.floor(existing.mtimeMs / 1e3) / 2) * 2e3 >= entry.modified.getTime()) continue;
+          let skip = false;
+          let prompting = 0;
+          while (existing && overwrite !== "all") {
+            if (overwrite === "none") {
+              skip = true;
+              break;
+            }
+            if (++prompting > limits.maxMembers) fail("overwrite prompt work limit exceeded");
+            await budget.output(`replace ${filtered(shown)}? [y]es, [n]o, [A]ll, [N]one, [r]ename: `, true);
+            const answer = await answers.read();
+            if (answer === void 0) {
+              await budget.output(' NULL\n(EOF or read error, treating as "[N]one" ...)\n', true);
+              overwrite = "none";
+              exitCode = 1;
+              skip = true;
+              break;
+            }
+            const choice = answer[0];
+            if (choice === "A") {
+              overwrite = "all";
+              break;
+            }
+            if (choice === "y" || choice === "Y") break;
+            if (choice === "n" || choice === "N") {
+              if (choice === "N") overwrite = "none";
+              skip = true;
+              break;
+            }
+            if (choice === "r" || choice === "R") {
+              let renamed = "";
+              while (!renamed) {
+                await budget.output("new name: ", true);
+                const value = await answers.read(limits.maxPathBytes);
+                if (value === void 0) fail("EOF while reading replacement name");
+                renamed = value.endsWith("\n") ? value.slice(0, -1) : value;
+              }
+              path = extraction.member(root, renamed);
+              shown = parsed.destination === void 0 ? renamed : `${parsed.destination.endsWith("/") ? parsed.destination : `${parsed.destination}/`}${renamed}`;
+              await extraction.parents(root, path, true);
+              parent = await extraction.operation(() => context.fs.lstat(dirname(path), { signal: context.signal }));
+              existing = await extraction.destination(path, archivePath, archiveStat);
+              continue;
+            }
+            const response = choice === "\n" || choice === "\r" ? "{ENTER}" : answer.endsWith("\n") ? answer.slice(0, -1) : answer;
+            await budget.output(`error:  invalid response [${response}]
+`, true);
+          }
+          if (skip) continue;
+          const chunks = [];
+          let actual = 0;
+          for await (const chunk of payload(entry)) {
+            actual += chunk.length;
+            await writeFileOutput(context, chunk, async (bytes2) => {
+              chunks.push(Uint8Array.from(bytes2));
+            });
+          }
+          if (entry.symlink) {
+            if (actual > limits.maxPathBytes) fail("symlink target byte limit exceeded");
+            const target = text(concatBytes(chunks));
+            await extraction.target(root, path, target);
+            if (!context.fs.symlink || context.fs.capabilities.symlinks === false) fail("filesystem does not support symlinks");
+            links.push({ path, shown, target, existing, parent, entry });
+            if (!parsed.quiet) await budget.output(`    linking: ${padded(filtered(shown))}  -> ${filtered(target)} 
+`);
+          } else {
+            await extraction.publish(root, path, chunks, existing, parent, entry.mode, entry.modified);
+            if (!parsed.quiet) await budget.output(`${entry.method === 0 ? " extracting" : "  inflating"}: ${padded(filtered(shown))}  
+`);
+          }
+        } catch (error) {
+          context.signal.throwIfAborted();
+          if (!(error instanceof PublicDiagnostic) || error.message !== "ZIP incorrect password") throw error;
+          badPasswords++;
+          await budget.output(`skipping: ${filtered(entry.name)}  incorrect password
+`, true);
+        }
+      }
+      if (parsed.list) await budget.output(parsed.verbose ? `--------          -------  ---                            -------
+${String(total).padStart(8)}         ${String(compressedTotal).padStart(8)} ${String(total ? Math.round(100 * (total - compressedTotal) / total) : 0).padStart(3)}%                            ${selected} file${selected === 1 ? "" : "s"}
+` : `---------                     -------
+${String(total).padStart(9)}                     ${selected} file${selected === 1 ? "" : "s"}
+`);
+      else {
+        if (links.length && !parsed.quiet) await budget.output("finishing deferred symbolic links:\n");
+        for (const link of links) {
+          await extraction.parents(root, link.path, false);
+          await extraction.target(root, link.path, link.target);
+          await extraction.destination(link.path, archivePath, archiveStat);
+          await extraction.publish(root, link.path, [], link.existing, link.parent, link.entry.mode, link.entry.modified, link.target);
+          if (!parsed.quiet) await budget.output(`  ${padded(filtered(link.shown))} -> ${filtered(link.target)}
+`);
+        }
+        for (const { path, entry, identity, parent } of directories.reverse()) {
+          await extraction.metadata(root, path, identity, parent, entry.mode, entry.modified);
+        }
+      }
+      for (let index = 0; index < parsed.patterns.length; index++) if (!selection.matched.has(index)) {
+        await budget.output(`caution: filename not matched:  ${filtered(parsed.patterns[index])}
+`, true);
+        exitCode = 11;
+      }
+      const resultCode = badPasswords ? badPasswords === selected ? 82 : 1 : selected ? exitCode : 11;
+      if (parsed.test && parsed.quiet < 2) await budget.output(resultCode ? `At least one error was detected in ${filtered(archive)}.
+` : `No errors detected in compressed data of ${filtered(archive)}.
+`);
+      return { exitCode: resultCode };
+    } catch (error) {
+      original.signal.throwIfAborted();
+      const message = display(publicDiagnosticMessage(error, original.onInternalError).slice(0, limits.maxDiagnosticBytes));
+      await writeBytes(original.stderr, encodeBytes(`unzip: ${message}
+`).subarray(0, limits.maxDiagnosticBytes), original.signal);
+      return { exitCode: 2 };
+    } finally {
+      await close();
+    }
+  }) };
+}
+
+export {
+  createUnzipCommand
+};

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

@@ -0,0 +1,178 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-diff/src/diff-options.ts
+init_buffer();
+import { ToolError } from "../../safe-bash-diff-engine/shared.js";
+import { Pattern } from "../../safe-bash-regex-engine/text/regex.js";
+function contextLength(value) {
+  if (!/^(?:[ \t\n\v\f\r]*[+-]?\d+)?$/u.test(value) || Number(value) < 0) {
+    throw new ToolError(`invalid context length: ${value}`);
+  }
+  return Math.min(Number(value), Number.MAX_SAFE_INTEGER);
+}
+function flags(args) {
+  const result = { format: "normal", whitespace: "exact", context: 0, brief: false, recursive: false, newFile: false, unidirectionalNewFile: false, stripTrailingCr: false, ignoreFileNameCase: false, labels: [], files: [], optionArgs: [], ignoreCase: false, ignoreBlank: false, ignoreTrailing: false, ignoreTabs: false, ignorePatterns: [], functions: [], reportSame: false, text: false, paginate: false, excludes: [], excludeFiles: [], width: 130, expand: false, initialTab: false, leftColumn: false, suppressCommon: false, symbol: "" };
+  let selectedFormat;
+  const selectFormat = (format) => {
+    if (selectedFormat !== void 0 && selectedFormat !== format) throw new ToolError("conflicting output format options");
+    selectedFormat = result.format = format;
+  };
+  let explicitWidth;
+  let legacyContext = -1;
+  let previousDigit = false;
+  const selectContext = (format, width, explicit) => {
+    selectFormat(format);
+    if (explicit) {
+      if (explicitWidth !== void 0 && explicitWidth !== width) throw new ToolError("conflicting output style options");
+      explicitWidth = width;
+    }
+    result.context = explicitWidth ?? width;
+  };
+  let operands = false;
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    const optionStart = index;
+    const isOption = !operands && arg !== "-" && arg.startsWith("-");
+    if (!operands && arg.startsWith("--")) previousDigit = false;
+    const value = (attached, name) => {
+      const next = attached ?? args[++index];
+      if (next === void 0) throw new ToolError(`${name} requires an argument`);
+      return next;
+    };
+    if (operands || arg === "-" || !arg.startsWith("-")) result.files.push(arg);
+    else if (arg === "--") operands = true;
+    else if (arg === "--brief") result.brief = true;
+    else if (arg === "--recursive") result.recursive = true;
+    else if (arg === "--new-file") result.newFile = true;
+    else if (arg === "--unidirectional-new-file") result.unidirectionalNewFile = true;
+    else if (arg === "--strip-trailing-cr") result.stripTrailingCr = true;
+    else if (arg === "--no-dereference") result.noDereference = true;
+    else if (arg === "--ignore-file-name-case") result.ignoreFileNameCase = true;
+    else if (arg === "--no-ignore-file-name-case") result.ignoreFileNameCase = false;
+    else if (arg === "--ignore-case") result.ignoreCase = true;
+    else if (arg === "--ignore-blank-lines") result.ignoreBlank = true;
+    else if (arg === "--ignore-trailing-space") result.ignoreTrailing = true;
+    else if (arg === "--ignore-tab-expansion") result.ignoreTabs = true;
+    else if (arg === "--report-identical-files") result.reportSame = true;
+    else if (arg === "--text") result.text = true;
+    else if (arg === "--minimal") {
+    } else if (arg === "--side-by-side") selectFormat("side");
+    else if (arg === "--ed") selectFormat("ed");
+    else if (arg === "--rcs") selectFormat("rcs");
+    else if (arg === "--expand-tabs") result.expand = true;
+    else if (arg === "--initial-tab") result.initialTab = true;
+    else if (arg === "--left-column") result.leftColumn = true;
+    else if (arg === "--suppress-common-lines") result.suppressCommon = true;
+    else if (arg === "--paginate") result.paginate = true;
+    else if (arg === "--color" || arg.startsWith("--color=")) {
+      const mode = arg === "--color" ? "auto" : arg.slice(8);
+      if (mode !== "auto" && mode !== "always" && mode !== "never") throw new ToolError(`invalid color: ${mode}`);
+      result.color = mode === "always";
+    } else if (arg === "--show-c-function") result.functions.push(new Pattern("^[A-Za-z_$]", false));
+    else if (["--width", "--ifdef", "--ignore-matching-lines", "--show-function-line", "--exclude", "--exclude-from", "--starting-file", "--from-file", "--to-file"].some((name) => arg === name || arg.startsWith(`${name}=`))) {
+      const equal = arg.indexOf("=");
+      const name = equal < 0 ? arg : arg.slice(0, equal);
+      const parameter = value(equal < 0 ? void 0 : arg.slice(equal + 1), name);
+      if (name === "--width") result.width = outputWidth(parameter);
+      else if (name === "--ifdef") {
+        selectFormat("ifdef");
+        result.symbol = parameter;
+      } else if (name === "--ignore-matching-lines") result.ignorePatterns.push(new Pattern(parameter, false));
+      else if (name === "--show-function-line") result.functions.push(new Pattern(parameter, false));
+      else if (name === "--exclude") result.excludes.push({ pattern: parameter, ignoreCase: result.ignoreFileNameCase });
+      else if (name === "--exclude-from") result.excludeFiles.push({ path: parameter, ignoreCase: result.ignoreFileNameCase });
+      else if (name === "--from-file") result.fromFile = parameter;
+      else if (name === "--to-file") result.toFile = parameter;
+      else result.startingFile = parameter;
+    } else if (arg === "--ignore-all-space") result.whitespace = "all";
+    else if (arg === "--ignore-space-change") {
+      if (result.whitespace !== "all") result.whitespace = "change";
+    } else if (arg === "--normal") selectFormat("normal");
+    else if (arg === "--unified") selectContext("unified", 3, false);
+    else if (arg.startsWith("--unified=")) selectContext("unified", contextLength(arg.slice(10)), true);
+    else if (arg === "--context") selectContext("context", 3, false);
+    else if (arg.startsWith("--context=")) selectContext("context", contextLength(arg.slice(10)), true);
+    else if (arg === "--label" || arg.startsWith("--label=")) result.labels.push(value(arg.includes("=") ? arg.slice(8) : void 0, "--label"));
+    else if (arg.startsWith("--")) throw new ToolError(`unsupported option: ${arg}`);
+    else {
+      for (let offset = 1; offset < arg.length; offset++) {
+        const flag = arg[offset];
+        if (/^\d$/u.test(flag)) {
+          legacyContext = Math.min((previousDigit ? legacyContext : 0) * 10 + Number(flag), Number.MAX_SAFE_INTEGER);
+          previousDigit = true;
+          continue;
+        }
+        previousDigit = false;
+        if (flag === "u") selectContext("unified", 3, false);
+        else if (flag === "c") selectContext("context", 3, false);
+        else if (flag === "q") result.brief = true;
+        else if (flag === "r") result.recursive = true;
+        else if (flag === "N") result.newFile = true;
+        else if (flag === "P") result.unidirectionalNewFile = true;
+        else if (flag === "i") result.ignoreCase = true;
+        else if (flag === "B") result.ignoreBlank = true;
+        else if (flag === "Z") result.ignoreTrailing = true;
+        else if (flag === "E") result.ignoreTabs = true;
+        else if (flag === "s") result.reportSame = true;
+        else if (flag === "a") result.text = true;
+        else if (flag === "d") {
+        } else if (flag === "y") selectFormat("side");
+        else if (flag === "e") selectFormat("ed");
+        else if (flag === "n") selectFormat("rcs");
+        else if (flag === "t") result.expand = true;
+        else if (flag === "T") result.initialTab = true;
+        else if (flag === "l") result.paginate = true;
+        else if (flag === "p") result.functions.push(new Pattern("^[A-Za-z_$]", false));
+        else if (flag === "w") result.whitespace = "all";
+        else if (flag === "b") {
+          if (result.whitespace !== "all") result.whitespace = "change";
+        } else if ("UCLWDIFxXS".includes(flag)) {
+          const parameter = value(arg.slice(offset + 1) || void 0, `-${flag}`);
+          if (flag === "U") selectContext("unified", contextLength(parameter), true);
+          else if (flag === "C") selectContext("context", contextLength(parameter), true);
+          else if (flag === "L") result.labels.push(parameter);
+          else if (flag === "W") result.width = outputWidth(parameter);
+          else if (flag === "D") {
+            selectFormat("ifdef");
+            result.symbol = parameter;
+          } else if (flag === "I") result.ignorePatterns.push(new Pattern(parameter, false));
+          else if (flag === "F") result.functions.push(new Pattern(parameter, false));
+          else if (flag === "x") result.excludes.push({ pattern: parameter, ignoreCase: result.ignoreFileNameCase });
+          else if (flag === "X") result.excludeFiles.push({ path: parameter, ignoreCase: result.ignoreFileNameCase });
+          else result.startingFile = parameter;
+          break;
+        } else throw new ToolError(`unsupported option: -${flag}`);
+      }
+    }
+    if (isOption) result.optionArgs.push(...args.slice(optionStart, index + 1));
+  }
+  if (legacyContext >= 0 && (result.format === "unified" || result.format === "context")) {
+    result.context = explicitWidth !== void 0 ? Math.max(result.context, legacyContext) : legacyContext;
+  }
+  if (result.fromFile !== void 0 && result.toFile !== void 0) throw new ToolError("--from-file and --to-file may not both be specified");
+  const multiple = result.fromFile !== void 0 || result.toFile !== void 0;
+  if (multiple ? result.files.length === 0 : result.files.length !== 2) throw new ToolError(multiple ? "expected at least one file or directory" : "expected two files or directories");
+  if (selectedFormat === void 0 && result.functions.length) {
+    result.format = "context";
+    result.context = Math.max(3, result.context);
+  }
+  if (result.labels.length > 2) throw new ToolError("at most two labels are supported");
+  for (const name of [...result.files, ...[result.fromFile, result.toFile].filter((name2) => name2 !== void 0)]) {
+    if (!name || /[\0\r\n\t]/u.test(name)) throw new ToolError("empty names or control characters in filenames/labels are unsupported");
+  }
+  for (const label of result.labels) {
+    if (/[\0\r\n\t]/u.test(label)) throw new ToolError("empty names or control characters in filenames/labels are unsupported");
+  }
+  return result;
+}
+function outputWidth(value) {
+  const width = contextLength(value);
+  if (width < 1) throw new ToolError(`invalid width: ${value}`);
+  return width;
+}
+
+export {
+  flags
+};

package/dist/safe-bash/command-chunks/{chunk-KBEURXFF.js → chunk-UN6WS55J.js}

@@ -5,13 +5,13 @@ import {
   parseFormatSections,
   scanFormat,
   selectFormatSection
-} from "./chunk-5SHGJ7NO.js";
+} from "./chunk-VA5ZHYYA.js";
 import {
   cellValueFormat
-} from "./chunk-4QJOYXVB.js";
+} from "./chunk-JV7LBUTP.js";
 import {
   SsconvertError
-} from "./chunk-DWFLVJC6.js";
+} from "./chunk-CCRHMAU5.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";