@poe-platform/safe-bash 0.1.781 → 0.1.783

package/dist/safe-bash/chunks/ffmpeg-BEFTQ6DZ.js

@@ -0,0 +1,60 @@
+import {
+  internal_exports
+} from "./chunk-GJWUEOT6.js";
+import {
+  init_platform
+} from "./chunk-Q45QCA4J.js";
+
+// packages/safe-bash/src/commands/ffmpeg/index.ts
+init_platform();
+import {
+  createFfmpegCommand as createRawFfmpegCommand,
+  createFfprobeCommand as createRawFfprobeCommand,
+  createFfmpegCommands as createRawFfmpegCommands,
+  evalSyncFfmpeg,
+  evalSyncFfprobe
+} from "../../safe-bash-command-ffmpeg/index.js";
+export * from "../../safe-bash-command-ffmpeg/index.js";
+function createFfmpegCommand(options = {}) {
+  const def = createRawFfmpegCommand(options);
+  internal_exports.builtInDirectContextExecutors.add(def.execute);
+  return def;
+}
+function createFfprobeCommand(options = {}) {
+  const def = createRawFfprobeCommand(options);
+  internal_exports.builtInDirectContextExecutors.add(def.execute);
+  return def;
+}
+function createFfmpegCommands(options = {}) {
+  const pair = createRawFfmpegCommands(options);
+  for (let i = 0; i < pair.length; i++) internal_exports.builtInDirectContextExecutors.add(pair[i].execute);
+  return pair;
+}
+function ffmpegCommands(options = {}) {
+  const definitions = createFfmpegCommands(options);
+  return {
+    name: "ffmpeg-commands",
+    setup(host) {
+      if (!options.replace) {
+        for (const definition of definitions) {
+          if (host.commands.has(definition.name)) {
+            throw new Error(`Command already registered: ${definition.name}`);
+          }
+        }
+      }
+      for (const definition of definitions) {
+        host.commands.register(definition, { replace: options.replace ?? false });
+      }
+    }
+  };
+}
+internal_exports.syncCommandEvaluators.evalSyncFfmpeg = evalSyncFfmpeg;
+internal_exports.syncCommandEvaluators.evalSyncFfprobe = evalSyncFfprobe;
+export {
+  createFfmpegCommand,
+  createFfmpegCommands,
+  createFfprobeCommand,
+  evalSyncFfmpeg,
+  evalSyncFfprobe,
+  ffmpegCommands
+};

package/dist/safe-bash/chunks/gh-HQWOWLWE.js

@@ -0,0 +1,41 @@
+import {
+  internal_exports
+} from "./chunk-GJWUEOT6.js";
+import {
+  init_platform
+} from "./chunk-Q45QCA4J.js";
+
+// packages/safe-bash/src/commands/gh/index.ts
+init_platform();
+import {
+  createGhCommand as createRawGhCommand,
+  createGhCommands as createRawGhCommands,
+  evalSyncGh
+} from "../../safe-bash-command-gh/index.js";
+export * from "../../safe-bash-command-gh/index.js";
+function createGhCommand(options = {}) {
+  const def = createRawGhCommand(options);
+  internal_exports.builtInDirectContextExecutors.add(def.execute);
+  return def;
+}
+function createGhCommands(options = {}) {
+  const defs = createRawGhCommands(options);
+  for (let i = 0; i < defs.length; i++) internal_exports.builtInDirectContextExecutors.add(defs[i].execute);
+  return defs;
+}
+function ghCommands(options = {}) {
+  const command = createGhCommand(options);
+  return {
+    name: "gh-commands",
+    setup(host) {
+      host.commands.register(command, { replace: options.replace ?? false });
+    }
+  };
+}
+internal_exports.syncCommandEvaluators.evalSyncGh = evalSyncGh;
+export {
+  createGhCommand,
+  createGhCommands,
+  evalSyncGh,
+  ghCommands
+};

package/dist/safe-bash/chunks/git-UFNPAOYZ.js

