@poe-platform/safe-bash 0.1.803 → 0.1.804

package/dist/safe-bash/chunks/{chunk-3HQU4OJO.js → chunk-XNGVOSGI.js}

@@ -1,6 +1,6 @@
 import {
   init_platform
-} from "./chunk-B7TAL7S5.js";
+} from "./chunk-PTAEWLSE.js";
 
 // packages/safe-bash/src/commands/column/index.ts
 init_platform();

package/dist/safe-bash/chunks/{chunk-J42RIHHJ.js → chunk-XQWCQSRN.js}

@@ -1,6 +1,6 @@
 import {
   init_platform
-} from "./chunk-B7TAL7S5.js";
+} from "./chunk-PTAEWLSE.js";
 
 // packages/safe-bash/src/contracts/value.ts
 init_platform();

package/dist/safe-bash/chunks/{chunk-A7XEHALN.js → chunk-Y7FW6GLT.js}

@@ -1,17 +1,17 @@
+import {
+  writeText
+} from "./chunk-4KTMKD5W.js";
 import {
   concatShellValues,
   shellValueBytes,
   shellValueFromBytes
-} from "./chunk-J42RIHHJ.js";
-import {
-  writeText
-} from "./chunk-74GHTNJA.js";
+} from "./chunk-XQWCQSRN.js";
 import {
   commandRuntimeIdentity
-} from "./chunk-7R5BDCG7.js";
+} from "./chunk-OHML2BEU.js";
 import {
   init_platform
-} from "./chunk-B7TAL7S5.js";
+} from "./chunk-PTAEWLSE.js";
 
 // packages/safe-bash/src/shell/extensions/jobs/index.ts
 init_platform();

package/dist/safe-bash/chunks/{chunk-QGUV42T5.js → chunk-YL3GBUG4.js}

@@ -1,6 +1,6 @@
 import {
   init_platform
-} from "./chunk-B7TAL7S5.js";
+} from "./chunk-PTAEWLSE.js";
 
 // packages/safe-bash/src/commands/archive/index.ts
 init_platform();

package/dist/safe-bash/chunks/chunk-YOXUCJER.js

