@poe-platform/safe-bash 0.1.710 → 0.1.712

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

@@ -1,7 +1,1458 @@
-export { parseInvocation, tokenizeBatchLine } from "./parser.js";
-export { createWkhtmltopdfCommand, wkhtmltopdfCommand, wkhtmltopdfCommands, runWkhtmltopdf, wkhtmltopdfLimits } from "./command.js";
-export { switches } from "./switches.js";
-export { WkhtmltopdfError } from "./errors.js";
-export { conversionOutcome } from "./outcome.js";
-export { planPageSequence, requireRendererFeatures } from "./engine.js";
-export { withResources } from "./resources.js";
+// packages/safe-bash-command-wkhtmltopdf/dist/errors.js
+var WkhtmltopdfError = class extends Error {
+  code;
+  option;
+  exitCode = 1;
+  constructor(code, message, option) {
+    super(message);
+    this.code = code;
+    this.option = option;
+    this.name = "WkhtmltopdfError";
+  }
+};
+
+// packages/safe-bash-command-wkhtmltopdf/dist/limits.js
+var ParseBudget = class {
+  options;
+  work = 0;
+  bytes = 0;
+  objects = 0;
+  limits;
+  constructor(options) {
+    this.options = options;
+    this.checkCancellation();
+    this.limits = {
+      maxArguments: options.limits?.maxArguments,
+      maxTextBytes: options.limits?.maxTextBytes,
+      maxObjects: options.limits?.maxObjects,
+      maxWork: options.limits?.maxWork
+    };
+    for (const value of Object.values(this.limits)) {
+      if (!Number.isSafeInteger(value) || value < 1) {
+        throw new WkhtmltopdfError("INVALID_VALUE", "Parser limits must be positive safe integers");
+      }
+    }
+  }
+  checkCancellation() {
+    if (this.options.signal?.aborted)
+      throw this.options.signal.reason;
+  }
+  step(amount = 1) {
+    this.checkCancellation();
+    if (amount > this.limits.maxWork - this.work) {
+      throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Parser work limit exceeded");
+    }
+    this.work += amount;
+  }
+  admitArguments(count) {
+    this.step();
+    if (count > this.limits.maxArguments) {
+      throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Parser argument limit exceeded");
+    }
+  }
+  admitText(text) {
+    for (let i = 0; i < text.length; i++) {
+      this.step();
+      const code = text.charCodeAt(i);
+      let size = code < 128 ? 1 : code < 2048 ? 2 : 3;
+      if (code >= 55296 && code <= 56319) {
+        const next = text.charCodeAt(i + 1);
+        if (next >= 56320 && next <= 57343) {
+          size = 4;
+          i++;
+          this.step();
+        }
+      }
+      if (size > this.limits.maxTextBytes - this.bytes) {
+        throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Parser text byte limit exceeded");
+      }
+      this.bytes += size;
+      if (code === 0)
+        throw new WkhtmltopdfError("INVALID_VALUE", "NUL is not admitted in CLI text");
+    }
+  }
+  admitObject(replacementCount) {
+    this.step(64 + replacementCount * 2);
+    if (++this.objects > this.limits.maxObjects) {
+      throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Parser object limit exceeded");
+    }
+  }
+};
+
+// packages/safe-bash-command-wkhtmltopdf/dist/settings.js
+function createGlobalSettings() {
+  return {
+    logLevel: "info",
+    orientation: "Portrait",
+    pageSize: "A4",
+    dpi: 96,
+    copies: 1,
+    collate: true,
+    outline: true,
+    outlineDepth: 4,
+    imageDPI: 600,
+    imageQuality: 94,
+    useCompression: true,
+    colorMode: "color",
+    resolution: "high",
+    documentTitle: "",
+    marginTop: { value: -1, unit: "mm" },
+    marginBottom: { value: -1, unit: "mm" },
+    marginLeft: { value: 10, unit: "mm" },
+    marginRight: { value: 10, unit: "mm" },
+    pageHeight: { value: -1, unit: "mm" },
+    pageWidth: { value: -1, unit: "mm" },
+    pageOffset: 0,
+    resolveRelativeLinks: true,
+    viewportSize: "",
+    readArgsFromStdin: false,
+    action: ""
+  };
+}
+function createPageSettings() {
+  return {
+    header: { fontSize: 12, fontName: "Arial", left: "", right: "", center: "", line: false, htmlUrl: "", spacing: 0 },
+    footer: { fontSize: 12, fontName: "Arial", left: "", right: "", center: "", line: false, htmlUrl: "", spacing: 0 },
+    toc: { useDottedLines: true, captionText: "Table of Contents", forwardLinks: true, backLinks: false, indentation: "1em", fontScale: Math.fround(0.8) },
+    web: { background: true, loadImages: true, enableJavascript: true, enableIntelligentShrinking: true, minimumFontSize: -1, defaultEncoding: "", enablePlugins: false },
+    load: { jsdelay: 200, zoomFactor: 1, blockLocalFileAccess: true, stopSlowScripts: true, loadErrorHandling: "abort", mediaLoadErrorHandling: "ignore", printMediaType: false },
+    includeInOutline: true,
+    pagesCount: true,
+    produceForms: false,
+    useLocalLinks: true,
+    useExternalLinks: true,
+    replacements: []
+  };
+}
+function clonePageSettings(settings) {
+  return {
+    ...settings,
+    header: { ...settings.header },
+    footer: { ...settings.footer },
+    toc: { ...settings.toc },
+    web: { ...settings.web },
+    load: { ...settings.load },
+    replacements: settings.replacements.map(([key, value]) => [key, value])
+  };
+}
+
+// packages/safe-bash-command-wkhtmltopdf/dist/values.js
+function integer(text, min, max) {
+  const value = text.trim();
+  let index = value[0] === "+" || value[0] === "-" ? 1 : 0;
+  if (index === value.length)
+    throw new WkhtmltopdfError("INVALID_VALUE", "Expected an integer");
+  for (; index < value.length; index++) {
+    if (value[index] < "0" || value[index] > "9") {
+      throw new WkhtmltopdfError("INVALID_VALUE", "Expected a decimal integer");
+    }
+  }
+  const result = Number(value);
+  if (!Number.isSafeInteger(result) || result < min || result > max) {
+    throw new WkhtmltopdfError("INVALID_VALUE", "Integer is outside the admitted range");
+  }
+  return result;
+}
+function float32(text, positive) {
+  const value = text.trim();
+  let digits = 0;
+  for (const character of value) {
+    if (character >= "0" && character <= "9")
+      digits++;
+    else if (!"+-.eE".includes(character)) {
+      throw new WkhtmltopdfError("INVALID_VALUE", "Expected a decimal float");
+    }
+  }
+  const result = Math.fround(Number(value));
+  if (!digits || !Number.isFinite(result) || (positive ? result <= 0 : result < 0)) {
+    throw new WkhtmltopdfError("INVALID_VALUE", "Float is outside the admitted finite binary32 range");
+  }
+  return result;
+}
+function choice(text, values) {
+  const result = values.find((value) => value.toLowerCase() === text.toLowerCase());
+  if (result === void 0)
+    throw new WkhtmltopdfError("INVALID_VALUE", "Unknown enumerated value");
+  return result;
+}
+function length(text) {
+  let index = 0;
+  while (text[index] !== void 0 && text[index] >= "0" && text[index] <= "9")
+    index++;
+  if (text[index] === ".")
+    index++;
+  while (text[index] !== void 0 && text[index] >= "0" && text[index] <= "9")
+    index++;
+  const number = text.slice(0, index);
+  const value = Number(number);
+  if (!number || number === "." || !Number.isFinite(value)) {
+    throw new WkhtmltopdfError("INVALID_VALUE", "Expected an unsigned finite length");
+  }
+  const units = {
+    "": ["mm", 1],
+    mm: ["mm", 1],
+    millimeter: ["mm", 1],
+    cm: ["mm", 10],
+    centimeter: ["mm", 10],
+    m: ["mm", 1e3],
+    meter: ["mm", 1e3],
+    in: ["in", 1],
+    inch: ["in", 1],
+    pt: ["pt", 1],
+    point: ["pt", 1],
+    px: ["px", 1],
+    pixel: ["px", 1],
+    pc: ["pc", 1],
+    pica: ["pc", 1],
+    didot: ["didot", 1],
+    cicero: ["cicero", 1]
+  };
+  const suffix = text.slice(index).toLowerCase();
+  const entry = Object.hasOwn(units, suffix) ? units[suffix] : void 0;
+  if (!entry || !Number.isFinite(value * entry[1])) {
+    throw new WkhtmltopdfError("INVALID_VALUE", "Unknown or overflowing length unit");
+  }
+  return { value: value * entry[1], unit: entry[0] };
+}
+
+// packages/safe-bash-command-wkhtmltopdf/dist/switches.js
+var declarations = [
+  { name: "--help", short: "h", scope: "global", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.action = "help";
+  } },
+  { name: "--version", short: "V", scope: "global", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.action = "version";
+  } },
+  { name: "--license", short: "", scope: "global", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.action = "license";
+  } },
+  { name: "--extended-help", short: "H", scope: "global", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.action = "extended-help";
+  } },
+  { name: "--manpage", short: "", scope: "global", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.action = "manpage";
+  } },
+  { name: "--htmldoc", short: "", scope: "global", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.action = "htmldoc";
+  } },
+  { name: "--readme", short: "", scope: "global", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.action = "readme";
+  } },
+  { name: "--quiet", short: "q", scope: "global", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.logLevel = "none";
+  } },
+  { name: "--log-level", short: "", scope: "global", arity: 1, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.logLevel = choice(_a[0], ["none", "error", "warn", "info", "debug"]);
+  } },
+  { name: "--no-collate", short: "", scope: "global", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.collate = false;
+  } },
+  { name: "--collate", short: "", scope: "global", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.collate = true;
+  } },
+  { name: "--copies", short: "", scope: "global", arity: 1, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.copies = integer(_a[0], 1, 2147483647);
+  } },
+  { name: "--orientation", short: "O", scope: "global", arity: 1, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.orientation = choice(_a[0], ["Portrait", "Landscape"]);
+  } },
+  { name: "--page-size", short: "s", scope: "global", arity: 1, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.pageSize = choice(_a[0], ["A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9", "B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9", "B10", "C5E", "Comm10E", "DLE", "Executive", "Folio", "Ledger", "Legal", "Letter", "Tabloid"]);
+  } },
+  { name: "--grayscale", short: "g", scope: "global", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.colorMode = "grayscale";
+  } },
+  { name: "--lowquality", short: "l", scope: "global", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.resolution = "screen";
+  } },
+  { name: "--title", short: "", scope: "global", arity: 1, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.documentTitle = _a[0];
+  } },
+  { name: "--read-args-from-stdin", short: "", scope: "global", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.readArgsFromStdin = true;
+  } },
+  { name: "--margin-bottom", short: "B", scope: "global", arity: 1, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.marginBottom = length(_a[0]);
+  } },
+  { name: "--margin-left", short: "L", scope: "global", arity: 1, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.marginLeft = length(_a[0]);
+  } },
+  { name: "--margin-right", short: "R", scope: "global", arity: 1, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.marginRight = length(_a[0]);
+  } },
+  { name: "--margin-top", short: "T", scope: "global", arity: 1, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.marginTop = length(_a[0]);
+  } },
+  { name: "--dpi", short: "d", scope: "global", arity: 1, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.dpi = integer(_a[0], 1, 2147483647);
+  } },
+  { name: "--page-height", short: "", scope: "global", arity: 1, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.pageHeight = length(_a[0]);
+  } },
+  { name: "--page-width", short: "", scope: "global", arity: 1, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.pageWidth = length(_a[0]);
+  } },
+  { name: "--cookie-jar", short: "", scope: "global", arity: 1, qtPatched: false, disposition: "resource" },
+  { name: "--image-quality", short: "", scope: "global", arity: 1, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _g.imageQuality = integer(_a[0], 0, 100);
+  } },
+  { name: "--image-dpi", short: "", scope: "global", arity: 1, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _g.imageDPI = integer(_a[0], 1, 2147483647);
+  } },
+  { name: "--no-pdf-compression", short: "", scope: "global", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _g.useCompression = false;
+  } },
+  { name: "--use-xserver", short: "", scope: "global", arity: 0, qtPatched: true, disposition: "excluded" },
+  { name: "--outline", short: "", scope: "global", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _g.outline = true;
+  } },
+  { name: "--no-outline", short: "", scope: "global", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _g.outline = false;
+  } },
+  { name: "--outline-depth", short: "", scope: "global", arity: 1, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _g.outlineDepth = integer(_a[0], 0, 2147483647);
+  } },
+  { name: "--dump-outline", short: "", scope: "global", arity: 1, qtPatched: true, disposition: "resource" },
+  { name: "--dump-default-toc-xsl", short: "", scope: "global", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _g.action = "dump-default-toc-xsl";
+  } },
+  { name: "--default-header", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p) => {
+    _p.header.left = "[webpage]";
+    _p.header.right = "[page]/[topage]";
+    _p.header.line = true;
+    _g.marginTop = { value: 20, unit: "mm" };
+  } },
+  { name: "--viewport-size", short: "", scope: "page", arity: 1, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _g.viewportSize = _a[0];
+  } },
+  { name: "--enable-plugins", short: "", scope: "page", arity: 0, qtPatched: false, disposition: "excluded" },
+  { name: "--disable-plugins", short: "", scope: "page", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _p.web.enablePlugins = false;
+  } },
+  { name: "--minimum-font-size", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _p.web.minimumFontSize = integer(_a[0], 1, 2147483647);
+  } },
+  { name: "--user-style-sheet", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "resource" },
+  { name: "--no-images", short: "", scope: "page", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _p.web.loadImages = false;
+  } },
+  { name: "--images", short: "", scope: "page", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _p.web.loadImages = true;
+  } },
+  { name: "--disable-javascript", short: "n", scope: "page", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _p.web.enableJavascript = false;
+  } },
+  { name: "--enable-javascript", short: "", scope: "page", arity: 0, qtPatched: false, disposition: "harness" },
+  { name: "--encoding", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _p.web.defaultEncoding = _a[0];
+  } },
+  { name: "--no-background", short: "", scope: "page", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _p.web.background = false;
+  } },
+  { name: "--background", short: "", scope: "page", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _p.web.background = true;
+  } },
+  { name: "--include-in-outline", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.includeInOutline = true;
+  } },
+  { name: "--exclude-from-outline", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.includeInOutline = false;
+  } },
+  { name: "--disable-smart-shrinking", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.web.enableIntelligentShrinking = false;
+  } },
+  { name: "--enable-smart-shrinking", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.web.enableIntelligentShrinking = true;
+  } },
+  { name: "--print-media-type", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.load.printMediaType = true;
+  } },
+  { name: "--no-print-media-type", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.load.printMediaType = false;
+  } },
+  { name: "--enable-forms", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.produceForms = true;
+  } },
+  { name: "--disable-forms", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.produceForms = false;
+  } },
+  { name: "--disable-internal-links", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.useLocalLinks = false;
+  } },
+  { name: "--enable-internal-links", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.useLocalLinks = true;
+  } },
+  { name: "--disable-external-links", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.useExternalLinks = false;
+  } },
+  { name: "--enable-external-links", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.useExternalLinks = true;
+  } },
+  { name: "--resolve-relative-links", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _g.resolveRelativeLinks = true;
+  } },
+  { name: "--keep-relative-links", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _g.resolveRelativeLinks = false;
+  } },
+  { name: "--enable-toc-back-links", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.toc.backLinks = true;
+  } },
+  { name: "--disable-toc-back-links", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.toc.backLinks = false;
+  } },
+  { name: "--proxy", short: "p", scope: "page", arity: 1, qtPatched: false, disposition: "resource" },
+  { name: "--proxy-hostname-lookup", short: "", scope: "page", arity: 0, qtPatched: false, disposition: "resource" },
+  { name: "--bypass-proxy-for", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "resource" },
+  { name: "--username", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "resource" },
+  { name: "--password", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "resource" },
+  { name: "--ssl-key-path", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "resource" },
+  { name: "--ssl-key-password", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "resource" },
+  { name: "--ssl-crt-path", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "resource" },
+  { name: "--load-error-handling", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _p.load.loadErrorHandling = choice(_a[0], ["abort", "skip", "ignore"]);
+  } },
+  { name: "--load-media-error-handling", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _p.load.mediaLoadErrorHandling = choice(_a[0], ["abort", "skip", "ignore"]);
+  } },
+  { name: "--custom-header", short: "", scope: "page", arity: 2, qtPatched: false, disposition: "resource" },
+  { name: "--custom-header-propagation", short: "", scope: "page", arity: 0, qtPatched: false, disposition: "resource" },
+  { name: "--no-custom-header-propagation", short: "", scope: "page", arity: 0, qtPatched: false, disposition: "resource" },
+  { name: "--javascript-delay", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "harness" },
+  { name: "--window-status", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "harness" },
+  { name: "--zoom", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _p.load.zoomFactor = float32(_a[0], true);
+  } },
+  { name: "--cookie", short: "", scope: "page", arity: 2, qtPatched: false, disposition: "resource" },
+  { name: "--post", short: "", scope: "page", arity: 2, qtPatched: false, disposition: "resource" },
+  { name: "--post-file", short: "", scope: "page", arity: 2, qtPatched: false, disposition: "resource" },
+  { name: "--disable-local-file-access", short: "", scope: "page", arity: 0, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _p.load.blockLocalFileAccess = true;
+  } },
+  { name: "--enable-local-file-access", short: "", scope: "page", arity: 0, qtPatched: false, disposition: "resource" },
+  { name: "--allow", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "resource" },
+  { name: "--cache-dir", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "resource" },
+  { name: "--debug-javascript", short: "", scope: "page", arity: 0, qtPatched: false, disposition: "harness" },
+  { name: "--no-debug-javascript", short: "", scope: "page", arity: 0, qtPatched: false, disposition: "harness" },
+  { name: "--stop-slow-scripts", short: "", scope: "page", arity: 0, qtPatched: false, disposition: "harness" },
+  { name: "--no-stop-slow-scripts", short: "", scope: "page", arity: 0, qtPatched: false, disposition: "harness" },
+  { name: "--run-script", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "harness" },
+  { name: "--checkbox-svg", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "resource" },
+  { name: "--checkbox-checked-svg", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "resource" },
+  { name: "--radiobutton-svg", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "resource" },
+  { name: "--radiobutton-checked-svg", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "resource" },
+  { name: "--page-offset", short: "", scope: "page", arity: 1, qtPatched: false, disposition: "static", apply: (_g, _p, _a) => {
+    _g.pageOffset = integer(_a[0], -2147483648, 2147483647);
+  } },
+  { name: "--footer-center", short: "", scope: "page", arity: 1, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.footer.center = _a[0];
+  } },
+  { name: "--footer-font-name", short: "", scope: "page", arity: 1, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.footer.fontName = _a[0];
+  } },
+  { name: "--footer-font-size", short: "", scope: "page", arity: 1, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.footer.fontSize = integer(_a[0], 1, 2147483647);
+  } },
+  { name: "--footer-left", short: "", scope: "page", arity: 1, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.footer.left = _a[0];
+  } },
+  { name: "--footer-line", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.footer.line = true;
+  } },
+  { name: "--no-footer-line", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.footer.line = false;
+  } },
+  { name: "--footer-right", short: "", scope: "page", arity: 1, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.footer.right = _a[0];
+  } },
+  { name: "--footer-spacing", short: "", scope: "page", arity: 1, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.footer.spacing = float32(_a[0], false);
+  } },
+  { name: "--footer-html", short: "", scope: "page", arity: 1, qtPatched: true, disposition: "resource" },
+  { name: "--header-center", short: "", scope: "page", arity: 1, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.header.center = _a[0];
+  } },
+  { name: "--header-font-name", short: "", scope: "page", arity: 1, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.header.fontName = _a[0];
+  } },
+  { name: "--header-font-size", short: "", scope: "page", arity: 1, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.header.fontSize = integer(_a[0], 1, 2147483647);
+  } },
+  { name: "--header-left", short: "", scope: "page", arity: 1, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.header.left = _a[0];
+  } },
+  { name: "--header-line", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.header.line = true;
+  } },
+  { name: "--no-header-line", short: "", scope: "page", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.header.line = false;
+  } },
+  { name: "--header-right", short: "", scope: "page", arity: 1, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.header.right = _a[0];
+  } },
+  { name: "--header-spacing", short: "", scope: "page", arity: 1, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.header.spacing = float32(_a[0], false);
+  } },
+  { name: "--header-html", short: "", scope: "page", arity: 1, qtPatched: true, disposition: "resource" },
+  { name: "--replace", short: "", scope: "page", arity: 2, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.replacements.push([_a[0], _a[1]]);
+  } },
+  { name: "--xsl-style-sheet", short: "", scope: "toc", arity: 1, qtPatched: true, disposition: "resource" },
+  { name: "--toc-header-text", short: "", scope: "toc", arity: 1, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.toc.captionText = _a[0];
+  } },
+  { name: "--disable-toc-links", short: "", scope: "toc", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.toc.forwardLinks = false;
+  } },
+  { name: "--disable-dotted-lines", short: "", scope: "toc", arity: 0, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.toc.useDottedLines = false;
+  } },
+  { name: "--toc-text-size-shrink", short: "", scope: "toc", arity: 1, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.toc.fontScale = float32(_a[0], true);
+  } },
+  { name: "--toc-level-indentation", short: "", scope: "toc", arity: 1, qtPatched: true, disposition: "static", apply: (_g, _p, _a) => {
+    _p.toc.indentation = _a[0];
+  } }
+];
+var switches = Object.freeze(declarations.map((entry) => Object.freeze(entry)));
+
+// packages/safe-bash-command-wkhtmltopdf/dist/parser.js
+var longOptions = new Map(switches.map((entry) => [entry.name, entry]));
+var shortOptions = new Map(switches.filter((entry) => entry.short).map((entry) => [entry.short, entry]));
+function parseInvocation(argv, options) {
+  const budget = new ParseBudget(options);
+  budget.admitArguments(argv.length);
+  for (const arg of argv)
+    budget.admitText(arg);
+  budget.step(64);
+  const global = createGlobalSettings();
+  const defaults = createPageSettings();
+  const objects = [];
+  let index = 0;
+  let literal = false;
+  const parseOptions = (settings, scope) => {
+    if (literal)
+      return;
+    while (index < (scope === "leading" ? argv.length : argv.length - 1)) {
+      const token = argv[index];
+      if (!token.startsWith("-") || token === "-")
+        break;
+      budget.step();
+      if (token === "--" && options.endOfOptions) {
+        index++;
+        literal = true;
+        break;
+      }
+      if (token === "--" || token.startsWith("--0")) {
+        throw new WkhtmltopdfError("UNQUALIFIED_QUIRK", "Pinned default-mode sentinel is unqualified and not admitted", token);
+      }
+      index++;
+      const names = token.startsWith("--") ? [token] : token.slice(1);
+      for (const name of names) {
+        budget.step();
+        const entry = token.startsWith("--") ? longOptions.get(name) : shortOptions.get(name);
+        if (!entry)
+          throw new WkhtmltopdfError("UNKNOWN_OPTION", "Unknown switch", token);
+        const allowed = entry.scope === "page" || (entry.scope === "global" ? scope === "leading" : scope === "toc");
+        if (!allowed)
+          throw new WkhtmltopdfError("OPTION_LOCATION", "Switch is in an incorrect object scope", entry.name);
+        if (entry.arity > argv.length - index) {
+          throw new WkhtmltopdfError("MISSING_OPERAND", "Switch is missing an operand", entry.name);
+        }
+        if (entry.disposition !== "static") {
+          throw new WkhtmltopdfError("UNSUPPORTED_CAPABILITY", `Switch requires unavailable ${entry.disposition} capability`, entry.name);
+        }
+        budget.step(entry.arity + 1);
+        const operands = argv.slice(index, index + entry.arity);
+        index += entry.arity;
+        try {
+          entry.apply(global, settings, operands);
+        } catch (error) {
+          if (error instanceof WkhtmltopdfError)
+            throw new WkhtmltopdfError(error.code, error.message, entry.name);
+          throw error;
+        }
+        if (global.action)
+          return;
+      }
+    }
+  };
+  parseOptions(defaults, "leading");
+  if (global.action)
+    return { mode: "information", global, pageDefaults: defaults, objects, output: null };
+  if (global.readArgsFromStdin && !options.batchJob)
+    return { mode: "batch", global, pageDefaults: defaults, objects, output: null };
+  while (index < argv.length - 1) {
+    budget.admitObject(defaults.replacements.length);
+    const settings = clonePageSettings(defaults);
+    let kind = "page";
+    const token = argv[index++];
+    let input = token;
+    if (token === "toc") {
+      kind = "toc";
+      input = null;
+    } else if (token === "cover" || token === "page") {
+      kind = token;
+      if (index >= argv.length - 1) {
+        throw new WkhtmltopdfError("MISSING_OBJECT", "Object requires an input and a final output");
+      }
+      input = argv[index++];
+    }
+    parseOptions(settings, kind === "toc" ? "toc" : "page");
+    if (kind === "cover") {
+      for (const furniture of [settings.header, settings.footer]) {
+        furniture.left = furniture.right = furniture.center = furniture.htmlUrl = "";
+        furniture.line = false;
+      }
+      settings.includeInOutline = false;
+    }
+    objects.push({ kind, input, settings });
+  }
+  if (!objects.length || index !== argv.length - 1) {
+    throw new WkhtmltopdfError("MISSING_OBJECT", "Expected at least one input object and exactly one output");
+  }
+  const margins = [global.marginTop, global.marginBottom, global.marginLeft, global.marginRight];
+  if (margins.some((margin) => margin.unit !== global.marginLeft.unit)) {
+    throw new WkhtmltopdfError("MARGIN_UNITS", "All margins must use the same normalized unit");
+  }
+  return { mode: "conversion", global, pageDefaults: defaults, objects, output: argv[index] };
+}
+function tokenizeBatchLine(line, options) {
+  const budget = new ParseBudget(options);
+  budget.admitText(line);
+  const tokens = [];
+  let token = "";
+  let quote = "";
+  let escaped = false;
+  const emit = () => {
+    if (!token)
+      return;
+    budget.admitArguments(tokens.length + 1);
+    tokens.push(token);
+    token = "";
+  };
+  for (const character of line) {
+    budget.step();
+    if (escaped) {
+      token += character;
+      escaped = false;
+    } else if (character === "\\")
+      escaped = true;
+    else if (quote) {
+      if (character === quote)
+        quote = "";
+      else
+        token += character;
+    } else if (character === "'" || character === '"')
+      quote = character;
+    else if (" 	\r\n".includes(character))
+      emit();
+    else
+      token += character;
+  }
+  emit();
+  return tokens;
+}
+
+// packages/safe-bash-command-wkhtmltopdf/dist/command.js
+import { commandRuntimeIdentity, getCommandArguments } from "../safe-bash-contracts/command.js";
+import { readBytes, writeBytes } from "../safe-bash-contracts/io.js";
+import { shellValueByteLength } from "../safe-bash-contracts/value.js";
+import { FsError } from "../safe-bash-contracts/errors.js";
+import { createOutputOperation } from "../safe-bash-contracts/output.js";
+import { basename, compareEntries, dirname, resolvePath } from "@poe-platform/safe-fs/core";
+
+// packages/safe-bash-command-wkhtmltopdf/dist/engine.js
+var rendererFeatures = [
+  "html5",
+  "computed-css",
+  "selectors",
+  "css-units",
+  "block-inline",
+  "font-shaping",
+  "lists",
+  "images",
+  "table-spans",
+  "pagination",
+  "break-rules",
+  "widows-orphans",
+  "positioning",
+  "page-furniture",
+  "flex",
+  "grid"
+];
+function requireRendererFeatures(profile, required) {
+  if (typeof profile.id !== "string" || !profile.id || profile.id.length > 128 || profile.features.length > rendererFeatures.length || required.length > rendererFeatures.length) {
+    throw new WkhtmltopdfError("INVALID_VALUE", "Expected a bounded renderer profile and feature requirements");
+  }
+  for (const feature of [...profile.features, ...required]) {
+    if (!rendererFeatures.includes(feature)) {
+      throw new WkhtmltopdfError("INVALID_VALUE", "Unknown renderer feature");
+    }
+  }
+  for (const feature of required) {
+    if (!profile.features.includes(feature)) {
+      throw new WkhtmltopdfError("UNSUPPORTED_CAPABILITY", `Renderer profile ${profile.id} does not support ${feature}`);
+    }
+  }
+}
+function planPageSequence(objects, options) {
+  const checkCancellation = () => {
+    if (options.signal?.aborted)
+      throw options.signal.reason;
+  };
+  checkCancellation();
+  const { maxObjects, maxPhysicalPages, maxWork } = options.limits;
+  for (const value of [maxObjects, maxPhysicalPages, maxWork, options.copies]) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+      throw new WkhtmltopdfError("INVALID_VALUE", "Page sequence limits and copies must be positive safe integers");
+    }
+  }
+  if (typeof options.collate !== "boolean" || !Number.isInteger(options.pageOffset) || options.pageOffset < -2147483648 || options.pageOffset > 2147483647) {
+    throw new WkhtmltopdfError("INVALID_VALUE", "Expected boolean collate and int32 page offset");
+  }
+  if (objects.length > maxObjects || objects.length > maxWork) {
+    throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Page sequence object/work limit exceeded");
+  }
+  let outlineTotal = 0;
+  let logicalTotal = 0;
+  const sourcePageLimit = Math.floor(Math.min(maxPhysicalPages, maxWork - objects.length) / options.copies);
+  for (const object of objects) {
+    checkCancellation();
+    if (!Number.isSafeInteger(object.physicalPages) || object.physicalPages < 0 || typeof object.pagesCount !== "boolean") {
+      throw new WkhtmltopdfError("INVALID_VALUE", "Expected a nonnegative safe page count and boolean pagesCount");
+    }
+    if (object.physicalPages > sourcePageLimit - outlineTotal) {
+      throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Page sequence physical-page/work limit exceeded");
+    }
+    outlineTotal += object.physicalPages;
+    if (object.pagesCount)
+      logicalTotal += object.physicalPages;
+  }
+  if (!Number.isSafeInteger(logicalTotal + Math.abs(options.pageOffset) + 1)) {
+    throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Logical page number exceeds checked precision");
+  }
+  const passes = options.collate ? options.copies : 1;
+  if (outlineTotal > 0) {
+    const remainingWork = maxWork - objects.length - outlineTotal * options.copies;
+    if (objects.length > Math.floor(remainingWork / passes)) {
+      throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Page sequence repeated traversal work limit exceeded");
+    }
+  }
+  const pages = [];
+  const emit = (objectIndex, pageIndex, copyIndex, logicalPage, outlinePage) => {
+    checkCancellation();
+    pages.push({ objectIndex, pageIndex, copyIndex, outputPage: pages.length + 1, logicalPage, outlinePage });
+  };
+  if (outlineTotal === 0)
+    return { pages, logicalTotal, outlineTotal };
+  for (let pass = 0; pass < passes; pass++) {
+    let logicalPage = 1 + options.pageOffset;
+    let outlinePage = 1;
+    for (let objectIndex = 0; objectIndex < objects.length; objectIndex++) {
+      checkCancellation();
+      const object = objects[objectIndex];
+      for (let pageIndex = 0; pageIndex < object.physicalPages; pageIndex++) {
+        if (options.collate)
+          emit(objectIndex, pageIndex, pass, logicalPage, outlinePage);
+        else
+          for (let copyIndex = 0; copyIndex < options.copies; copyIndex++) {
+            emit(objectIndex, pageIndex, copyIndex, logicalPage, outlinePage);
+          }
+        if (object.pagesCount)
+          logicalPage++;
+        outlinePage++;
+      }
+    }
+  }
+  return { pages, logicalTotal, outlineTotal };
+}
+
+// packages/safe-bash-command-wkhtmltopdf/dist/outcome.js
+var httpDescriptions = {
+  400: "Bad Request",
+  401: "Unauthorized",
+  402: "Payment Required",
+  403: "Forbidden",
+  404: "Page not found",
+  405: "Method Not Allowed",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  503: "Service Unavailable",
+  505: "HTTP Version Not Supported"
+};
+function conversionOutcome(completion) {
+  const { mode, success, errorCode, networkErrorName } = completion;
+  if (mode !== "single" && mode !== "batch" || typeof success !== "boolean" || !Number.isInteger(errorCode) || errorCode < 0 || errorCode > 2147483647) {
+    throw new WkhtmltopdfError("INVALID_VALUE", "Expected a conversion mode, boolean success and nonnegative int32 loader code");
+  }
+  if (networkErrorName !== void 0) {
+    if (typeof networkErrorName !== "string" || !networkErrorName.length || networkErrorName.length > 128) {
+      throw new WkhtmltopdfError("INVALID_VALUE", "Network enum name must contain 1\u2013128 ASCII identifier characters");
+    }
+    for (const character of networkErrorName) {
+      if (!(character >= "a" && character <= "z") && !(character >= "A" && character <= "Z") && !(character >= "0" && character <= "9") && character !== "_") {
+        throw new WkhtmltopdfError("INVALID_VALUE", "Network enum name must contain ASCII identifier characters");
+      }
+    }
+  }
+  if (mode === "batch")
+    return { exitCode: success ? 0 : 1, diagnostic: null };
+  if (errorCode >= 1e3) {
+    return { exitCode: 1, diagnostic: { kind: "network", code: errorCode - 1e3, name: networkErrorName ?? null } };
+  }
+  if (errorCode !== 0) {
+    return {
+      exitCode: errorCode === 404 ? 2 : errorCode === 401 ? 3 : 1,
+      diagnostic: { kind: "http", code: errorCode, description: httpDescriptions[errorCode] ?? "" }
+    };
+  }
+  return { exitCode: success ? 0 : 1, diagnostic: success ? null : { kind: "unknown" } };
+}
+
+// packages/safe-bash-command-wkhtmltopdf/dist/resources.js
+var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
+var byteLengthGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength").get;
+var byteTypeGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, Symbol.toStringTag).get;
+var copyBytes = Uint8Array.prototype.set;
+async function withResources(options, run) {
+  const limits = { ...options.limits };
+  for (const key of ["maxInputBytes", "maxDecodedBytes", "maxRetainedBytes", "maxWork", "maxResources"]) {
+    if (!Number.isSafeInteger(limits[key]) || limits[key] < 1) {
+      throw new WkhtmltopdfError("INVALID_VALUE", "Resource limits must be positive safe integers");
+    }
+  }
+  const { vfs, fonts, network } = options;
+  const controller = new AbortController();
+  const signal = controller.signal;
+  const sourceSignal = options.signal;
+  const abort = () => controller.abort(sourceSignal.reason);
+  sourceSignal.addEventListener("abort", abort, { once: true });
+  if (sourceSignal.aborted)
+    abort();
+  const usage = { inputBytes: 0, decodedBytes: 0, retainedBytes: 0, work: 0, resources: 0 };
+  let active = true;
+  let busy = false;
+  const pending = /* @__PURE__ */ new Set();
+  const check = () => {
+    if (signal.aborted)
+      throw signal.reason;
+    if (!active)
+      throw new WkhtmltopdfError("INVALID_VALUE", "Resource invocation has ended");
+  };
+  const charge = (key, amount, limit) => {
+    check();
+    if (amount > limit - usage[key])
+      throw new WkhtmltopdfError("LIMIT_EXCEEDED", `Resource ${key} limit exceeded`);
+    usage[key] += amount;
+  };
+  const work = (amount = 1) => charge("work", amount, limits.maxWork);
+  const admitText = (reference) => {
+    for (let i = 0; i < reference.length; i++) {
+      work();
+      const c = reference.charCodeAt(i);
+      let size = c < 128 ? 1 : c < 2048 ? 2 : 3;
+      if (c >= 55296 && c <= 56319 && reference.charCodeAt(i + 1) >= 56320 && reference.charCodeAt(i + 1) <= 57343) {
+        size = 4;
+        i++;
+        work();
+      }
+      charge("inputBytes", size, limits.maxInputBytes);
+      if (c === 0)
+        throw new WkhtmltopdfError("INVALID_VALUE", "NUL resource reference");
+    }
+  };
+  const retain = (size) => {
+    charge("decodedBytes", size, limits.maxDecodedBytes);
+    charge("retainedBytes", size, limits.maxRetainedBytes);
+  };
+  const data = (reference) => {
+    const comma = reference.indexOf(",");
+    if (comma < 0)
+      throw new WkhtmltopdfError("INVALID_VALUE", "Data URL requires a comma");
+    const base64 = reference.slice(5, comma).toLowerCase().endsWith(";base64");
+    const start = comma + 1;
+    let size = 0;
+    const invalid = () => {
+      throw new WkhtmltopdfError("INVALID_VALUE", "Malformed data URL byte encoding");
+    };
+    const hex = (c) => {
+      const code = c.charCodeAt(0);
+      if (code >= 48 && code <= 57)
+        return code - 48;
+      if (code >= 65 && code <= 70)
+        return code - 55;
+      if (code >= 97 && code <= 102)
+        return code - 87;
+      return invalid();
+    };
+    if (base64) {
+      const length2 = reference.length - start;
+      if (length2 % 4 !== 0)
+        invalid();
+      for (let i = start; i < reference.length; i += 4) {
+        work(4);
+        const a = alphabet.indexOf(reference[i]);
+        const b = alphabet.indexOf(reference[i + 1]);
+        const c = alphabet.indexOf(reference[i + 2]);
+        const d = alphabet.indexOf(reference[i + 3]);
+        if (a < 0 || b < 0)
+          invalid();
+        if (reference[i + 2] === "=") {
+          if (reference[i + 3] !== "=" || i + 4 !== reference.length || (b & 15) !== 0)
+            invalid();
+          size++;
+        } else if (reference[i + 3] === "=") {
+          if (c < 0 || i + 4 !== reference.length || (c & 3) !== 0)
+            invalid();
+          size += 2;
+        } else {
+          if (c < 0 || d < 0)
+            invalid();
+          size += 3;
+        }
+      }
+    } else {
+      for (let i = start; i < reference.length; i++) {
+        work();
+        const code = reference.charCodeAt(i);
+        if (code > 127 || code <= 32)
+          invalid();
+        if (reference[i] === "%") {
+          if (i + 2 >= reference.length)
+            invalid();
+          hex(reference[i + 1]);
+          hex(reference[i + 2]);
+          i += 2;
+          work(2);
+        }
+        size++;
+      }
+    }
+    work(size);
+    retain(size);
+    const result = new Uint8Array(size);
+    let offset = 0;
+    if (base64) {
+      for (let i = start; i < reference.length; i += 4) {
+        const a = alphabet.indexOf(reference[i]);
+        const b = alphabet.indexOf(reference[i + 1]);
+        const c = alphabet.indexOf(reference[i + 2]);
+        const d = alphabet.indexOf(reference[i + 3]);
+        result[offset++] = a << 2 | b >> 4;
+        if (c >= 0)
+          result[offset++] = b << 4 | c >> 2;
+        if (d >= 0)
+          result[offset++] = c << 6 | d;
+      }
+    } else {
+      for (let i = start; i < reference.length; i++) {
+        result[offset++] = reference[i] === "%" ? hex(reference[++i]) << 4 | hex(reference[++i]) : reference.charCodeAt(i);
+      }
+    }
+    return result;
+  };
+  const read = async (reference, open) => {
+    const lease = await open(reference, signal);
+    let temporary = 0;
+    const chunks = [];
+    let primary = false;
+    let failure;
+    let result;
+    try {
+      check();
+      const iterator = lease.chunks[Symbol.asyncIterator]();
+      for (; ; ) {
+        work();
+        let abortRead;
+        let next;
+        try {
+          next = await new Promise((resolve, reject) => {
+            abortRead = () => reject(signal.reason);
+            signal.addEventListener("abort", abortRead, { once: true });
+            if (signal.aborted)
+              abortRead();
+            Promise.resolve().then(() => {
+              check();
+              return iterator.next();
+            }).then(resolve, reject);
+          });
+        } finally {
+          if (abortRead)
+            signal.removeEventListener("abort", abortRead);
+        }
+        check();
+        if (next.done)
+          break;
+        if (byteTypeGetter.call(next.value) !== "Uint8Array") {
+          throw new WkhtmltopdfError("INVALID_VALUE", "Expected resource byte chunks");
+        }
+        const size = byteLengthGetter.call(next.value);
+        charge("inputBytes", size, limits.maxInputBytes);
+        work(size);
+        retain(size);
+        temporary += size;
+        if (size) {
+          const chunk = new Uint8Array(size);
+          copyBytes.call(chunk, next.value);
+          chunks.push(chunk);
+        }
+      }
+      work(temporary);
+      charge("retainedBytes", temporary, limits.maxRetainedBytes);
+      result = new Uint8Array(temporary);
+      let offset = 0;
+      for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+      }
+    } catch (error) {
+      primary = true;
+      failure = error;
+    } finally {
+      usage.retainedBytes -= temporary;
+      try {
+        await lease.close();
+        check();
+      } catch (error) {
+        if (!primary) {
+          primary = true;
+          failure = error;
+        }
+      }
+    }
+    if (primary) {
+      if (result)
+        usage.retainedBytes -= result.byteLength;
+      throw failure;
+    }
+    return result;
+  };
+  const load = (reference, font, base) => {
+    const operation = (async () => {
+      check();
+      if (busy)
+        throw new WkhtmltopdfError("INVALID_VALUE", "Resource reads must be sequential");
+      busy = true;
+      try {
+        charge("resources", 1, limits.maxResources);
+        admitText(reference);
+        if (base !== void 0) {
+          admitText(base);
+          try {
+            reference = new URL(reference, base).href;
+          } catch {
+            throw new WkhtmltopdfError("INVALID_VALUE", "Invalid resource URL or base");
+          }
+          admitText(reference);
+        }
+        if (!font) {
+          work(reference.length);
+          const fragment = reference.indexOf("#");
+          if (fragment >= 0)
+            reference = reference.slice(0, fragment);
+        }
+        if (!font && reference.startsWith("data:"))
+          return data(reference);
+        const open = font ? fonts : reference.startsWith("vfs:") ? vfs : reference.startsWith("https:") || reference.startsWith("http:") ? network : void 0;
+        if (!open)
+          throw new WkhtmltopdfError("UNSUPPORTED_CAPABILITY", "Resource requires an explicitly supplied capability");
+        return await read(reference, open);
+      } finally {
+        busy = false;
+      }
+    })();
+    pending.add(operation);
+    void operation.then(() => pending.delete(operation), () => pending.delete(operation));
+    return operation;
+  };
+  try {
+    check();
+    const result = await run({ load: (reference, base) => load(reference, false, base), font: (name) => load(name, true), get usage() {
+      return { ...usage };
+    } });
+    check();
+    if (pending.size)
+      throw new WkhtmltopdfError("INVALID_VALUE", "Resource reads must finish before the invocation ends");
+    return result;
+  } finally {
+    active = false;
+    controller.abort(new WkhtmltopdfError("INVALID_VALUE", "Resource invocation has ended"));
+    await Promise.allSettled(pending);
+    sourceSignal.removeEventListener("abort", abort);
+    usage.retainedBytes = 0;
+  }
+}
+
+// packages/safe-bash-command-wkhtmltopdf/dist/command.js
+var wkhtmltopdfLimits = Object.freeze({
+  parse: Object.freeze({ maxArguments: 1024, maxTextBytes: 65536, maxObjects: 64, maxWork: 1048576 }),
+  resources: Object.freeze({ maxInputBytes: 16777216, maxDecodedBytes: 16777216, maxRetainedBytes: 33554432, maxWork: 67108864, maxResources: 128 }),
+  maxOutputBytes: 16777216,
+  maxOutputChunks: 65536,
+  maxBatchJobs: 128
+});
+var encoder = new TextEncoder();
+var decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+var typedArrayPrototype2 = Object.getPrototypeOf(Uint8Array.prototype);
+var byteType = Object.getOwnPropertyDescriptor(typedArrayPrototype2, Symbol.toStringTag).get;
+var byteLength = Object.getOwnPropertyDescriptor(typedArrayPrototype2, "byteLength").get;
+async function runWkhtmltopdf(context, options) {
+  context.signal.throwIfAborted();
+  const controller = new AbortController();
+  const signal = controller.signal;
+  let opening;
+  let closing;
+  let cleanupPromise;
+  let resourceRun;
+  let stdout;
+  let stderr;
+  const retire = () => {
+    if (!opening)
+      return Promise.resolve();
+    closing ??= opening.then((document) => document.close(), () => {
+    });
+    return closing;
+  };
+  const onAbort = () => controller.abort(context.signal.reason);
+  const cleanup = () => {
+    cleanupPromise ??= (async () => {
+      controller.abort(new WkhtmltopdfError("INVALID_VALUE", "Invocation has ended"));
+      context.signal.removeEventListener("abort", onAbort);
+      const drained = await Promise.allSettled([
+        retire(),
+        resourceRun?.then(() => {
+        }, () => {
+        }),
+        stdout?.close(),
+        stderr?.close()
+      ]);
+      const failures = drained.filter((value) => value.status === "rejected").map((value) => value.reason);
+      if (failures.length)
+        throw new AggregateError(failures, "Invocation cleanup failed");
+    })();
+    return cleanupPromise;
+  };
+  context.registerCleanup?.(cleanup);
+  let primary = false;
+  let failure;
+  let result;
+  try {
+    context.signal.addEventListener("abort", onAbort, { once: true });
+    if (context.signal.aborted)
+      onAbort();
+    signal.throwIfAborted();
+    stdout = createOutputOperation({ signal, registerCleanup: (callback) => context.registerCleanup?.(callback) }, context.stdout);
+    stderr = createOutputOperation({ signal, registerCleanup: (callback) => context.registerCleanup?.(callback) }, context.stderr);
+    const limits = Object.freeze({
+      ...options.limits,
+      parse: Object.freeze({ ...options.limits.parse }),
+      resources: Object.freeze({ ...options.limits.resources })
+    });
+    for (const value of [limits.maxOutputBytes, limits.maxOutputChunks, limits.maxBatchJobs]) {
+      if (!Number.isSafeInteger(value) || value < 1)
+        throw new WkhtmltopdfError("INVALID_VALUE", "Command limits must be positive safe integers");
+    }
+    for (const key of ["maxInputBytes", "maxDecodedBytes", "maxRetainedBytes", "maxWork", "maxResources"]) {
+      if (!Number.isSafeInteger(limits.resources[key]) || limits.resources[key] < 1) {
+        throw new WkhtmltopdfError("INVALID_VALUE", "Resource limits must be positive safe integers");
+      }
+    }
+    const admission = new ParseBudget({ limits: limits.parse, signal });
+    admission.admitArguments(context.args.length);
+    for (const arg of context.args)
+      admission.admitText(arg);
+    const carrier = context.argumentValues === void 0 ? void 0 : getCommandArguments(context);
+    const argv = [];
+    let argumentBytes = 0;
+    for (let index = 0; index < context.args.length; index++) {
+      signal.throwIfAborted();
+      if (carrier === void 0 || typeof carrier.values[index] === "string") {
+        argv.push(context.args[index]);
+        continue;
+      }
+      const bytes = carrier.bytes(index);
+      if (bytes.byteLength > limits.parse.maxTextBytes - argumentBytes)
+        throw new WkhtmltopdfError("LIMIT_EXCEEDED", "CLI argument byte limit exceeded");
+      argumentBytes += bytes.byteLength;
+      try {
+        argv.push(decoder.decode(bytes));
+      } catch {
+        throw new WkhtmltopdfError("INVALID_VALUE", "CLI arguments must be valid UTF-8");
+      }
+    }
+    const parse = (args, batchJob = false) => parseInvocation(args, { limits: limits.parse, signal, endOfOptions: true, batchJob });
+    const initial = parse(argv);
+    if (initial.mode === "information") {
+      let text;
+      if (initial.global.action === "help" || initial.global.action === "extended-help") {
+        text = "Usage: wkhtmltopdf [options] [page|cover input|toc]... output\nStatic first-party renderer requires an explicit binding. Input/output '-' use stdin/stdout.\n";
+      } else if (initial.global.action === "version") {
+        text = "wkhtmltopdf safe static adapter (source 024b2b2bb459dd904d15b911d04c6df4ff2c9031; Qt compatibility unqualified)\n";
+      } else
+        throw new WkhtmltopdfError("UNSUPPORTED_CAPABILITY", "Information action is unavailable in the static profile", initial.global.action);
+      if (shellValueByteLength(text) > limits.maxOutputBytes) {
+        throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Information output byte limit exceeded");
+      }
+      await writeBytes(stdout.output, encoder.encode(text), signal);
+      result = { kind: "information", exitCode: 0 };
+    } else {
+      const renderer = options.renderer;
+      if (!renderer)
+        throw new WkhtmltopdfError("UNSUPPORTED_CAPABILITY", "A qualified first-party static renderer binding is required");
+      requireRendererFeatures(renderer.profile, []);
+      let outputBytes = 0;
+      let outputChunks = 0;
+      let jobs = 0;
+      let inputBytes = 0;
+      let currentInputs = [];
+      let produced;
+      resourceRun = Promise.resolve().then(() => withResources({
+        limits: limits.resources,
+        signal,
+        vfs: async (reference, readSignal) => {
+          if (reference === "vfs:output") {
+            if (!produced)
+              throw new WkhtmltopdfError("INVALID_VALUE", "No renderer output is active");
+            const document = produced;
+            return {
+              chunks: (async function* () {
+                for await (const chunk of document.chunks) {
+                  readSignal.throwIfAborted();
+                  if (byteType.call(chunk) !== "Uint8Array")
+                    throw new WkhtmltopdfError("INVALID_VALUE", "Renderer must produce byte chunks");
+                  const length2 = byteLength.call(chunk);
+                  if (++outputChunks > limits.maxOutputChunks || length2 > limits.maxOutputBytes - outputBytes) {
+                    throw new WkhtmltopdfError("LIMIT_EXCEEDED", "PDF output stage limit exceeded");
+                  }
+                  outputBytes += length2;
+                  yield chunk;
+                }
+              })(),
+              close: retire
+            };
+          }
+          const index = Number(reference.slice("vfs:input/".length));
+          const input = currentInputs[index];
+          if (input === void 0)
+            throw new WkhtmltopdfError("INVALID_VALUE", "Unknown invocation input identity");
+          if (input === "-")
+            return {
+              chunks: (async function* () {
+                for await (const chunk of readBytes(context.stdin, readSignal)) {
+                  inputBytes += byteLength.call(chunk);
+                  context.inputBudget?.check(inputBytes);
+                  yield chunk;
+                }
+              })(),
+              async close() {
+              }
+            };
+          if (!context.fs.openReadFile)
+            throw new WkhtmltopdfError("UNSUPPORTED_CAPABILITY", "VFS requires bounded read handles");
+          const handle = await context.fs.openReadFile(resolvePath(context.cwd, input), { signal: readSignal });
+          let position = 0;
+          return {
+            chunks: (async function* () {
+              for (; ; ) {
+                readSignal.throwIfAborted();
+                const chunk = await handle.read(position, Math.min(65536, limits.resources.maxInputBytes, limits.resources.maxDecodedBytes, limits.resources.maxRetainedBytes, Math.max(1, context.inputBudget?.maxBytes ?? limits.resources.maxInputBytes)), { signal: readSignal });
+                if (byteType.call(chunk) !== "Uint8Array")
+                  throw new WkhtmltopdfError("INVALID_VALUE", "VFS must produce byte chunks");
+                const length2 = byteLength.call(chunk);
+                if (!length2)
+                  return;
+                inputBytes += length2;
+                context.inputBudget?.check(inputBytes);
+                position += length2;
+                yield chunk;
+              }
+            })(),
+            close: () => handle.close()
+          };
+        }
+      }, async (resources) => {
+        const convert = async (job, batch) => {
+          if (++jobs > limits.maxBatchJobs)
+            throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Batch job limit exceeded");
+          currentInputs = job.objects.map((object) => {
+            if (object.input === null)
+              throw new WkhtmltopdfError("UNSUPPORTED_CAPABILITY", "TOC requires a qualified outline/XSLT engine");
+            if (batch && object.input === "-")
+              throw new WkhtmltopdfError("UNSUPPORTED_CAPABILITY", "Batch conversion cannot share stdin with HTML input");
+            return object.input;
+          });
+          let destination;
+          if (job.output !== "-") {
+            if (!context.fs.writeFileConditional) {
+              throw new WkhtmltopdfError("UNSUPPORTED_CAPABILITY", "VFS requires conditional file publication");
+            }
+            const requested = resolvePath(context.cwd, job.output);
+            const parentPath = await context.fs.realpath(dirname(requested), { signal });
+            const path = resolvePath(parentPath, basename(requested));
+            const parent = await context.fs.stat(parentPath, { signal });
+            let expected = null;
+            try {
+              expected = await context.fs.lstat(path, { signal });
+            } catch (error) {
+              if (!(error instanceof FsError && error.code === "ENOENT"))
+                throw error;
+            }
+            if (expected !== null && expected.type !== "file") {
+              throw new WkhtmltopdfError("INVALID_VALUE", "Output must be a regular VFS file or absent");
+            }
+            for (let index = 0; index < currentInputs.length; index++) {
+              const input = currentInputs[index];
+              if (input === "-")
+                continue;
+              const source = await context.fs.realpath(resolvePath(context.cwd, input), { signal });
+              currentInputs[index] = source;
+              if (source === path || expected !== null && await compareEntries(context.fs, source, context.fs, path, { signal }) !== "distinct") {
+                throw new WkhtmltopdfError("INVALID_VALUE", "Input and output VFS identities must be distinct");
+              }
+            }
+            destination = { path, condition: { parent, expected, signal } };
+          }
+          const inputs = [];
+          for (let index = 0; index < currentInputs.length; index++)
+            inputs.push(await resources.load("vfs:input/" + index));
+          signal.throwIfAborted();
+          opening = Promise.resolve().then(() => {
+            signal.throwIfAborted();
+            return renderer.open({ job, inputs, signal, limits });
+          });
+          closing = void 0;
+          const document = await opening;
+          produced = document;
+          signal.throwIfAborted();
+          const outcome2 = conversionOutcome({
+            mode: batch ? "batch" : "single",
+            success: document.success,
+            errorCode: document.errorCode,
+            ...document.networkErrorName === void 0 ? {} : { networkErrorName: document.networkErrorName }
+          });
+          let pdf;
+          if (outcome2.exitCode === 0) {
+            pdf = await resources.load("vfs:output");
+          }
+          await retire();
+          opening = void 0;
+          closing = void 0;
+          produced = void 0;
+          signal.throwIfAborted();
+          if (outcome2.exitCode === 0) {
+            if (job.output === "-")
+              await writeBytes(stdout.output, pdf, signal);
+            else
+              await context.fs.writeFileConditional(destination.path, pdf, destination.condition);
+          } else
+            await diagnostic({ ...context, stderr: stderr.output }, outcome2, signal);
+          return outcome2;
+        };
+        let outcome = { exitCode: 0, diagnostic: null };
+        if (initial.mode === "batch") {
+          currentInputs = ["-"];
+          const bytes = await resources.load("vfs:input/0");
+          let text;
+          try {
+            text = decoder.decode(bytes);
+          } catch {
+            throw new WkhtmltopdfError("INVALID_VALUE", "Batch input must be valid UTF-8");
+          }
+          let start = 0;
+          for (let end = 0; end <= text.length; end++) {
+            signal.throwIfAborted();
+            if (end !== text.length && text[end] !== "\n")
+              continue;
+            if (end === text.length && start === end)
+              break;
+            const args = tokenizeBatchLine(text.slice(start, end), { limits: limits.parse, signal });
+            const job = parse([...argv, ...args], true);
+            if (job.mode !== "conversion")
+              throw new WkhtmltopdfError("UNSUPPORTED_CAPABILITY", "Batch lines must describe conversion jobs");
+            outcome = await convert(job, true);
+            if (outcome.exitCode !== 0)
+              break;
+            start = end + 1;
+          }
+        } else
+          outcome = await convert(initial, false);
+        return { kind: "conversion", exitCode: outcome.exitCode, jobs, outcome, usage: resources.usage };
+      }));
+      result = await resourceRun;
+    }
+  } catch (error) {
+    if (context.signal.aborted) {
+      primary = true;
+      failure = context.signal.reason;
+    } else if (signal.aborted) {
+      primary = true;
+      failure = signal.reason;
+    } else if (error instanceof WkhtmltopdfError || error instanceof FsError) {
+      try {
+        const option = error instanceof WkhtmltopdfError ? error.option : void 0;
+        await writeBytes(stderr.output, encoder.encode(`wkhtmltopdf: ${error.code}${option ? ` (${option})` : ""}: ${error.message}
+`), signal);
+        result = { kind: "rejected", exitCode: 1, code: error.code };
+      } catch (writeError) {
+        primary = true;
+        failure = writeError;
+      }
+    } else {
+      primary = true;
+      failure = error;
+    }
+  } finally {
+    try {
+      await cleanup();
+    } catch (error) {
+      if (primary)
+        failure = new AggregateError([failure, error], "Invocation and cleanup failed");
+      else {
+        primary = true;
+        failure = error;
+      }
+    }
+  }
+  if (primary)
+    throw failure;
+  return result;
+}
+async function diagnostic(context, outcome, signal) {
+  const value = outcome.diagnostic;
+  if (!value)
+    return;
+  const message = value.kind === "http" ? `Exit with code ${outcome.exitCode} due to http error: ${value.code} ${value.description}` : value.kind === "network" ? `Exit with code 1 due to network error: ${value.name ?? "UnqualifiedNetworkError"}` : "Exit with code 1, due to unknown error.";
+  await writeBytes(context.stderr, encoder.encode(message + "\n"), signal);
+}
+function createWkhtmltopdfCommand(options = { limits: wkhtmltopdfLimits }) {
+  return Object.freeze({
+    name: "wkhtmltopdf",
+    runtimeIdentity: commandRuntimeIdentity,
+    description: "Bounded static HTML-to-PDF adapter with an explicit first-party renderer",
+    execute: (context) => runWkhtmltopdf(context, options)
+  });
+}
+var wkhtmltopdfCommand = createWkhtmltopdfCommand();
+function wkhtmltopdfCommands(options = { limits: wkhtmltopdfLimits }) {
+  const command = createWkhtmltopdfCommand(options);
+  return { name: "wkhtmltopdf-commands", setup(host) {
+    host.commands.register(command);
+  } };
+}
+export {
+  WkhtmltopdfError,
+  conversionOutcome,
+  createWkhtmltopdfCommand,
+  parseInvocation,
+  planPageSequence,
+  requireRendererFeatures,
+  runWkhtmltopdf,
+  switches,
+  tokenizeBatchLine,
+  withResources,
+  wkhtmltopdfCommand,
+  wkhtmltopdfCommands,
+  wkhtmltopdfLimits
+};
+//# sourceMappingURL=index.js.map