@@ -0,0 +1,52 @@
+import "./chunk-FJZNUUOQ.js";
+import "./chunk-O6356Z27.js";
+import "./chunk-T3VDYWKZ.js";
+import {
+  internal_exports
+} from "./chunk-GJWUEOT6.js";
+import {
+  init_platform
+} from "./chunk-Q45QCA4J.js";
+
+// packages/safe-bash/src/commands/git/index.ts
+init_platform();
+import {
+  createGitCommand as createBaseGitCommand,
+  createGitCommands as createBaseGitCommands,
+  evalSyncGit
+} from "../../safe-bash-command-git/index.js";
+function isDefaultOptions(options) {
+  return options === void 0 || options.http === void 0 && options.wasmModule === void 0 && options.limits === void 0;
+}
+function createGitCommand(options = {}) {
+  const def = createBaseGitCommand(options);
+  if (isDefaultOptions(options)) {
+    internal_exports.builtInDirectContextExecutors.add(def.execute);
+  }
+  return def;
+}
+function createGitCommands(options = {}) {
+  const defs = createBaseGitCommands(options);
+  if (isDefaultOptions(options)) {
+    for (const def of defs) internal_exports.builtInDirectContextExecutors.add(def.execute);
+  }
+  return defs;
+}
+function gitCommands(options = {}) {
+  const commands = createGitCommands(options);
+  return {
+    name: "git-commands",
+    setup(host) {
+      for (const command of commands) {
+        host.commands.register(command, { replace: options.replace ?? false });
+      }
+    }
+  };
+}
+internal_exports.syncCommandEvaluators.evalSyncGit = evalSyncGit;
+export {
+  createGitCommand,
+  createGitCommands,
+  evalSyncGit,
+  gitCommands
+};

package/dist/safe-bash/chunks/imagemagick-53BMHH6D.js