@@ -0,0 +1,389 @@
+import {
+  builtInDirectContextExecutors,
+  registerDefaultExecutor,
+  registerDefaultExecutors
+} from "./chunk-V7QT2RWC.js";
+import {
+  init_platform
+} from "./chunk-PTAEWLSE.js";
+
+// packages/safe-bash/src/commands/csvcut/index.ts
+init_platform();
+import {
+  CsvBudget,
+  CsvParser,
+  generatedHeaders,
+  parseCsvcutArguments,
+  resolveColumns,
+  serializeRow,
+  createCsvcutCommand as createRawCsvcutCommand,
+  createCsvcutCommands as createRawCsvcutCommands,
+  csvcutCommand as rawCsvcutCommand
+} from "../../safe-bash-command-csvcut/index.js";
+import { CsvBudget as CsvBudget2, CsvError, CsvParser as CsvParser2, csvcut, cutCsv, defaultCsvLimits, generatedHeaders as generatedHeaders2, parseCsvRecords, parseCsvcutArguments as parseCsvcutArguments2, resolveColumns as resolveColumns2, serializeRow as serializeRow2 } from "../../safe-bash-command-csvcut/index.js";
+builtInDirectContextExecutors.add(rawCsvcutCommand.execute);
+function createCsvcutCommand(options) {
+  const def = createRawCsvcutCommand(options);
+  if (options?.limits === void 0) builtInDirectContextExecutors.add(def.execute);
+  return def;
+}
+function createCsvcutCommands(options) {
+  const defs = createRawCsvcutCommands(options);
+  if (options?.limits === void 0) {
+    for (let i = 0; i < defs.length; i++) builtInDirectContextExecutors.add(defs[i].execute);
+  }
+  return defs;
+}
+function csvcutCommands(options = {}) {
+  const commands = createCsvcutCommands(options);
+  const replace = options.replace ?? false;
+  return {
+    name: "csvcut",
+    setup(host) {
+      for (const command of commands) host.commands.register(command, { replace });
+    }
+  };
+}
+var _syncAbortSignal;
+var syncAbortSignal = () => _syncAbortSignal ??= new AbortController().signal;
+function evalSyncCsvcut(inBytes, opArgs, readFileSync) {
+  if (inBytes !== void 0 && inBytes.byteLength > 16384) return void 0;
+  const budget = new CsvBudget({}, syncAbortSignal());
+  try {
+    const supplied = parseCsvcutArguments(opArgs, budget);
+    if (supplied.help || supplied.version) return void 0;
+    if (supplied.encoding && supplied.encoding.toLowerCase() !== "utf-8" && supplied.encoding.toLowerCase() !== "utf-8-sig") {
+      return void 0;
+    }
+    let sourceBytes = inBytes;
+    if (supplied.filePath !== void 0 && supplied.filePath !== "-") {
+      if (!readFileSync) return void 0;
+      const fileBytes = readFileSync(supplied.filePath);
+      if (!fileBytes || fileBytes.byteLength > 16384) return void 0;
+      sourceBytes = fileBytes;
+    }
+    if (supplied.names && supplied.headerless) return void 0;
+    const dialect = { ...supplied.dialect, profile: supplied.dialect?.profile ?? "utf8-sig-permissive-v1" };
+    if (Number.isSafeInteger(dialect.skipLines) && dialect.skipLines < 0) dialect.skipLines = 0;
+    if (sourceBytes === void 0) return void 0;
+    const parser = new CsvParser(dialect, budget);
+    const rows = [...parser.push(sourceBytes), ...parser.end()];
+    const first = rows[0];
+    if (supplied.names && !first) return void 0;
+    const headers = supplied.headerless ? generatedHeaders(first?.cells.length ?? 0, budget) : first?.cells ?? [];
+    let out = supplied.addBom ? "\uFEFF" : "";
+    if (supplied.names) {
+      for (let i = 0; i < headers.length; i++) {
+        out += `${String(i + (supplied.zero ? 0 : 1)).padStart(3, " ")}: ${headers[i]}
+`;
+      }
+      return out;
+    }
+    const columns = headers.length ? resolveColumns(supplied, headers, budget) : [];
+    const project = (cells) => {
+      const projected = [];
+      for (let i = 0; i < columns.length; i++) {
+        projected.push(cells[columns[i]] ?? "");
+      }
+      return projected;
+    };
+    const heading = project(headers);
+    if (supplied.lineNumbers) heading.unshift("line_number");
+    out += serializeRow(heading, budget);
+    let number = 0;
+    for (let i = supplied.headerless ? 0 : 1; i < rows.length; i++) {
+      const cells = project(rows[i].cells);
+      if (supplied.deleteEmptyRows && cells.every((c) => c === "")) continue;
+      if (supplied.lineNumbers) cells.unshift(String(++number));
+      out += serializeRow(cells, budget);
+    }
+    return out;
+  } catch {
+    return void 0;
+  } finally {
+    budget.dispose();
+  }
+}
+
+// packages/safe-bash/src/commands/csvgrep/index.ts
+init_platform();
+import {
+  CsvBudget as CsvBudget3,
+  CsvParser as CsvParser3,
+  createMatcher,
+  generatedHeaders as generatedHeaders3,
+  matchesRow,
+  parseCsvgrepArguments,
+  selectColumns,
+  serializeRow as serializeRow3,
+  createCsvgrepCommand as createRawCsvgrepCommand,
+  createCsvgrepCommands as createRawCsvgrepCommands,
+  csvgrepCommand as rawCsvgrepCommand
+} from "../../safe-bash-command-csvgrep/index.js";
+import { CsvBudget as CsvBudget4, CsvError as CsvError2, CsvParser as CsvParser4, createMatcher as createMatcher2, csvgrep, generatedHeaders as generatedHeaders4, matchesRow as matchesRow2, parseCsvgrepArguments as parseCsvgrepArguments2, selectColumns as selectColumns2, serializeRow as serializeRow4 } from "../../safe-bash-command-csvgrep/index.js";
+builtInDirectContextExecutors.add(rawCsvgrepCommand.execute);
+function createCsvgrepCommand(options) {
+  const def = createRawCsvgrepCommand(options);
+  if (options?.limits === void 0) builtInDirectContextExecutors.add(def.execute);
+  return def;
+}
+function createCsvgrepCommands(options) {
+  const defs = createRawCsvgrepCommands(options);
+  if (options?.limits === void 0) {
+    for (let i = 0; i < defs.length; i++) builtInDirectContextExecutors.add(defs[i].execute);
+  }
+  return defs;
+}
+function csvgrepCommands(options = {}) {
+  const commands = createCsvgrepCommands(options);
+  const replace = options.replace ?? false;
+  return {
+    name: "csvgrep",
+    setup(host) {
+      for (const command of commands) host.commands.register(command, { replace });
+    }
+  };
+}
+var _syncAbortSignal2;
+var syncAbortSignal2 = () => _syncAbortSignal2 ??= new AbortController().signal;
+function evalSyncCsvgrep(inBytes, opArgs, readFileSync) {
+  if (inBytes !== void 0 && inBytes.byteLength > 16384) return void 0;
+  const budget = new CsvBudget3({}, syncAbortSignal2());
+  try {
+    const options = parseCsvgrepArguments(opArgs, budget);
+    if (!options.names) {
+      if (!options.columns) return void 0;
+      const modes = [options.match !== void 0, options.regex !== void 0, options.file !== void 0].filter(Boolean).length;
+      if (modes !== 1) return void 0;
+    }
+    if (options.names && options.headerless) return void 0;
+    let fileMatchSet = /* @__PURE__ */ new Set();
+    if (options.file !== void 0) {
+      if (!readFileSync) return void 0;
+      const patBytes = readFileSync(options.file);
+      if (!patBytes || patBytes.byteLength > 16384) return void 0;
+      const patText = new TextDecoder("utf-8", { fatal: false }).decode(patBytes);
+      fileMatchSet = new Set(patText.split(/\r?\n/).filter((l) => l.length > 0));
+    }
+    let sourceBytes = inBytes;
+    if (options.filePath !== void 0 && options.filePath !== "-") {
+      if (!readFileSync) return void 0;
+      const fileBytes = readFileSync(options.filePath);
+      if (!fileBytes || fileBytes.byteLength > 16384) return void 0;
+      sourceBytes = fileBytes;
+    }
+    if (sourceBytes === void 0) return void 0;
+    const parser = new CsvParser3(options.dialect ?? {}, budget);
+    const rows = [...parser.push(sourceBytes), ...parser.end()];
+    const matcher = options.names ? void 0 : createMatcher(options, fileMatchSet, budget);
+    let headers;
+    let columns = [];
+    let out = "";
+    for (const row of rows) {
+      if (headers === void 0) {
+        headers = options.headerless ? generatedHeaders3(row.cells.length + (options.lineNumbers ? 1 : 0), budget) : row.cells;
+        if (options.lineNumbers && !options.headerless) {
+          headers = ["line_numbers", ...headers];
+        }
+        if (options.names) {
+          for (let i = 0; i < headers.length; i++) {
+            out += `${String(i + (options.zero ? 0 : 1)).padStart(3)}: ${headers[i]}
+`;
+          }
+          return out;
+        }
+        columns = selectColumns(options.columns, headers, options.zero ?? false, budget, void 0, options.lineNumbers ? 1 : 0);
+        out += serializeRow3(headers, budget);
+        if (!options.headerless) continue;
+      }
+      const cells = options.lineNumbers ? [String(row.line - (options.headerless ? 0 : 1)), ...row.cells] : row.cells;
+      if (matchesRow(cells, columns, matcher, options.any ?? false, options.invert ?? false, budget)) {
+        out += serializeRow3(cells, budget);
+      }
+    }
+    if (headers === void 0) {
+      if (options.names) return void 0;
+      out += serializeRow3([], budget);
+    }
+    return out;
+  } catch {
+    return void 0;
+  } finally {
+    budget.dispose();
+  }
+}
+
+// packages/safe-bash/src/commands/htmlq/index.ts
+init_platform();
+import { HtmlBudget, HtmlError, createHtmlqCommand, createHtmlqCommands, defaultHtmlLimits, detachHtmlNode, evalSyncHtmlq, getInternalHtmlNode, htmlText, htmlq, htmlqBaseline, htmlqBytes, htmlqCommand, htmlqCommands, inclusiveHtmlDescendants, invocationOptions, parseHtml, parseHtmlSync, parseHtmlqArguments, replaceHtmlAttribute, rustWhitespaceOnly, selectHtml, serializeHtml, serializeHtmlBytes } from "../../safe-bash-command-htmlq/index.js";
+
+// packages/safe-bash/src/commands/unrtf/index.ts
+init_platform();
+import {
+  renderRtfSync,
+  createUnrtfCommand as createRawUnrtfCommand,
+  createUnrtfCommands as createRawUnrtfCommands
+} from "../../safe-bash-command-unrtf/index.js";
+import { UnrtfError, charsetCodePages, codecLabels, extractRtf, renderRtf, renderRtfSync as renderRtfSync2, tokenizeRtf, unrtf, unrtfBaseline, unrtfCommand } from "../../safe-bash-command-unrtf/index.js";
+function createUnrtfCommand(options = {}) {
+  return registerDefaultExecutor(createRawUnrtfCommand(options), options);
+}
+function createUnrtfCommands(options = {}) {
+  return registerDefaultExecutors(createRawUnrtfCommands(options), options);
+}
+function unrtfCommands(options = {}) {
+  const commands = createUnrtfCommands(options);
+  const replace = options.replace ?? false;
+  return {
+    name: "unrtf",
+    setup(host) {
+      if (!replace) {
+        for (const command of commands) {
+          if (host.commands.has(command.name)) throw new Error(`Command already registered: ${command.name}`);
+        }
+      }
+      for (const command of commands) host.commands.register(command, { replace });
+    }
+  };
+}
+var _syncUnrtfSignal;
+var syncUnrtfSignal = () => _syncUnrtfSignal ??= new AbortController().signal;
+var syncUnrtfDecoder = new TextDecoder("utf-8", { fatal: false });
+var unrtfCache = /* @__PURE__ */ new Map();
+function evalSyncUnrtf(inBytes, opArgs, readFileSync) {
+  let format = "html";
+  let profile;
+  let quiet;
+  let noremap;
+  let file;
+  let literal = false;
+  for (let i = 0; i < opArgs.length; i++) {
+    const arg = opArgs[i];
+    if (literal) {
+      if (file !== void 0) return void 0;
+      file = arg;
+    } else if (arg === "--") literal = true;
+    else if (arg === "--text") format = "text";
+    else if (arg === "--html") format = "html";
+    else if (arg === "--latex") format = "latex";
+    else if (arg.startsWith("--profile=")) profile = arg.slice("--profile=".length);
+    else if (arg === "--quiet") quiet = true;
+    else if (arg === "--noremap") noremap = true;
+    else if (arg === "--nopict" || arg === "-n") continue;
+    else if (arg.startsWith("-")) return void 0;
+    else {
+      if (file !== void 0) return void 0;
+      file = arg;
+    }
+  }
+  let srcBytes = inBytes;
+  if (file !== void 0) {
+    if (!readFileSync || file.includes("\0")) return void 0;
+    srcBytes = readFileSync(file) ?? readFileSync(file + ".rtf");
+  }
+  if (!srcBytes || srcBytes.byteLength === 0 || srcBytes.byteLength > 16384) return void 0;
+  const cacheKey = `${format}|\0${profile ?? ""}|\0${quiet ? 1 : 0}|\0${noremap ? 1 : 0}|\0${syncUnrtfDecoder.decode(srcBytes)}`;
+  const cached = unrtfCache.get(cacheKey);
+  if (cached !== void 0) return cached;
+  try {
+    let out = renderRtfSync(srcBytes, {
+      format,
+      signal: syncUnrtfSignal(),
+      ...quiet === void 0 ? {} : { quiet },
+      ...noremap === void 0 ? {} : { noremap },
+      ...profile === void 0 ? {} : { profile }
+    });
+    if (out.endsWith("\n")) out = out.slice(0, -1);
+    if (unrtfCache.size >= 8) unrtfCache.clear();
+    unrtfCache.set(cacheKey, out);
+    return out;
+  } catch {
+    return void 0;
+  }
+}
+
+// packages/safe-bash/src/commands/diff3/index.ts
+init_platform();
+import {
+  compareDiff3,
+  diff3DefaultLimits,
+  parseDiff3Arguments,
+  createDiff3Command as createRawDiff3Command,
+  createDiff3Commands as createRawDiff3Commands
+} from "../../safe-bash-command-diff3/index.js";
+import { Diff3Error, analyzeDiff3, compareDiff3 as compareDiff32, createDiff3Engine, diff3, diff3Command, diff3DefaultLimits as diff3DefaultLimits2, parseDiff3Arguments as parseDiff3Arguments2, validateDiff3Invocation } from "../../safe-bash-command-diff3/index.js";
+function createDiff3Command(options = {}) {
+  return registerDefaultExecutor(createRawDiff3Command(options), options);
+}
+function createDiff3Commands(options = {}) {
+  return registerDefaultExecutors(createRawDiff3Commands(options), options);
+}
+function diff3Commands(options = {}) {
+  const commands = createDiff3Commands(options);
+  const replace = options.replace ?? false;
+  return {
+    name: "diff3-commands",
+    setup(host) {
+      if (!replace) {
+        for (const command of commands) {
+          if (host.commands.has(command.name)) throw new Error(`Command already registered: ${command.name}`);
+        }
+      }
+      for (const command of commands) host.commands.register(command, { replace });
+    }
+  };
+}
+var _syncDiff3Signal;
+var syncDiff3Signal = () => _syncDiff3Signal ??= new AbortController().signal;
+var syncDiff3Decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+function evalSyncDiff3(inBytes, opArgs, readFileSync) {
+  try {
+    const options = parseDiff3Arguments([...opArgs], diff3DefaultLimits);
+    if (options.information !== void 0 || options.files.length !== 3) return void 0;
+    const inputs = [];
+    let stdinUsed = false;
+    for (const file of options.files) {
+      let srcBytes;
+      if (file === "-") {
+        if (stdinUsed || !inBytes) return void 0;
+        stdinUsed = true;
+        srcBytes = inBytes;
+      } else {
+        if (!readFileSync) return void 0;
+        srcBytes = readFileSync(file);
+      }
+      if (!srcBytes || srcBytes.byteLength > 16384) return void 0;
+      inputs.push(srcBytes);
+    }
+    const rendered = compareDiff3(inputs, options, diff3DefaultLimits, syncDiff3Signal());
+    if (rendered.exitCode !== 0 || rendered.stderr.byteLength !== 0) return void 0;
+    let out = syncDiff3Decoder.decode(rendered.stdout);
+    if (out.endsWith("\n")) out = out.slice(0, -1);
+    return out;
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  createCsvcutCommand,
+  createCsvcutCommands,
+  csvcutCommands,
+  evalSyncCsvcut,
+  createCsvgrepCommand,
+  createCsvgrepCommands,
+  csvgrepCommands,
+  evalSyncCsvgrep,
+  createHtmlqCommand,
+  createHtmlqCommands,
+  evalSyncHtmlq,
+  htmlqCommands,
+  createUnrtfCommand,
+  createUnrtfCommands,
+  unrtfCommands,
+  evalSyncUnrtf,
+  createDiff3Command,
+  createDiff3Commands,
+  diff3Commands,
+  evalSyncDiff3
+};

package/dist/safe-bash/chunks/{chunk-HBCN24ZA.js → chunk-Z2AAYYJN.js}

@@ -1,9 +1,9 @@
 import {
   builtInDirectContextExecutors
-} from "./chunk-E7OYNDGL.js";
+} from "./chunk-V7QT2RWC.js";
 import {
   init_platform
-} from "./chunk-B7TAL7S5.js";
+} from "./chunk-PTAEWLSE.js";
 
 // packages/safe-bash/src/commands/stream-inspection/index.ts
 init_platform();

