@poe-platform/safe-bash 0.1.802 → 0.1.804

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

@@ -0,0 +1,887 @@
+import {
+  CommandRegistry,
+  commandRuntimeIdentity
+} from "./chunk-OHML2BEU.js";
+import {
+  init_platform
+} from "./chunk-PTAEWLSE.js";
+
+// packages/safe-bash/src/plugins/lazy-command.ts
+init_platform();
+function createLazyCommandLoader(load) {
+  let pending;
+  return () => pending ??= Promise.resolve().then(load).catch((error) => {
+    pending = void 0;
+    throw error;
+  });
+}
+async function waitForCode(pending, signal) {
+  signal.throwIfAborted();
+  let abort;
+  const cancelled = new Promise((_resolve, reject) => {
+    abort = () => reject(signal.reason);
+    signal.addEventListener("abort", abort, { once: true });
+  });
+  try {
+    return await Promise.race([pending, cancelled]);
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}
+function createLazyCommands(metadata, load) {
+  return Object.freeze(
+    metadata.map(
+      (item) => Object.freeze({
+        ...item,
+        runtimeIdentity: commandRuntimeIdentity,
+        async execute(context) {
+          context.signal.throwIfAborted();
+          const factory = await waitForCode(load(), context.signal);
+          context.signal.throwIfAborted();
+          const definition = factory().find((command) => command.name === item.name);
+          if (!definition) throw new Error(`Lazy command loader did not provide ${item.name}`);
+          return definition.execute(context);
+        }
+      })
+    )
+  );
+}
+function lazyCommandPlugin(name, commands, replace = false) {
+  return {
+    name,
+    setup(host) {
+      if (!replace)
+        for (const command of commands) {
+          const existing = host.commands.get(command.name);
+          if (existing && !(command.fallback && !existing.fallback))
+            throw new Error(`Command already registered: ${command.name}`);
+        }
+      for (const command of commands) host.commands.register(command, { replace });
+    }
+  };
+}
+
+// packages/safe-bash/src/lazy-gh.ts
+init_platform();
+var loadgh = /* @__PURE__ */ createLazyCommandLoader(() => import("./gh-4MBJ2S5V.js"));
+var ghMetadata = [
+  { name: "gh", description: "Work seamlessly with GitHub from the command line" }
+];
+var createGhCommand = (options = {}) => {
+  const backends = /* @__PURE__ */ new WeakMap();
+  return createLazyCommands(ghMetadata, async () => {
+    const module = await loadgh();
+    return () => [{
+      ...ghMetadata[0],
+      async execute(context) {
+        let backend = options.backend ?? backends.get(context.fs);
+        if (!backend) {
+          backend = module.createGitHubBackend({
+            defaultHost: options.defaultHost,
+            defaultUser: options.defaultUser,
+            defaultToken: options.defaultToken,
+            now: options.now
+          });
+          backends.set(context.fs, backend);
+        }
+        return module.createGhCommand({ ...options, backend }).execute(context);
+      }
+    }];
+  })[0];
+};
+var createGhCommands = (options = {}) => [createGhCommand(options)];
+var ghCommands = (options = {}) => lazyCommandPlugin("gh-commands", createGhCommands(options), options.replace ?? false);
+
+// packages/safe-bash/src/lazy-optional.ts
+init_platform();
+import { validatePandocOptions } from "../../safe-bash-command-pandoc/options.js";
+var loadffmpeg = /* @__PURE__ */ createLazyCommandLoader(() => import("./ffmpeg-YANDK6HU.js"));
+var ffmpegMetadata = [
+  {
+    name: "ffmpeg",
+    description: "Multimedia converter, merger, and stream processor powered by pluggable ASTs"
+  },
+  {
+    name: "ffprobe",
+    description: "Multimedia stream analyzer powered by pluggable ASTs"
+  }
+];
+var createFfmpegCommand = (...args) => {
+  const metadata = ffmpegMetadata.find((item) => item.name === "ffmpeg");
+  if (!metadata) throw new TypeError("Unknown ffmpeg command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadffmpeg();
+    return () => [module.createFfmpegCommand(...args)];
+  })[0];
+};
+var createFfprobeCommand = (...args) => {
+  const metadata = ffmpegMetadata.find((item) => item.name === "ffprobe");
+  if (!metadata) throw new TypeError("Unknown ffmpeg command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadffmpeg();
+    return () => [module.createFfprobeCommand(...args)];
+  })[0];
+};
+var createFfmpegCommands = (...args) => {
+  const definitions = createLazyCommands(ffmpegMetadata, async () => {
+    const module = await loadffmpeg();
+    return () => module.createFfmpegCommands(...args);
+  });
+  return Object.freeze(
+    Object.assign([definitions[0], definitions[1]], {
+      ffmpeg: definitions[0],
+      ffprobe: definitions[1]
+    })
+  );
+};
+var ffmpegCommands = (options = {}) => lazyCommandPlugin("ffmpeg-commands", createFfmpegCommands(options), options.replace ?? false);
+var loadgit = /* @__PURE__ */ createLazyCommandLoader(() => import("./git-2QONJNRQ.js"));
+var gitMetadata = [
+  {
+    name: "git",
+    description: "Git repositories in the virtual filesystem"
+  }
+];
+var gitCommands = (options = {}) => lazyCommandPlugin("git-commands", createGitCommands(options), options.replace ?? false);
+var createGitCommands = (...args) => {
+  const definitions = createLazyCommands(gitMetadata, async () => {
+    const module = await loadgit();
+    return () => module.createGitCommands(...args);
+  });
+  return definitions;
+};
+var createGitCommand = (...args) => {
+  const metadata = gitMetadata.find((item) => item.name === "git");
+  if (!metadata) throw new TypeError("Unknown git command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadgit();
+    return () => [module.createGitCommand(...args)];
+  })[0];
+};
+var loadsoffice = /* @__PURE__ */ createLazyCommandLoader(() => import("./soffice-RAJU3JUT.js"));
+var sofficeMetadata = [
+  {
+    name: "soffice",
+    description: "Headless document/spreadsheet/presentation to PDF and CSV converter via @poe-code/pdf-ast"
+  },
+  {
+    name: "libreoffice",
+    description: "Headless LibreOffice document/spreadsheet/presentation to PDF converter via @poe-code/pdf-ast"
+  }
+];
+var createSofficeCommand = (...args) => {
+  const metadata = sofficeMetadata.find((item) => item.name === "soffice");
+  if (!metadata) throw new TypeError("Unknown soffice command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadsoffice();
+    return () => [module.createSofficeCommand(...args)];
+  })[0];
+};
+var sofficeCommands = (options = {}) => lazyCommandPlugin("soffice", createSofficeCommands(options), options.replace ?? false);
+var createSofficeCommands = (...args) => {
+  const definitions = createLazyCommands(sofficeMetadata, async () => {
+    const module = await loadsoffice();
+    return () => module.createSofficeCommands(...args);
+  });
+  return definitions;
+};
+var loadpandoc = /* @__PURE__ */ createLazyCommandLoader(() => import("../../safe-bash-command-pandoc/index.js"));
+var pandocMetadata = [
+  {
+    name: "pandoc",
+    description: "Convert documents with the original bounded TypeScript SDK"
+  }
+];
+var 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 });
+    }
+  };
+};
+var createPandocCommands = (...args) => {
+  validatePandocOptions(args[0] === void 0 ? {} : args[0]);
+  const definitions = createLazyCommands(pandocMetadata, async () => {
+    const module = await loadpandoc();
+    return () => module.createPandocCommands(...args);
+  });
+  return definitions;
+};
+var createPandocCommand = (...args) => {
+  validatePandocOptions(args[0] === void 0 ? {} : args[0]);
+  const metadata = pandocMetadata.find((item) => item.name === "pandoc");
+  if (!metadata) throw new TypeError("Unknown pandoc command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadpandoc();
+    return () => [module.createPandocCommand(...args)];
+  })[0];
+};
+var loadssconvert = /* @__PURE__ */ createLazyCommandLoader(() => import("../../safe-bash-command-ssconvert/index.js"));
+var loadSelectedSsconvert = /* @__PURE__ */ createLazyCommandLoader(
+  () => import("../../safe-bash-command-ssconvert/commands.js")
+);
+var ssconvertMetadata = [
+  {
+    name: "ssconvert",
+    description: "Explicitly bound TypeScript spreadsheet conversion engine"
+  }
+];
+var createSsconvertCommand = (...args) => {
+  const metadata = ssconvertMetadata.find((item) => item.name === "ssconvert");
+  if (!metadata) throw new TypeError("Unknown ssconvert command");
+  return createLazyCommands([metadata], async () => {
+    const module = await (args[0]?.formats === void 0 ? loadssconvert() : loadSelectedSsconvert());
+    return () => [module.createSsconvertCommand(...args)];
+  })[0];
+};
+var ssconvertCommands = (options = {}) => lazyCommandPlugin(
+  "ssconvert-commands",
+  createSsconvertCommands(options),
+  options.replace ?? false
+);
+var createSsconvertCommands = (...args) => {
+  const definitions = createLazyCommands(ssconvertMetadata, async () => {
+    const module = await (args[0]?.formats === void 0 ? loadssconvert() : loadSelectedSsconvert());
+    return () => module.createSsconvertCommands(...args);
+  });
+  return definitions;
+};
+var loadpdfinfo = /* @__PURE__ */ createLazyCommandLoader(() => import("./pdfinfo-L3SGWPNG.js"));
+var pdfinfoMetadata = [
+  {
+    name: "pdfinfo",
+    description: "Extract PDF metadata, page boxes, encryption, and structure via @poe-code/pdf-ast"
+  },
+  {
+    name: "pdfunite",
+    description: "Merge multiple PDF documents into a single PDF via @poe-code/pdf-ast"
+  },
+  {
+    name: "pdfseparate",
+    description: "Split PDF pages into individual PDF files via @poe-code/pdf-ast"
+  },
+  {
+    name: "pdffonts",
+    description: "List fonts used in a PDF document via @poe-code/pdf-ast"
+  },
+  {
+    name: "pdfdetach",
+    description: "List and extract embedded file attachments from PDF documents via @poe-code/pdf-ast"
+  }
+];
+var createPdfinfoCommand = (...args) => {
+  const metadata = pdfinfoMetadata.find((item) => item.name === "pdfinfo");
+  if (!metadata) throw new TypeError("Unknown pdfinfo command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadpdfinfo();
+    return () => [module.createPdfinfoCommand(...args)];
+  })[0];
+};
+var pdfinfoCommands = (options = {}) => lazyCommandPlugin("pdfinfo", createPdfinfoCommands(options), options.replace ?? false);
+var createPdfinfoCommands = (...args) => {
+  const definitions = createLazyCommands(pdfinfoMetadata, async () => {
+    const module = await loadpdfinfo();
+    return () => module.createPdfinfoCommands(...args);
+  });
+  return definitions;
+};
+var loadpdftotext = /* @__PURE__ */ createLazyCommandLoader(() => import("./pdftotext-4IHNWT6F.js"));
+var pdftotextMetadata = [
+  {
+    name: "pdftotext",
+    description: "Extract PDF text, layout, XHTML bounding boxes, and TSV via @poe-code/pdf-ast"
+  },
+  {
+    name: "pdftohtml",
+    description: "Convert PDF pages into HTML or XML layout documents via @poe-code/pdf-ast"
+  }
+];
+var createPdftotextCommand = (...args) => {
+  const metadata = pdftotextMetadata.find((item) => item.name === "pdftotext");
+  if (!metadata) throw new TypeError("Unknown pdftotext command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadpdftotext();
+    return () => [module.createPdftotextCommand(...args)];
+  })[0];
+};
+var pdftotextCommands = (options = {}) => lazyCommandPlugin(
+  "pdftotext",
+  createPdftotextCommands(options),
+  options.replace ?? false
+);
+var createPdftotextCommands = (...args) => {
+  const definitions = createLazyCommands(pdftotextMetadata, async () => {
+    const module = await loadpdftotext();
+    return () => module.createPdftotextCommands(...args);
+  });
+  return definitions;
+};
+var loadpdfimages = /* @__PURE__ */ createLazyCommandLoader(() => import("./pdfimages-RSHL7LOP.js"));
+var pdfimagesMetadata = [
+  {
+    name: "pdfimages",
+    description: "List and extract embedded images from PDF pages via @poe-code/pdf-ast"
+  }
+];
+var createPdfimagesCommand = (...args) => {
+  const metadata = pdfimagesMetadata.find((item) => item.name === "pdfimages");
+  if (!metadata) throw new TypeError("Unknown pdfimages command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadpdfimages();
+    return () => [module.createPdfimagesCommand(...args)];
+  })[0];
+};
+var pdfimagesCommands = (options = {}) => lazyCommandPlugin(
+  "pdfimages",
+  createPdfimagesCommands(options),
+  options.replace ?? false
+);
+var createPdfimagesCommands = (...args) => {
+  const definitions = createLazyCommands(pdfimagesMetadata, async () => {
+    const module = await loadpdfimages();
+    return () => module.createPdfimagesCommands(...args);
+  });
+  return definitions;
+};
+var loadpdftoppm = /* @__PURE__ */ createLazyCommandLoader(() => import("./pdftoppm-NXXFUIHG.js"));
+var pdftoppmMetadata = [
+  {
+    name: "pdftoppm",
+    description: "Render PDF pages to PNG, PPM, PGM, PBM, or SVG via @poe-code/pdf-ast"
+  },
+  {
+    name: "pdftocairo",
+    description: "Render PDF pages to PNG, JPEG, TIFF, PDF, PS, EPS, or SVG via @poe-code/pdf-ast"
+  }
+];
+var createPdftoppmCommand = (...args) => {
+  const metadata = pdftoppmMetadata.find((item) => item.name === "pdftoppm");
+  if (!metadata) throw new TypeError("Unknown pdftoppm command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadpdftoppm();
+    return () => [module.createPdftoppmCommand(...args)];
+  })[0];
+};
+var pdftoppmCommands = (options = {}) => lazyCommandPlugin("pdftoppm", createPdftoppmCommands(options), options.replace ?? false);
+var createPdftoppmCommands = (...args) => {
+  const definitions = createLazyCommands(pdftoppmMetadata, async () => {
+    const module = await loadpdftoppm();
+    return () => module.createPdftoppmCommands(...args);
+  });
+  return definitions;
+};
+var loadpdftk = /* @__PURE__ */ createLazyCommandLoader(() => import("./pdftk-LFBJNU5A.js"));
+var pdftkMetadata = [
+  {
+    name: "pdftk",
+    description: "Manipulate PDF documents, fill/flatten AcroForms, and assemble pages via @poe-code/pdf-ast"
+  }
+];
+var createPdftkCommand = (...args) => {
+  const metadata = pdftkMetadata.find((item) => item.name === "pdftk");
+  if (!metadata) throw new TypeError("Unknown pdftk command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadpdftk();
+    return () => [module.createPdftkCommand(...args)];
+  })[0];
+};
+var pdftkCommands = (options = {}) => lazyCommandPlugin("pdftk", createPdftkCommands(options), options.replace ?? false);
+var createPdftkCommands = (...args) => {
+  const definitions = createLazyCommands(pdftkMetadata, async () => {
+    const module = await loadpdftk();
+    return () => module.createPdftkCommands(...args);
+  });
+  return definitions;
+};
+var loadqpdf = /* @__PURE__ */ createLazyCommandLoader(() => import("./qpdf-ZEIREV63.js"));
+var qpdfMetadata = [
+  {
+    name: "qpdf",
+    description: "Structural PDF inspection, encryption, page selection, and transformation via @poe-code/pdf-ast"
+  }
+];
+var createQpdfCommand = (...args) => {
+  const metadata = qpdfMetadata.find((item) => item.name === "qpdf");
+  if (!metadata) throw new TypeError("Unknown qpdf command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadqpdf();
+    return () => [module.createQpdfCommand(...args)];
+  })[0];
+};
+var qpdfCommands = (options = {}) => lazyCommandPlugin("qpdf", createQpdfCommands(options), options.replace ?? false);
+var createQpdfCommands = (...args) => {
+  const definitions = createLazyCommands(qpdfMetadata, async () => {
+    const module = await loadqpdf();
+    return () => module.createQpdfCommands(...args);
+  });
+  return definitions;
+};
+var loadsips = /* @__PURE__ */ createLazyCommandLoader(() => import("./sips-D5YBG2V3.js"));
+var sipsMetadata = [
+  {
+    name: "sips",
+    description: "Scriptable image processing system powered by @poe-code/image-ast"
+  }
+];
+var createSipsCommand = (...args) => {
+  const metadata = sipsMetadata.find((item) => item.name === "sips");
+  if (!metadata) throw new TypeError("Unknown sips command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadsips();
+    return () => [module.createSipsCommand(...args)];
+  })[0];
+};
+var sipsCommands = (options = {}) => lazyCommandPlugin("sips", createSipsCommands(options), options.replace ?? false);
+var createSipsCommands = (...args) => {
+  const definitions = createLazyCommands(sipsMetadata, async () => {
+    const module = await loadsips();
+    return () => module.createSipsCommands(...args);
+  });
+  return definitions;
+};
+var loadimagemagick = /* @__PURE__ */ createLazyCommandLoader(() => import("./imagemagick-JLEHGYSN.js"));
+var imagemagickMetadata = [
+  {
+    name: "magick",
+    description: "ImageMagick v7 image processor powered by @poe-code/image-ast"
+  },
+  {
+    name: "convert",
+    description: "ImageMagick convert pipeline powered by @poe-code/image-ast"
+  },
+  {
+    name: "mogrify",
+    description: "ImageMagick in-place batch image processor powered by @poe-code/image-ast"
+  },
+  {
+    name: "composite",
+    description: "ImageMagick overlay composition tool powered by @poe-code/image-ast"
+  },
+  {
+    name: "montage",
+    description: "ImageMagick contact-sheet grid generator powered by @poe-code/image-ast"
+  },
+  {
+    name: "identify",
+    description: "ImageMagick image metadata inspector powered by @poe-code/image-ast"
+  },
+  {
+    name: "compare",
+    description: "ImageMagick image comparison and diff generator powered by @poe-code/image-ast"
+  }
+];
+var createMagickCommand = (...args) => {
+  const metadata = imagemagickMetadata.find((item) => item.name === "magick");
+  if (!metadata) throw new TypeError("Unknown imagemagick command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadimagemagick();
+    return () => [module.createMagickCommand(...args)];
+  })[0];
+};
+var imagemagickCommands = (options = {}) => lazyCommandPlugin(
+  "imagemagick",
+  createImagemagickCommands(options),
+  options.replace ?? false
+);
+var createImagemagickCommands = (...args) => {
+  const definitions = createLazyCommands(imagemagickMetadata, async () => {
+    const module = await loadimagemagick();
+    return () => module.createImagemagickCommands(...args);
+  });
+  return definitions;
+};
+var createImagemagickCommand = (...args) => {
+  const metadata = imagemagickMetadata.find((item) => item.name === "magick");
+  if (!metadata) throw new TypeError("Unknown imagemagick command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadimagemagick();
+    return () => [module.createImagemagickCommand(...args)];
+  })[0];
+};
+var loadwkhtmltopdf = /* @__PURE__ */ createLazyCommandLoader(() => import("./wkhtmltopdf-7UE4FORZ.js"));
+var wkhtmltopdfMetadata = [
+  {
+    name: "wkhtmltopdf",
+    description: "Bounded static HTML-to-PDF adapter with a built-in PDF AST renderer"
+  }
+];
+var createWkhtmltopdfCommand = (...args) => {
+  const metadata = wkhtmltopdfMetadata.find((item) => item.name === "wkhtmltopdf");
+  if (!metadata) throw new TypeError("Unknown wkhtmltopdf command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadwkhtmltopdf();
+    return () => [module.createWkhtmltopdfCommand(...args)];
+  })[0];
+};
+var wkhtmltopdfCommands = (options = {}) => lazyCommandPlugin(
+  "wkhtmltopdf",
+  createWkhtmltopdfCommands(options),
+  options.replace ?? false
+);
+var createWkhtmltopdfCommands = (...args) => {
+  const definitions = createLazyCommands(wkhtmltopdfMetadata, async () => {
+    const module = await loadwkhtmltopdf();
+    return () => module.createWkhtmltopdfCommands(...args);
+  });
+  return definitions;
+};
+var loadcsvkit = /* @__PURE__ */ createLazyCommandLoader(() => import("../commands/csvkit/index.browser.js"));
+var csvkitMetadata = [
+  {
+    name: "csvclean",
+    description: "csvkit 2.2.0 csvclean; compatibility gaps return status 78"
+  },
+  {
+    name: "csvcut",
+    description: "csvkit 2.2.0 csvcut; compatibility gaps return status 78",
+    fallback: true
+  },
+  {
+    name: "csvformat",
+    description: "csvkit 2.2.0 csvformat; compatibility gaps return status 78"
+  },
+  {
+    name: "csvgrep",
+    description: "csvkit 2.2.0 csvgrep; compatibility gaps return status 78",
+    fallback: true
+  },
+  {
+    name: "csvjoin",
+    description: "csvkit 2.2.0 csvjoin; compatibility gaps return status 78"
+  },
+  {
+    name: "csvjson",
+    description: "csvkit 2.2.0 csvjson; compatibility gaps return status 78"
+  },
+  {
+    name: "csvlook",
+    description: "csvkit 2.2.0 csvlook; compatibility gaps return status 78"
+  },
+  {
+    name: "csvpy",
+    description: "csvkit 2.2.0 csvpy; compatibility gaps return status 78"
+  },
+  {
+    name: "csvsort",
+    description: "csvkit 2.2.0 csvsort; compatibility gaps return status 78"
+  },
+  {
+    name: "csvsql",
+    description: "csvkit 2.2.0 csvsql; compatibility gaps return status 78"
+  },
+  {
+    name: "csvstack",
+    description: "csvkit 2.2.0 csvstack; compatibility gaps return status 78"
+  },
+  {
+    name: "csvstat",
+    description: "csvkit 2.2.0 csvstat; compatibility gaps return status 78"
+  },
+  {
+    name: "in2csv",
+    description: "csvkit 2.2.0 in2csv; compatibility gaps return status 78"
+  },
+  {
+    name: "sql2csv",
+    description: "csvkit 2.2.0 sql2csv; compatibility gaps return status 78"
+  }
+];
+var csvkitCommands = (options = {}) => lazyCommandPlugin("csvkit-commands", createCsvkitCommands(options), options.replace ?? false);
+var createCsvkitCommands = (...args) => {
+  const definitions = createLazyCommands(csvkitMetadata, async () => {
+    const module = await loadcsvkit();
+    return () => module.createCsvkitCommands(...args);
+  });
+  return definitions;
+};
+var createCsvkitCommand = (...args) => {
+  const metadata = csvkitMetadata.find((item) => item.name === (args[0]?.name ?? "csvclean"));
+  if (!metadata) throw new TypeError("Unknown csvkit command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadcsvkit();
+    return () => [module.createCsvkitCommand(...args)];
+  })[0];
+};
+var optionalFamilies = {
+  ffmpeg: {
+    metadata: ffmpegMetadata,
+    create: (options) => createFfmpegCommands(options.ffmpeg)
+  },
+  git: {
+    metadata: gitMetadata,
+    create: (options) => createGitCommands(options.git)
+  },
+  soffice: {
+    metadata: sofficeMetadata,
+    create: (options) => createSofficeCommands(options.soffice)
+  },
+  pandoc: {
+    metadata: pandocMetadata,
+    create: (options) => createPandocCommands(options.pandoc)
+  },
+  ssconvert: {
+    metadata: ssconvertMetadata,
+    create: (options) => createSsconvertCommands(options.ssconvert)
+  },
+  pdfinfo: {
+    metadata: pdfinfoMetadata,
+    create: (options) => createPdfinfoCommands(options.pdfinfo)
+  },
+  pdftotext: {
+    metadata: pdftotextMetadata,
+    create: (options) => createPdftotextCommands(options.pdftotext)
+  },
+  pdfimages: {
+    metadata: pdfimagesMetadata,
+    create: (options) => createPdfimagesCommands(options.pdfimages)
+  },
+  pdftoppm: {
+    metadata: pdftoppmMetadata,
+    create: (options) => createPdftoppmCommands(options.pdftoppm)
+  },
+  pdftk: {
+    metadata: pdftkMetadata,
+    create: (options) => createPdftkCommands(options.pdftk)
+  },
+  qpdf: {
+    metadata: qpdfMetadata,
+    create: (options) => createQpdfCommands(options.qpdf)
+  },
+  sips: {
+    metadata: sipsMetadata,
+    create: (options) => createSipsCommands(options.sips)
+  },
+  imagemagick: {
+    metadata: imagemagickMetadata,
+    create: (options) => createImagemagickCommands(options.imagemagick)
+  },
+  wkhtmltopdf: {
+    metadata: wkhtmltopdfMetadata,
+    create: (options) => createWkhtmltopdfCommands(options.wkhtmltopdf)
+  },
+  csvkit: {
+    metadata: csvkitMetadata,
+    create: (options) => createCsvkitCommands(options.csvkit)
+  },
+  gh: {
+    metadata: ghMetadata,
+    create: (options) => createGhCommands(options.gh)
+  }
+};
+var optionalCommandCatalog = Object.freeze(
+  Object.entries(optionalFamilies).flatMap(
+    ([family, entry]) => entry.metadata.map(
+      (metadata) => Object.freeze({ family, ...metadata })
+    )
+  )
+);
+function createOptionalCommands(options = {}) {
+  const names = new Set(options.commands ?? []);
+  for (const name of names)
+    if (!optionalCommandCatalog.some((metadata) => metadata.name === name)) {
+      throw new TypeError(`Unknown optional command: ${name}`);
+    }
+  const families = new Set(options.families ?? []);
+  for (const family of families)
+    if (!Object.hasOwn(optionalFamilies, family)) {
+      throw new TypeError(`Unknown optional command family: ${family}`);
+    }
+  const definitions = [];
+  for (const [family, entry] of Object.entries(optionalFamilies)) {
+    const fullFamily = options.profile === "full" || families.has(family);
+    if (!fullFamily && !entry.metadata.some((metadata) => names.has(metadata.name))) continue;
+    definitions.push(
+      ...entry.create(options.configuration ?? {}).filter((command) => fullFamily || names.has(command.name)).map((command) => options.profile === "full" ? Object.freeze({ ...command, fallback: true }) : command)
+    );
+  }
+  return new CommandRegistry(definitions).list();
+}
+function optionalCommands(options = {}) {
+  return lazyCommandPlugin(
+    "optional-commands",
+    createOptionalCommands(options),
+    options.replace ?? false
+  );
+}
+var createConvertCommand = (...args) => {
+  const metadata = imagemagickMetadata.find((item) => item.name === "convert");
+  if (!metadata) throw new TypeError("Unknown convert command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadimagemagick();
+    return () => [module.createConvertCommand(...args)];
+  })[0];
+};
+var createMogrifyCommand = (...args) => {
+  const metadata = imagemagickMetadata.find((item) => item.name === "mogrify");
+  if (!metadata) throw new TypeError("Unknown mogrify command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadimagemagick();
+    return () => [module.createMogrifyCommand(...args)];
+  })[0];
+};
+var createCompositeCommand = (...args) => {
+  const metadata = imagemagickMetadata.find((item) => item.name === "composite");
+  if (!metadata) throw new TypeError("Unknown composite command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadimagemagick();
+    return () => [module.createCompositeCommand(...args)];
+  })[0];
+};
+var createMontageCommand = (...args) => {
+  const metadata = imagemagickMetadata.find((item) => item.name === "montage");
+  if (!metadata) throw new TypeError("Unknown montage command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadimagemagick();
+    return () => [module.createMontageCommand(...args)];
+  })[0];
+};
+var createIdentifyCommand = (...args) => {
+  const metadata = imagemagickMetadata.find((item) => item.name === "identify");
+  if (!metadata) throw new TypeError("Unknown identify command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadimagemagick();
+    return () => [module.createIdentifyCommand(...args)];
+  })[0];
+};
+var createCompareCommand = (...args) => {
+  const metadata = imagemagickMetadata.find((item) => item.name === "compare");
+  if (!metadata) throw new TypeError("Unknown compare command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadimagemagick();
+    return () => [module.createCompareCommand(...args)];
+  })[0];
+};
+var createPdfuniteCommand = (...args) => {
+  const metadata = pdfinfoMetadata.find((item) => item.name === "pdfunite");
+  if (!metadata) throw new TypeError("Unknown pdfunite command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadpdfinfo();
+    return () => [module.createPdfuniteCommand(...args)];
+  })[0];
+};
+var createPdfseparateCommand = (...args) => {
+  const metadata = pdfinfoMetadata.find((item) => item.name === "pdfseparate");
+  if (!metadata) throw new TypeError("Unknown pdfseparate command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadpdfinfo();
+    return () => [module.createPdfseparateCommand(...args)];
+  })[0];
+};
+var createPdffontsCommand = (...args) => {
+  const metadata = pdfinfoMetadata.find((item) => item.name === "pdffonts");
+  if (!metadata) throw new TypeError("Unknown pdffonts command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadpdfinfo();
+    return () => [module.createPdffontsCommand(...args)];
+  })[0];
+};
+var createPdfdetachCommand = (...args) => {
+  const metadata = pdfinfoMetadata.find((item) => item.name === "pdfdetach");
+  if (!metadata) throw new TypeError("Unknown pdfdetach command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadpdfinfo();
+    return () => [module.createPdfdetachCommand(...args)];
+  })[0];
+};
+var createPdftocairoCommand = (...args) => {
+  const metadata = pdftoppmMetadata.find((item) => item.name === "pdftocairo");
+  if (!metadata) throw new TypeError("Unknown pdftocairo command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadpdfinfo();
+    return () => [module.createPdftocairoCommand(...args)];
+  })[0];
+};
+var createLibreofficeCommand = (...args) => {
+  const metadata = sofficeMetadata.find((item) => item.name === "libreoffice");
+  if (!metadata) throw new TypeError("Unknown libreoffice command");
+  return createLazyCommands([metadata], async () => {
+    const module = await loadsoffice();
+    return () => [module.createLibreofficeCommand(...args)];
+  })[0];
+};
+var createFormatInspectionCommand = (...args) => ({
+  name: "pandoc",
+  description: "List available document formats and dialect extensions",
+  async execute(context) {
+    context.signal.throwIfAborted();
+    const module = await loadpandoc();
+    context.signal.throwIfAborted();
+    return module.createFormatInspectionCommand(...args).execute(context);
+  }
+});
+
+export {
+  createLazyCommandLoader,
+  createLazyCommands,
+  lazyCommandPlugin,
+  createGhCommand,
+  createGhCommands,
+  ghCommands,
+  createFfmpegCommand,
+  createFfprobeCommand,
+  createFfmpegCommands,
+  ffmpegCommands,
+  gitCommands,
+  createGitCommands,
+  createGitCommand,
+  createSofficeCommand,
+  sofficeCommands,
+  createSofficeCommands,
+  pandocCommands,
+  createPandocCommands,
+  createPandocCommand,
+  createSsconvertCommand,
+  ssconvertCommands,
+  createSsconvertCommands,
+  createPdfinfoCommand,
+  pdfinfoCommands,
+  createPdfinfoCommands,
+  createPdftotextCommand,
+  pdftotextCommands,
+  createPdftotextCommands,
+  createPdfimagesCommand,
+  pdfimagesCommands,
+  createPdfimagesCommands,
+  createPdftoppmCommand,
+  pdftoppmCommands,
+  createPdftoppmCommands,
+  createPdftkCommand,
+  pdftkCommands,
+  createPdftkCommands,
+  createQpdfCommand,
+  qpdfCommands,
+  createQpdfCommands,
+  createSipsCommand,
+  sipsCommands,
+  createSipsCommands,
+  createMagickCommand,
+  imagemagickCommands,
+  createImagemagickCommands,
+  createImagemagickCommand,
+  createWkhtmltopdfCommand,
+  wkhtmltopdfCommands,
+  createWkhtmltopdfCommands,
+  csvkitCommands,
+  createCsvkitCommands,
+  createCsvkitCommand,
+  optionalCommandCatalog,
+  createOptionalCommands,
+  optionalCommands,
+  createConvertCommand,
+  createMogrifyCommand,
+  createCompositeCommand,
+  createMontageCommand,
+  createIdentifyCommand,
+  createCompareCommand,
+  createPdfuniteCommand,
+  createPdfseparateCommand,
+  createPdffontsCommand,
+  createPdfdetachCommand,
+  createPdftocairoCommand,
+  createLibreofficeCommand,
+  createFormatInspectionCommand
+};