@@ -0,0 +1,134 @@
+import {
+  internal_exports
+} from "./chunk-GJWUEOT6.js";
+import {
+  init_platform
+} from "./chunk-Q45QCA4J.js";
+
+// packages/safe-bash/src/commands/imagemagick/index.ts
+init_platform();
+import {
+  createImagemagickCommands as createRawImagemagickCommands,
+  runIdentifyCliSync,
+  runConvertCliSync,
+  runMogrifyCliSync,
+  runCompositeCliSync,
+  runMontageCliSync,
+  runCompareCliSync,
+  runMagickCliSync
+} from "../../safe-bash-command-imagemagick/index.js";
+export * from "../../safe-bash-command-imagemagick/index.js";
+function createImagemagickCommands(options = {}) {
+  const defs = createRawImagemagickCommands(options);
+  for (let i = 0; i < defs.length; i++) internal_exports.builtInDirectContextExecutors.add(defs[i].execute);
+  return defs;
+}
+function imagemagickPlugin(options = {}) {
+  const commands = createImagemagickCommands(options);
+  const replace = options.replace ?? false;
+  return {
+    name: "imagemagick",
+    setup(host) {
+      for (const command of commands) host.commands.register(command, { replace });
+    }
+  };
+}
+var imagemagickCommands = imagemagickPlugin;
+var KNOWN_PREFIX_FORMATS = /* @__PURE__ */ new Set([
+  "png",
+  "png8",
+  "png24",
+  "png32",
+  "jpg",
+  "jpeg",
+  "gif",
+  "bmp",
+  "bmp2",
+  "bmp3",
+  "webp",
+  "tiff",
+  "tif",
+  "ppm",
+  "pgm",
+  "pbm",
+  "pnm",
+  "pam",
+  "svg",
+  "ico",
+  "cur",
+  "tga",
+  "hdr",
+  "exr",
+  "avif",
+  "heic",
+  "txt",
+  "info",
+  "json",
+  "null",
+  "histogram"
+]);
+function evalSyncIdentify(cmdName, inBytes, opArgs, readFileSync, writeFileSync) {
+  try {
+    if (opArgs[0] === "-version" || opArgs[0] === "--version") {
+      return runIdentifyCliSync(opArgs, /* @__PURE__ */ new Map()).stdout;
+    }
+    const vfsFiles = /* @__PURE__ */ new Map();
+    if (inBytes !== void 0) vfsFiles.set("-", inBytes);
+    for (let i = 0; i < opArgs.length; i++) {
+      const token = opArgs[i];
+      if (token === "-" || token.endsWith(":-")) continue;
+      if (token.startsWith("-") || token.startsWith("+") || token === "(" || token === ")") continue;
+      let candidate = token.toLowerCase().startsWith("tile:") ? token.slice(5) : token;
+      const prefixMatch = /^([a-zA-Z0-9]+):(.*)$/.exec(candidate);
+      if (prefixMatch && KNOWN_PREFIX_FORMATS.has(prefixMatch[1].toLowerCase())) {
+        candidate = prefixMatch[2];
+      }
+      const bracketMatch = /^(.*)\[([^\]]+)\]$/.exec(candidate);
+      if (bracketMatch) {
+        candidate = bracketMatch[1];
+      }
+      if (!candidate) continue;
+      const b = readFileSync?.(candidate);
+      if (b) {
+        if (b.byteLength > 262144) return void 0;
+        vfsFiles.set(candidate, b);
+      }
+    }
+    const existingSnap = new Map(vfsFiles);
+    const res = cmdName === "identify" ? runIdentifyCliSync(opArgs, vfsFiles, inBytes) : cmdName === "magick" ? runMagickCliSync(opArgs, vfsFiles, inBytes) : cmdName === "convert" ? runConvertCliSync(opArgs, vfsFiles, inBytes) : cmdName === "mogrify" ? runMogrifyCliSync(opArgs, vfsFiles) : cmdName === "composite" ? runCompositeCliSync(opArgs, vfsFiles, inBytes) : cmdName === "montage" ? runMontageCliSync(opArgs, vfsFiles, inBytes) : cmdName === "compare" ? runCompareCliSync(opArgs, vfsFiles, inBytes) : void 0;
+    if (!res || res.exitCode !== 0 || res.stderr) return void 0;
+    let hasWrites = false;
+    for (const [key, val] of vfsFiles.entries()) {
+      if (existingSnap.get(key) !== val) {
+        hasWrites = true;
+        break;
+      }
+    }
+    if (hasWrites && !writeFileSync) return void 0;
+    let outText = res.stdout;
+    if (res.stdoutBytes) {
+      try {
+        outText = new TextDecoder("utf-8", { fatal: true }).decode(res.stdoutBytes);
+      } catch {
+        return void 0;
+      }
+    }
+    if (hasWrites && writeFileSync) {
+      for (const [key, val] of vfsFiles.entries()) {
+        if (existingSnap.get(key) !== val) {
+          if (!writeFileSync(key, val)) return void 0;
+        }
+      }
+    }
+    return outText;
+  } catch {
+    return void 0;
+  }
+}
+internal_exports.syncCommandEvaluators.evalSyncIdentify = evalSyncIdentify;
+export {
+  createImagemagickCommands,
+  evalSyncIdentify,
+  imagemagickCommands,
+  imagemagickPlugin
+};

package/dist/safe-bash/chunks/implementation-QUTAAYMT.js