package/dist/safe-bash/chunks/chunk-ZKYKJCZZ.js

@@ -0,0 +1,30 @@
+import {
+  init_platform
+} from "./chunk-PTAEWLSE.js";
+
+// packages/safe-bash/src/commands/op/index.ts
+init_platform();
+import { captureEnvironment, createDocumentHandlers, createEnvironmentHandlers, createItemHandlers, createObjectBackend, createOp, createOpCommand, createOpCommands, createOpTextCodec, createSecretHandlers, evalSyncOp, opCommands, parseCommand, parseOpFileMode, parseSecretReference, renderOpHelp, renderOpOutput, restoreEnvironment, selectOpBackendContext, selectOpGlobalFlags } from "../../safe-bash-command-op/index.js";
+
+export {
+  captureEnvironment,
+  createDocumentHandlers,
+  createEnvironmentHandlers,
+  createItemHandlers,
+  createObjectBackend,
+  createOp,
+  createOpCommand,
+  createOpCommands,
+  createOpTextCodec,
+  createSecretHandlers,
+  evalSyncOp,
+  opCommands,
+  parseCommand,
+  parseOpFileMode,
+  parseSecretReference,
+  renderOpHelp,
+  renderOpOutput,
+  restoreEnvironment,
+  selectOpBackendContext,
+  selectOpGlobalFlags
+};