@@ -0,0 +1,105 @@
+import {
+  internal_exports
+} from "./chunk-GJWUEOT6.js";
+import {
+  init_platform
+} from "./chunk-Q45QCA4J.js";
+
+// packages/safe-bash/src/commands/pandoc/implementation.ts
+init_platform();
+import {
+  createPandocCommand as createRawPandocCommand,
+  createPandocCommands as createRawPandocCommands,
+  inspectFormats,
+  parseConversionArgs,
+  convertSync
+} from "../../safe-bash-command-pandoc/index.js";
+export * from "../../safe-bash-command-pandoc/index.js";
+function createPandocCommand(options = {}, hasCommand) {
+  const def = createRawPandocCommand(options, hasCommand);
+  if (options.limits === void 0 && options.filters === void 0 && options.jsonFilterCommand === void 0 && options.citeproc === void 0) {
+    internal_exports.builtInDirectContextExecutors.add(def.execute);
+  }
+  return def;
+}
+function createPandocCommands(options = {}) {
+  const defs = createRawPandocCommands(options);
+  if (options.limits === void 0 && options.filters === void 0 && options.jsonFilterCommand === void 0 && options.citeproc === void 0) {
+    for (let i = 0; i < defs.length; i++) internal_exports.builtInDirectContextExecutors.add(defs[i].execute);
+  }
+  return defs;
+}
+function pandocCommands(options = {}) {
+  let hasCommand;
+  const command = createPandocCommand(options, (name) => hasCommand?.(name) ?? false);
+  return {
+    name: "pandoc",
+    setup(host) {
+      hasCommand = (name) => host.commands.has(name);
+      host.commands.register(command, { replace: options.replace ?? false });
+    }
+  };
+}
+function evalSyncPandoc(inBytes, opArgs, readFileSync, writeFileSync) {
+  try {
+    if (opArgs.length > 0 && opArgs.every((a) => a === "--list-input-formats" || a === "--list-output-formats")) {
+      return inspectFormats(opArgs);
+    }
+    for (let i = 0; i < opArgs.length; i++) {
+      const a = opArgs[i];
+      if (a === "-d" || a === "--defaults" || a.startsWith("-d") || a.startsWith("--defaults=")) {
+        return void 0;
+      }
+    }
+    const signal = new AbortController().signal;
+    const parsed = parseConversionArgs(
+      opArgs,
+      {
+        cwd: "/",
+        ...inBytes === void 0 ? {} : { stdin: [inBytes] },
+        readFile: async () => new Uint8Array(0),
+        writeFile: async () => {
+        }
+      },
+      signal
+    );
+    const inputs = [];
+    if (!parsed.operands) {
+      if (inBytes === void 0 || inBytes.byteLength > 262144) return void 0;
+      inputs.push({ bytes: inBytes });
+    } else {
+      for (const op of parsed.operands) {
+        if (op.source === void 0) {
+          if (inBytes === void 0 || inBytes.byteLength > 262144) return void 0;
+          inputs.push({ bytes: inBytes });
+        } else {
+          if (parsed.destination && op.source === parsed.destination) return void 0;
+          const b = readFileSync?.(op.source);
+          if (!b || b.byteLength > 262144) return void 0;
+          inputs.push({ bytes: b, source: op.source, ...op.base === void 0 ? {} : { base: op.base } });
+        }
+      }
+    }
+    const serialized = convertSync(inputs, parsed.options);
+    if (!serialized) return void 0;
+    if (parsed.destination !== void 0) {
+      if (!writeFileSync) return void 0;
+      const outBytes = serialized.kind === "binary" ? serialized.bytes : new TextEncoder().encode(serialized.text);
+      if (!writeFileSync(parsed.destination, outBytes)) return void 0;
+      return "";
+    }
+    if (serialized.kind === "text") {
+      return serialized.text;
+    }
+    return new TextDecoder("utf-8", { fatal: true }).decode(serialized.bytes);
+  } catch {
+    return void 0;
+  }
+}
+internal_exports.syncCommandEvaluators.evalSyncPandoc = evalSyncPandoc;
+export {
+  createPandocCommand,
+  createPandocCommands,
+  evalSyncPandoc,
+  pandocCommands
+};

package/dist/safe-bash/chunks/pdfimages-4OYI6FLG.js

@@ -0,0 +1,73 @@
+import {
+  internal_exports
+} from "./chunk-GJWUEOT6.js";
+import {
+  init_platform
+} from "./chunk-Q45QCA4J.js";
+
+// packages/safe-bash/src/commands/pdfimages/index.ts
+init_platform();
+import {
+  createPdfimagesCommand as createRawPdfimagesCommand,
+  createPdfimagesCommands as createRawPdfimagesCommands,
+  runPdfimagesCliSync
+} from "../../safe-bash-command-pdfimages/index.js";
+export * from "../../safe-bash-command-pdfimages/index.js";
+function createPdfimagesCommand(options = {}) {
+  const def = createRawPdfimagesCommand(options);
+  internal_exports.builtInDirectContextExecutors.add(def.execute);
+  return def;
+}
+function createPdfimagesCommands(options = {}) {
+  const defs = createRawPdfimagesCommands(options);
+  for (let i = 0; i < defs.length; i++) internal_exports.builtInDirectContextExecutors.add(defs[i].execute);
+  return defs;
+}
+function pdfimagesPlugin(options = {}) {
+  const command = createPdfimagesCommand(options);
+  const replace = options.replace ?? false;
+  return {
+    name: "pdfimages",
+    setup(host) {
+      host.commands.register(command, { replace });
+    }
+  };
+}
+var pdfimagesCommands = pdfimagesPlugin;
+function evalSyncPdfimages(inBytes, opArgs, readFileSync, writeFileSync) {
+  try {
+    const files = /* @__PURE__ */ new Map();
+    if (inBytes !== void 0) files.set("-", inBytes);
+    for (let i = 0; i < opArgs.length; i++) {
+      const a = opArgs[i];
+      if (a === "-f" || a === "-l" || a === "-upw" || a === "-opw") {
+        i++;
+      } else if (!a.startsWith("-") && a !== "-") {
+        const b = readFileSync?.(a);
+        if (b) {
+          if (b.byteLength > 262144) return void 0;
+          files.set(a, b);
+        }
+      }
+    }
+    const snap = new Map(files);
+    const res = runPdfimagesCliSync(opArgs, files);
+    if (res.exitCode !== 0 || res.stderr) return void 0;
+    for (const [k, v] of files.entries()) {
+      if (snap.get(k) !== v) {
+        if (!writeFileSync || !writeFileSync(k, v)) return void 0;
+      }
+    }
+    return res.stdout;
+  } catch {
+    return void 0;
+  }
+}
+internal_exports.syncCommandEvaluators.evalSyncPdfimages = evalSyncPdfimages;
+export {
+  createPdfimagesCommand,
+  createPdfimagesCommands,
+  evalSyncPdfimages,
+  pdfimagesCommands,
+  pdfimagesPlugin
+};

package/dist/safe-bash/chunks/pdfinfo-I7U6TQPP.js

@@ -0,0 +1,153 @@
+import {
+  internal_exports
+} from "./chunk-GJWUEOT6.js";
+import {
+  init_platform
+} from "./chunk-Q45QCA4J.js";
+
+// packages/safe-bash/src/commands/pdfinfo/index.ts
+init_platform();
+import {
+  createPdfinfoCommand as createRawPdfinfoCommand,
+  createPdfinfoCommands as createRawPdfinfoCommands,
+  createPdffontsCommand as createRawPdffontsCommand,
+  createPdfdetachCommand as createRawPdfdetachCommand,
+  createPdftocairoCommand as createRawPdftocairoCommand,
+  inspectPdfBytes,
+  runPdffontsCliSync,
+  runPdfdetachCliSync
+} from "../../safe-bash-command-pdfinfo/index.js";
+export * from "../../safe-bash-command-pdfinfo/index.js";
+function createPdfinfoCommand(options = {}) {
+  const def = createRawPdfinfoCommand(options);
+  internal_exports.builtInDirectContextExecutors.add(def.execute);
+  return def;
+}
+function createPdffontsCommand(options = {}) {
+  const def = createRawPdffontsCommand(options);
+  internal_exports.builtInDirectContextExecutors.add(def.execute);
+  return def;
+}
+function createPdfdetachCommand(options = {}) {
+  const def = createRawPdfdetachCommand(options);
+  internal_exports.builtInDirectContextExecutors.add(def.execute);
+  return def;
+}
+function createPdftocairoCommand(options = {}) {
+  const def = createRawPdftocairoCommand(options);
+  internal_exports.builtInDirectContextExecutors.add(def.execute);
+  return def;
+}
+function createPdfinfoCommands(options = {}) {
+  const defs = createRawPdfinfoCommands(options);
+  for (let i = 0; i < defs.length; i++) internal_exports.builtInDirectContextExecutors.add(defs[i].execute);
+  return defs;
+}
+function pdfinfoCommands(options = {}) {
+  const commands = createPdfinfoCommands(options);
+  const replace = options.replace ?? false;
+  return {
+    name: "pdfinfo",
+    setup(host) {
+      for (const command of commands) host.commands.register(command, { replace });
+    }
+  };
+}
+function evalSyncPdfinfo(inBytes, opArgs, readFileSync) {
+  try {
+    let inputFile;
+    let isHelpOrVer = false;
+    for (let i = 0; i < opArgs.length; i++) {
+      const a = opArgs[i];
+      if (a === "-listenc" || a === "-v" || a === "--version" || a === "-h" || a === "--help" || a === "-?") {
+        isHelpOrVer = true;
+      } else if (a === "-f" || a === "-l" || a === "-enc" || a === "-upw" || a === "-opw") {
+        i++;
+      } else if (a === "--") {
+        if (i + 1 < opArgs.length) inputFile = opArgs[i + 1];
+        break;
+      } else if (!a.startsWith("-") || a === "-") {
+        if (inputFile === void 0) inputFile = a;
+      }
+    }
+    if (isHelpOrVer) {
+      const res2 = inspectPdfBytes(new Uint8Array(0), opArgs);
+      if (res2.exitCode !== 0 || res2.stderr) return void 0;
+      return res2.stdout;
+    }
+    const target = inputFile ?? "-";
+    const pdfBytes = target === "-" ? inBytes : readFileSync?.(target);
+    if (!pdfBytes || pdfBytes.byteLength > 262144) return void 0;
+    const res = inspectPdfBytes(
+      pdfBytes,
+      opArgs,
+      target === "-" ? { isStdin: true, fileSize: 0 } : { fileSize: pdfBytes.byteLength }
+    );
+    if (res.exitCode !== 0 || res.stderr) return void 0;
+    return res.stdout;
+  } catch {
+    return void 0;
+  }
+}
+function evalSyncPdffonts(inBytes, opArgs, readFileSync) {
+  try {
+    const files = /* @__PURE__ */ new Map();
+    if (inBytes !== void 0) files.set("-", inBytes);
+    for (let i = 0; i < opArgs.length; i++) {
+      const a = opArgs[i];
+      if (a === "-f" || a === "-l" || a === "-upw" || a === "-opw") {
+        i++;
+      } else if (!a.startsWith("-") && a !== "-") {
+        const b = readFileSync?.(a);
+        if (!b || b.byteLength > 262144) return void 0;
+        files.set(a, b);
+      }
+    }
+    const res = runPdffontsCliSync(opArgs, files);
+    if (res.exitCode !== 0 || res.stderr) return void 0;
+    return res.stdout;
+  } catch {
+    return void 0;
+  }
+}
+function evalSyncPdfdetach(inBytes, opArgs, readFileSync, writeFileSync) {
+  try {
+    const files = /* @__PURE__ */ new Map();
+    if (inBytes !== void 0) files.set("-", inBytes);
+    for (let i = 0; i < opArgs.length; i++) {
+      const a = opArgs[i];
+      if (a === "-upw" || a === "-opw" || a === "-enc" || a === "-save" || a === "-savefile" || a === "-o") {
+        i++;
+      } else if (!a.startsWith("-") && a !== "-") {
+        const b = readFileSync?.(a);
+        if (!b || b.byteLength > 262144) return void 0;
+        files.set(a, b);
+      }
+    }
+    const snap = new Map(files);
+    const res = runPdfdetachCliSync(opArgs, files);
+    if (res.exitCode !== 0 || res.stderr) return void 0;
+    for (const [k, v] of files.entries()) {
+      if (snap.get(k) !== v) {
+        if (!writeFileSync || !writeFileSync(k, v)) return void 0;
+      }
+    }
+    return res.stdout;
+  } catch {
+    return void 0;
+  }
+}
+internal_exports.syncCommandEvaluators.evalSyncPdfinfo = evalSyncPdfinfo;
+internal_exports.syncCommandEvaluators.evalSyncPdffonts = evalSyncPdffonts;
+internal_exports.syncCommandEvaluators.evalSyncPdfdetach = evalSyncPdfdetach;
+export {
+  createPdfdetachCommand,
+  createPdffontsCommand,
+  createPdfinfoCommand,
+  createPdfinfoCommands,
+  createPdftocairoCommand,
+  evalSyncPdfdetach,
+  evalSyncPdffonts,
+  evalSyncPdfinfo,
+  pdfinfoCommands
+};

package/dist/safe-bash/chunks/pdftk-SUA6FMHI.js

@@ -0,0 +1,79 @@
+import {
+  internal_exports
+} from "./chunk-GJWUEOT6.js";
+import {
+  init_platform
+} from "./chunk-Q45QCA4J.js";
+
+// packages/safe-bash/src/commands/pdftk/index.ts
+init_platform();
+import {
+  createPdftkCommand as createRawPdftkCommand,
+  createPdftkCommands as createRawPdftkCommands,
+  runPdftkCliSync
+} from "../../safe-bash-command-pdftk/index.js";
+export * from "../../safe-bash-command-pdftk/index.js";
+function isDefaultPdftkOptions(options) {
+  if (!options) return true;
+  const o = options;
+  return o.limits === void 0 && o.maxInputBytes === void 0 && o.maxOutputBytes === void 0;
+}
+function createPdftkCommand(options = {}) {
+  const def = createRawPdftkCommand(options);
+  if (isDefaultPdftkOptions(options)) internal_exports.builtInDirectContextExecutors.add(def.execute);
+  return def;
+}
+function createPdftkCommands(options = {}) {
+  const defs = createRawPdftkCommands(options);
+  if (isDefaultPdftkOptions(options)) {
+    for (let i = 0; i < defs.length; i++) internal_exports.builtInDirectContextExecutors.add(defs[i].execute);
+  }
+  return defs;
+}
+function pdftkPlugin(options = {}) {
+  const command = createPdftkCommand(options);
+  const replace = options.replace ?? false;
+  return {
+    name: "pdftk",
+    setup(host) {
+      host.commands.register(command, { replace });
+    }
+  };
+}
+var pdftkCommands = pdftkPlugin;
+function evalSyncPdftk(inBytes, opArgs, readFileSync, writeFileSync) {
+  try {
+    const files = /* @__PURE__ */ new Map();
+    if (inBytes !== void 0) files.set("-", inBytes);
+    for (const token of opArgs) {
+      if (token.startsWith("-") && token !== "-") continue;
+      const eq = token.indexOf("=");
+      const filePath = eq > 0 ? token.slice(eq + 1) : token;
+      if (filePath === "-") continue;
+      const b = readFileSync?.(filePath);
+      if (b) {
+        if (b.byteLength > 262144) return void 0;
+        files.set(filePath, b);
+      }
+    }
+    const snap = new Map(files);
+    const res = runPdftkCliSync(opArgs, files);
+    if (res.exitCode !== 0 || res.stderr || res.stdoutBytes) return void 0;
+    for (const [k, v] of files.entries()) {
+      if (snap.get(k) !== v) {
+        if (!writeFileSync || !writeFileSync(k, v)) return void 0;
+      }
+    }
+    return res.stdout;
+  } catch {
+    return void 0;
+  }
+}
+internal_exports.syncCommandEvaluators.evalSyncPdftk = evalSyncPdftk;
+export {
+  createPdftkCommand,
+  createPdftkCommands,
+  evalSyncPdftk,
+  pdftkCommands,
+  pdftkPlugin
+};