@json-to-office/jto-ops 1.2.0

package/dist/index.js

@@ -0,0 +1,1460 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/format-adapter.ts
+import * as path5 from "path";
+import * as fs5 from "fs";
+import { validatePresentationDocument } from "@json-to-office/shared-pptx";
+import { validate as validateDocx } from "@json-to-office/shared-docx";
+
+// src/pptx-rasterizer.ts
+import { execFile } from "child_process";
+import { promises as fs4 } from "fs";
+import os from "os";
+import path4 from "path";
+import crypto from "crypto";
+import {
+  DEFAULT_VISUAL_DPI
+} from "@json-to-office/shared";
+import { fromRasterizeFontFaces } from "@json-to-office/shared/fonts/node";
+
+// src/font-staging/noop-stager.ts
+var NoopFontStager = class {
+  // Signature matches FontStager; every parameter (including `options`) is
+  // deliberately ignored on platforms with no staging mechanism.
+  async stage(_fonts, _tempDir, _options) {
+    return {
+      envOverrides: {},
+      cleanup: async () => {
+      }
+    };
+  }
+};
+
+// src/font-staging/fontconfig-stager.ts
+import { promises as fs } from "fs";
+import path from "path";
+import {
+  synthesizeFamilyName,
+  rewriteFontFamilyName
+} from "@json-to-office/shared";
+
+// src/font-staging/types.ts
+var counter = 0;
+function nextStagingId() {
+  counter += 1;
+  return `${process.pid}-${counter}`;
+}
+function safeFilenamePart(s) {
+  return s.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 48);
+}
+
+// src/font-staging/fontconfig-stager.ts
+var SYSTEM_FONTS_CONF_CANDIDATES = [
+  "/etc/fonts/fonts.conf",
+  "/opt/homebrew/etc/fonts/fonts.conf",
+  "/usr/local/etc/fonts/fonts.conf"
+];
+var FontconfigStager = class {
+  async stage(fonts, tempDir, _options) {
+    const id = nextStagingId();
+    const fontsDir = path.join(tempDir, "fonts");
+    await fs.mkdir(fontsDir, { recursive: true });
+    let serial = 0;
+    for (const r of fonts) {
+      if (r.sources.length === 0) continue;
+      for (const s of r.sources) {
+        serial += 1;
+        const suffix = s.italic ? "i" : "r";
+        const synth = synthesizeFamilyName(r.family, s.weight, s.italic);
+        const data = synth.family === r.family ? s.data : rewriteFontFamilyName(s.data, synth.family);
+        const name = `${safeFilenamePart(synth.family)}-${s.weight}${suffix}-${id}-${serial}.ttf`;
+        await fs.writeFile(path.join(fontsDir, name), data);
+      }
+    }
+    await fs.chmod(fontsDir, 365).catch(() => {
+    });
+    const includeLines = await this.pickSystemIncludes();
+    const cacheDir = path.join(tempDir, "fc-cache");
+    await fs.mkdir(cacheDir, { recursive: true });
+    const configPath = path.join(tempDir, "fontconfig.xml");
+    const configXml = [
+      '<?xml version="1.0"?>',
+      '<!DOCTYPE fontconfig SYSTEM "fonts.dtd">',
+      "<fontconfig>",
+      `  <dir>${escapeXml(fontsDir)}</dir>`,
+      `  <cachedir>${escapeXml(cacheDir)}</cachedir>`,
+      ...includeLines,
+      "</fontconfig>",
+      ""
+    ].join("\n");
+    await fs.writeFile(configPath, configXml, "utf8");
+    return {
+      envOverrides: {
+        FONTCONFIG_FILE: configPath,
+        XDG_CACHE_HOME: cacheDir
+      },
+      cleanup: async () => {
+        await fs.chmod(fontsDir, 493).catch(() => {
+        });
+      }
+    };
+  }
+  async pickSystemIncludes() {
+    for (const candidate of SYSTEM_FONTS_CONF_CANDIDATES) {
+      try {
+        await fs.access(candidate);
+        return [
+          `  <include ignore_missing="yes">${escapeXml(candidate)}</include>`
+        ];
+      } catch {
+      }
+    }
+    return [`  <include ignore_missing="yes">/etc/fonts/fonts.conf</include>`];
+  }
+};
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// src/font-staging/windows-stager.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+import {
+  synthesizeFamilyName as synthesizeFamilyName2,
+  rewriteFontFamilyName as rewriteFontFamilyName2
+} from "@json-to-office/shared";
+var cachedBindings = null;
+async function getGdiBindings() {
+  if (cachedBindings) return cachedBindings;
+  const koffi = await import("koffi");
+  const mod = koffi.default ?? koffi;
+  const gdi32 = mod.load("gdi32.dll");
+  cachedBindings = {
+    addFont: gdi32.func("int __stdcall AddFontResourceW(str16)"),
+    removeFont: gdi32.func("bool __stdcall RemoveFontResourceW(str16)")
+  };
+  return cachedBindings;
+}
+var WindowsFontStager = class {
+  async stage(fonts, tempDir, _options) {
+    const id = nextStagingId();
+    const fontsDir = path2.join(tempDir, "fonts");
+    await fs2.mkdir(fontsDir, { recursive: true });
+    const stagedPaths = [];
+    let serial = 0;
+    for (const r of fonts) {
+      if (r.sources.length === 0) continue;
+      for (const s of r.sources) {
+        serial += 1;
+        const suffix = s.italic ? "i" : "r";
+        const synth = synthesizeFamilyName2(r.family, s.weight, s.italic);
+        const data = synth.family === r.family ? s.data : rewriteFontFamilyName2(s.data, synth.family);
+        const name = `${safeFilenamePart(synth.family)}-${s.weight}${suffix}-${id}-${serial}.ttf`;
+        const fullPath = path2.join(fontsDir, name);
+        await fs2.writeFile(fullPath, data);
+        stagedPaths.push(fullPath);
+      }
+    }
+    if (stagedPaths.length === 0) {
+      return { envOverrides: {}, cleanup: async () => {
+      } };
+    }
+    const { addFont, removeFont } = await getGdiBindings();
+    const registered = [];
+    for (const p of stagedPaths) {
+      const added = addFont(p);
+      if (added > 0) registered.push(p);
+    }
+    let cleaned = false;
+    return {
+      envOverrides: {
+        // Force GDI backend so the freshly-registered fonts are visible.
+        // Skia on Windows uses DirectWrite which does not reliably see
+        // fonts added via AddFontResourceW.
+        SAL_DISABLE_SKIA: "1"
+      },
+      cleanup: async () => {
+        if (cleaned) return;
+        cleaned = true;
+        for (const p of registered) {
+          try {
+            removeFont(p);
+          } catch {
+          }
+        }
+      }
+    };
+  }
+};
+
+// src/font-staging/macos-stager.ts
+import { promises as fs3 } from "fs";
+import path3 from "path";
+import {
+  synthesizeFamilyName as synthesizeFamilyName3,
+  rewriteFontFamilyName as rewriteFontFamilyName3
+} from "@json-to-office/shared";
+
+// src/diagnostics.ts
+import { AsyncLocalStorage } from "async_hooks";
+var sinks = new AsyncLocalStorage();
+function runWithDiagnosticSink(sink, callback) {
+  return sinks.run(sink, callback);
+}
+function emitDiagnostic(text, tone = "muted") {
+  sinks.getStore()?.(text, tone);
+}
+var stderrDiagnosticSink = (text) => {
+  process.stderr.write(`${text}
+`);
+};
+
+// src/font-staging/macos-stager.ts
+var PYTHON_MACRO = `# Auto-generated by @json-to-office/jto. Runs inside soffice on OnStartApp
+# to make staged fonts visible to LibreOffice's font enumeration. macOS 26
+# blocks Session/Persistent CT registration for unsigned callers, but
+# Process scope still works from inside the target process \u2014 which is
+# exactly where this macro runs.
+import os
+import sys
+import ctypes
+import ctypes.util
+
+
+def _log(msg):
+    # soffice swallows Python stdout in headless mode; stderr surfaces to
+    # the parent's pipe. The stager doesn't read this today but the
+    # converter logs stderr on failure, which is how we'll debug.
+    sys.stderr.write("[jto-font-register] " + msg + "\\n")
+
+
+def register(*_args):
+    paths_env = os.environ.get("JTO_FONT_PATHS", "")
+    if not paths_env:
+        return
+    try:
+        cf = ctypes.CDLL(ctypes.util.find_library("CoreFoundation"))
+        ct = ctypes.CDLL(ctypes.util.find_library("CoreText"))
+    except Exception as e:
+        _log("failed to load CoreFoundation/CoreText: " + repr(e))
+        return
+    cf.CFURLCreateFromFileSystemRepresentation.argtypes = [
+        ctypes.c_void_p, ctypes.c_char_p, ctypes.c_long, ctypes.c_bool,
+    ]
+    cf.CFURLCreateFromFileSystemRepresentation.restype = ctypes.c_void_p
+    cf.CFRelease.argtypes = [ctypes.c_void_p]
+    ct.CTFontManagerRegisterFontsForURL.argtypes = [
+        ctypes.c_void_p, ctypes.c_uint32, ctypes.c_void_p,
+    ]
+    ct.CTFontManagerRegisterFontsForURL.restype = ctypes.c_bool
+
+    kCTFontManagerScopeProcess = 1
+    registered = 0
+    for p in paths_env.split(os.pathsep):
+        if not p:
+            continue
+        try:
+            b = p.encode("utf-8")
+            url = cf.CFURLCreateFromFileSystemRepresentation(
+                None, b, len(b), False
+            )
+            if not url:
+                _log("CFURL failed for " + p)
+                continue
+            ok = ct.CTFontManagerRegisterFontsForURL(
+                url, kCTFontManagerScopeProcess, None
+            )
+            cf.CFRelease(url)
+            if ok:
+                registered += 1
+            else:
+                _log("CT register returned false for " + p)
+        except Exception as e:
+            _log("exception registering " + p + ": " + repr(e))
+    _log("registered " + str(registered) + " font(s) at Process scope")
+
+
+# Expose under "register" (event-binding URL) and module-level run so
+# command-line vnd.sun.star.script invocation works either way.
+g_exportedScripts = (register,)
+`;
+var REGISTRY_MOD_XCU = `<?xml version="1.0" encoding="UTF-8"?>
+<oor:items xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <item oor:path="/org.openoffice.Office.Events/ApplicationEvents/Bindings">
+    <node oor:name="OnStartApp" oor:op="replace">
+      <prop oor:name="BindingURL" oor:type="xs:string">
+        <value>vnd.sun.star.script:JtoFontRegister.py$register?language=Python&amp;location=user</value>
+      </prop>
+    </node>
+  </item>
+  <item oor:path="/org.openoffice.Office.Common/Security/Scripting">
+    <prop oor:name="MacroSecurityLevel" oor:op="fuse">
+      <value>0</value>
+    </prop>
+  </item>
+</oor:items>
+`;
+var MacOSCoreTextStager = class {
+  async stage(fonts, tempDir, options) {
+    const embeddable = fonts.filter((r) => r.sources.length > 0);
+    if (embeddable.length === 0) {
+      return { envOverrides: {}, cleanup: async () => {
+      } };
+    }
+    const fontsDir = path3.join(tempDir, "fonts");
+    await fs3.mkdir(fontsDir, { recursive: true });
+    const id = nextStagingId();
+    const fontPaths = [];
+    const staged = [];
+    let serial = 0;
+    for (const r of embeddable) {
+      for (const s of r.sources) {
+        serial += 1;
+        const suffix = s.italic ? "i" : "r";
+        const synth = synthesizeFamilyName3(r.family, s.weight, s.italic);
+        const data = synth.family === r.family ? s.data : rewriteFontFamilyName3(s.data, synth.family);
+        const name = `${safeFilenamePart(synth.family)}-${s.weight}${suffix}-${id}-${serial}.ttf`;
+        const full = path3.join(fontsDir, name);
+        await fs3.writeFile(full, data);
+        fontPaths.push(full);
+        staged.push({
+          family: synth.family,
+          weight: s.weight,
+          italic: s.italic,
+          path: full
+        });
+      }
+    }
+    if (process.env.JTO_DEBUG_FONTS === "1") {
+      emitDiagnostic(
+        "[jto macos-stager] staged " + staged.length + " font(s) for CT Process-scope registration; JTO_FONT_PATHS has " + fontPaths.length + " entries\n" + staged.map(
+          (s) => `  ${s.family} (w=${s.weight}${s.italic ? " italic" : ""}) \u2192 ${path3.basename(s.path)}`
+        ).join("\n")
+      );
+    }
+    const profileDirs = options?.profileDirs?.length ? options.profileDirs : [path3.join(tempDir, "user-profile")];
+    for (const profileDir of profileDirs) {
+      const profileUser = path3.join(profileDir, "user");
+      const scriptsDir = path3.join(profileUser, "Scripts", "python");
+      await fs3.mkdir(scriptsDir, { recursive: true });
+      await fs3.writeFile(
+        path3.join(scriptsDir, "JtoFontRegister.py"),
+        PYTHON_MACRO
+      );
+      await fs3.writeFile(
+        path3.join(profileUser, "registrymodifications.xcu"),
+        REGISTRY_MOD_XCU
+      );
+    }
+    return {
+      envOverrides: {
+        // Colon-separated list of staged TTF paths (`:` matches Python's
+        // `os.pathsep` on macOS). The macro reads this at OnStartApp.
+        JTO_FONT_PATHS: fontPaths.join(":"),
+        // Force LibreOffice's Core Graphics backend. Skia on macOS can
+        // skip Core Text's freshly-registered fonts in some builds.
+        SAL_DISABLE_SKIA: "1"
+      },
+      cleanup: async () => {
+      }
+    };
+  }
+};
+
+// src/font-staging/index.ts
+var cached = /* @__PURE__ */ new Map();
+function getFontStager(platform = process.platform) {
+  const hit = cached.get(platform);
+  if (hit) return hit;
+  let stager;
+  switch (platform) {
+    case "win32":
+      stager = new WindowsFontStager();
+      break;
+    case "darwin":
+      stager = new MacOSCoreTextStager();
+      break;
+    case "linux":
+    case "freebsd":
+    case "openbsd":
+      stager = new FontconfigStager();
+      break;
+    default:
+      stager = new NoopFontStager();
+  }
+  cached.set(platform, stager);
+  return stager;
+}
+
+// src/pptx-rasterizer.ts
+var SOFFICE_TIMEOUT_MS = 6e4;
+var SOFFICE_BATCH_EXTRA_PER_SLIDE_MS = 15e3;
+var SOFFICE_BATCH_TIMEOUT_CAP_MS = 3e5;
+var MAX_ISOLATED_RETRIES = 3;
+var PDFTOPPM_TIMEOUT_MS = 3e4;
+var PROBE_TIMEOUT_MS = 5e3;
+var MAX_BUFFER = 64 * 1024 * 1024;
+function exec(binary, args, timeoutMs, env) {
+  return new Promise((resolve2, reject) => {
+    execFile(
+      binary,
+      args,
+      {
+        timeout: timeoutMs,
+        maxBuffer: MAX_BUFFER,
+        windowsHide: true,
+        env: env ? { ...process.env, ...env } : process.env
+      },
+      (error) => error ? reject(error) : resolve2()
+    );
+  });
+}
+async function binaryWorks(binary) {
+  if (binary.includes(path4.sep)) {
+    try {
+      await fs4.access(binary);
+    } catch {
+      return false;
+    }
+  }
+  try {
+    await exec(binary, ["--version"], PROBE_TIMEOUT_MS);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    return code !== "ENOENT" && code !== "EACCES";
+  }
+}
+function sofficeCandidates() {
+  const candidates = [];
+  const configured = process.env.LIBREOFFICE_PATH?.trim();
+  if (configured) candidates.push(configured);
+  if (process.platform === "darwin") {
+    candidates.push("/Applications/LibreOffice.app/Contents/MacOS/soffice");
+  } else if (process.platform === "win32") {
+    candidates.push("C:\\Program Files\\LibreOffice\\program\\soffice.exe");
+    candidates.push(
+      "C:\\Program Files (x86)\\LibreOffice\\program\\soffice.exe"
+    );
+  }
+  candidates.push("soffice", "libreoffice");
+  return [...new Set(candidates)];
+}
+function pdftoppmCandidates() {
+  const candidates = [];
+  const configured = process.env.PDFTOPPM_PATH?.trim();
+  if (configured) candidates.push(configured);
+  candidates.push("pdftoppm");
+  return [...new Set(candidates)];
+}
+async function resolveBinary(candidates, label, install) {
+  for (const candidate of candidates) {
+    if (await binaryWorks(candidate)) return candidate;
+  }
+  throw new Error(
+    `Visual rasterization needs ${label}, which was not found. ${install} (searched: ${candidates.join(", ")}).`
+  );
+}
+var sofficePromise;
+var pdftoppmPromise;
+function resolveSoffice() {
+  if (!sofficePromise) {
+    sofficePromise = resolveBinary(
+      sofficeCandidates(),
+      "LibreOffice (soffice)",
+      "Install LibreOffice or set LIBREOFFICE_PATH."
+    ).catch((error) => {
+      sofficePromise = void 0;
+      throw error;
+    });
+  }
+  return sofficePromise;
+}
+function resolvePdftoppm() {
+  if (!pdftoppmPromise) {
+    pdftoppmPromise = resolveBinary(
+      pdftoppmCandidates(),
+      "pdftoppm (poppler)",
+      "Install poppler-utils or set PDFTOPPM_PATH."
+    ).catch((error) => {
+      pdftoppmPromise = void 0;
+      throw error;
+    });
+  }
+  return pdftoppmPromise;
+}
+var rasterizerCounters = {
+  diskHits: 0,
+  diskMisses: 0,
+  dedupedRequests: 0,
+  rendered: 0,
+  failed: 0
+};
+var knownCacheDirs = /* @__PURE__ */ new Set();
+async function getRasterizerCacheStats() {
+  const dirs = new Set(knownCacheDirs);
+  const defaultDir = resolveCacheDir();
+  if (defaultDir) dirs.add(defaultDir);
+  let entries = 0;
+  let bytes = 0;
+  for (const dir of dirs) {
+    try {
+      const files = await fs4.readdir(dir);
+      for (const file of files) {
+        if (!file.endsWith(".png")) continue;
+        try {
+          const stat = await fs4.stat(path4.join(dir, file));
+          entries++;
+          bytes += stat.size;
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  const lookups = rasterizerCounters.diskHits + rasterizerCounters.diskMisses;
+  return {
+    ...rasterizerCounters,
+    hitRate: lookups > 0 ? rasterizerCounters.diskHits / lookups : 0,
+    entries,
+    bytes
+  };
+}
+async function clearRasterizerCache() {
+  const dirs = new Set(knownCacheDirs);
+  const defaultDir = resolveCacheDir();
+  if (defaultDir) dirs.add(defaultDir);
+  for (const dir of dirs) {
+    try {
+      const files = await fs4.readdir(dir);
+      await Promise.all(
+        files.filter((file) => file.endsWith(".png")).map((file) => fs4.rm(path4.join(dir, file), { force: true }))
+      );
+    } catch {
+    }
+  }
+  rasterizerCounters.diskHits = 0;
+  rasterizerCounters.diskMisses = 0;
+  rasterizerCounters.dedupedRequests = 0;
+  rasterizerCounters.rendered = 0;
+  rasterizerCounters.failed = 0;
+}
+var PNG_SIGNATURE = Buffer.from([
+  137,
+  80,
+  78,
+  71,
+  13,
+  10,
+  26,
+  10
+]);
+function parsePngSize(png) {
+  if (png.length < 24) return null;
+  if (!png.subarray(0, 8).equals(PNG_SIGNATURE)) return null;
+  if (png.toString("ascii", 12, 16) !== "IHDR") return null;
+  const width = png.readUInt32BE(16);
+  const height = png.readUInt32BE(20);
+  if (width <= 0 || height <= 0) return null;
+  return { width, height };
+}
+var tmpCounter = 0;
+async function writeCacheAtomic(cacheDir, cachePath, png) {
+  const tmp = `${cachePath}.tmp-${process.pid}-${tmpCounter++}`;
+  try {
+    await fs4.mkdir(cacheDir, { recursive: true });
+    await fs4.writeFile(tmp, png);
+    await fs4.rename(tmp, cachePath);
+  } catch {
+    await fs4.rm(tmp, { force: true }).catch(() => {
+    });
+  }
+}
+function fontsDigest(fonts) {
+  if (!fonts || fonts.length === 0) return void 0;
+  const parts = fonts.map(
+    (f) => `${f.family}|${f.weight}|${f.italic ? "i" : "r"}|` + crypto.createHash("sha256").update(Buffer.from(f.data, "base64")).digest("hex")
+  ).sort();
+  return crypto.createHash("sha256").update(parts.join("\n")).digest("hex");
+}
+function cacheKey(request) {
+  return crypto.createHash("sha256").update(
+    JSON.stringify({
+      p: request.presentation,
+      dpi: request.dpi,
+      base: request.baseDir,
+      f: request.fontsKey ?? null
+    })
+  ).digest("hex");
+}
+function toDataUri(png) {
+  return `data:image/png;base64,${png.toString("base64")}`;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function fileExists(filePath) {
+  try {
+    await fs4.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var sofficeArgs = (profileDir, outDir, files) => [
+  "--headless",
+  "--norestore",
+  "--nolockcheck",
+  "--nodefault",
+  `-env:UserInstallation=file://${profileDir.replace(/\\/g, "/")}`,
+  "--convert-to",
+  "pdf:impress_pdf_Export",
+  "--outdir",
+  outDir,
+  ...files
+];
+async function rasterizeSlidesWithEngine(slides, baseDir, cacheDir, fonts) {
+  const results = new Array(slides.length);
+  if (cacheDir) knownCacheDirs.add(cacheDir);
+  const fontsKey = fontsDigest(fonts);
+  const jobsByKey = /* @__PURE__ */ new Map();
+  for (let i = 0; i < slides.length; i++) {
+    const slide = slides[i];
+    const key = cacheKey({
+      presentation: slide.presentation,
+      dpi: slide.dpi,
+      baseDir,
+      fontsKey
+    });
+    const existing = jobsByKey.get(key);
+    if (existing) {
+      existing.indexes.push(i);
+    } else {
+      jobsByKey.set(key, {
+        presentation: slide.presentation,
+        dpi: slide.dpi,
+        indexes: [i],
+        cachePath: cacheDir ? path4.join(cacheDir, `${key}.png`) : null,
+        pptxPath: "",
+        pdfPath: "",
+        pngPrefix: ""
+      });
+    }
+  }
+  rasterizerCounters.dedupedRequests += slides.length - jobsByKey.size;
+  const fail = (job, stage, error, cause) => {
+    rasterizerCounters.failed++;
+    for (const i of job.indexes)
+      results[i] = { ok: false, error, stage, cause };
+  };
+  const succeed = (job, result) => {
+    for (const i of job.indexes) results[i] = { ok: true, ...result };
+  };
+  const uncached = [];
+  await Promise.all(
+    [...jobsByKey.values()].map(async (job) => {
+      if (job.cachePath) {
+        const cached2 = await fs4.readFile(job.cachePath).catch(() => null);
+        if (cached2) {
+          const size = parsePngSize(cached2);
+          if (size) {
+            rasterizerCounters.diskHits++;
+            succeed(job, { base64DataUri: toDataUri(cached2), ...size });
+            return;
+          }
+          await fs4.rm(job.cachePath, { force: true }).catch(() => {
+          });
+        }
+        rasterizerCounters.diskMisses++;
+      }
+      uncached.push(job);
+    })
+  );
+  if (uncached.length === 0) return results;
+  const corePptx = await import("@json-to-office/core-pptx");
+  const tempDir = await fs4.mkdtemp(path4.join(os.tmpdir(), "jto-visual-"));
+  let stageHandle = null;
+  try {
+    const built = [];
+    for (let j = 0; j < uncached.length; j++) {
+      const job = uncached[j];
+      job.pptxPath = path4.join(tempDir, `slide-${j}.pptx`);
+      job.pdfPath = path4.join(tempDir, `slide-${j}.pdf`);
+      job.pngPrefix = path4.join(tempDir, `slide-${j}`);
+      try {
+        const pptxBuffer = await corePptx.generateBufferFromJson(
+          job.presentation,
+          { baseDir }
+        );
+        await fs4.writeFile(job.pptxPath, pptxBuffer);
+        built.push(job);
+      } catch (error) {
+        fail(job, "build", errorMessage(error), error);
+      }
+    }
+    if (built.length === 0) return results;
+    const profileDirs = [
+      path4.join(tempDir, "profile"),
+      ...Array.from(
+        { length: MAX_ISOLATED_RETRIES },
+        (_, r) => path4.join(tempDir, `profile-retry-${r}`)
+      )
+    ];
+    const stageFonts = fonts?.length ? fromRasterizeFontFaces(fonts) : [];
+    if (stageFonts.length > 0) {
+      stageHandle = await getFontStager().stage(stageFonts, tempDir, {
+        profileDirs
+      });
+    }
+    const sofficeEnv = stageHandle?.envOverrides;
+    const [soffice, pdftoppm] = await Promise.all([
+      resolveSoffice(),
+      resolvePdftoppm()
+    ]);
+    const batchTimeoutMs = Math.min(
+      SOFFICE_TIMEOUT_MS + SOFFICE_BATCH_EXTRA_PER_SLIDE_MS * (built.length - 1),
+      SOFFICE_BATCH_TIMEOUT_CAP_MS
+    );
+    const deadlineAt = Date.now() + batchTimeoutMs + PDFTOPPM_TIMEOUT_MS * built.length;
+    const remainingMs = () => deadlineAt - Date.now();
+    let batchError;
+    try {
+      await exec(
+        soffice,
+        sofficeArgs(
+          profileDirs[0],
+          tempDir,
+          built.map((job) => job.pptxPath)
+        ),
+        batchTimeoutMs,
+        sofficeEnv
+      );
+    } catch (error) {
+      batchError = error;
+    }
+    const converted = [];
+    const missing = [];
+    for (const job of built) {
+      (await fileExists(job.pdfPath) ? converted : missing).push(job);
+    }
+    let retriesLeft = missing.length > 0 && built.length > 1 && (batchError === void 0 || converted.length > 0) ? MAX_ISOLATED_RETRIES : 0;
+    for (const [r, job] of missing.entries()) {
+      const retryBudget = Math.min(SOFFICE_TIMEOUT_MS, remainingMs());
+      if (retriesLeft > 0 && retryBudget > 1e3) {
+        retriesLeft--;
+        let retryError;
+        try {
+          await exec(
+            soffice,
+            // Same directories seeded in `profileDirs` above (index 0 is the
+            // batch profile, so retry `r` is `profileDirs[r + 1]`); the
+            // literal is kept as the fallback for an out-of-range retry.
+            sofficeArgs(
+              profileDirs[r + 1] ?? path4.join(tempDir, `profile-retry-${r}`),
+              tempDir,
+              [job.pptxPath]
+            ),
+            retryBudget,
+            sofficeEnv
+          );
+        } catch (error) {
+          retryError = error;
+        }
+        if (await fileExists(job.pdfPath)) {
+          converted.push(job);
+          continue;
+        }
+        batchError ??= retryError;
+      }
+      const cause = batchError;
+      fail(
+        job,
+        "convert",
+        `LibreOffice failed to convert the slide to PDF${cause ? `: ${errorMessage(cause)}` : "."}`,
+        cause
+      );
+    }
+    for (const job of converted) {
+      const budget = Math.min(PDFTOPPM_TIMEOUT_MS, remainingMs());
+      if (budget <= 1e3) {
+        fail(
+          job,
+          "rasterize",
+          "Rasterization deadline exceeded before this slide could be converted to PNG."
+        );
+        continue;
+      }
+      try {
+        await exec(
+          pdftoppm,
+          [
+            "-r",
+            String(job.dpi),
+            "-png",
+            "-singlefile",
+            job.pdfPath,
+            job.pngPrefix
+          ],
+          budget
+        );
+        const png = await fs4.readFile(`${job.pngPrefix}.png`);
+        const size = parsePngSize(png);
+        if (!size) {
+          throw new Error(
+            "Rasterization produced an invalid PNG (empty or truncated output from pdftoppm)."
+          );
+        }
+        if (job.cachePath) {
+          await writeCacheAtomic(cacheDir, job.cachePath, png);
+        }
+        rasterizerCounters.rendered++;
+        succeed(job, { base64DataUri: toDataUri(png), ...size });
+      } catch (error) {
+        fail(job, "rasterize", errorMessage(error), error);
+      }
+    }
+    return results;
+  } finally {
+    if (stageHandle) await stageHandle.cleanup().catch(() => {
+    });
+    await fs4.rm(tempDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+function resolveCacheDir(options) {
+  return options?.cacheDir === void 0 ? path4.join(os.tmpdir(), "jto-visual-cache") : options.cacheDir;
+}
+function createLibreOfficePptxRasterizer(options) {
+  const cacheDir = resolveCacheDir(options);
+  return async function rasterize(request) {
+    const [result] = await rasterizeSlidesWithEngine(
+      [{ presentation: request.presentation, dpi: request.dpi }],
+      request.baseDir,
+      cacheDir,
+      request.fonts
+    );
+    if (!result) throw new Error("Rasterization produced no result.");
+    if (!result.ok) {
+      const error = new Error(result.error);
+      if (result.cause !== void 0) error.cause = result.cause;
+      throw error;
+    }
+    return {
+      base64DataUri: result.base64DataUri,
+      width: result.width,
+      height: result.height
+    };
+  };
+}
+function createLibreOfficePptxBatchRasterizer(options) {
+  const cacheDir = resolveCacheDir(options);
+  return async function rasterizeBatch(request) {
+    const engineResults = await rasterizeSlidesWithEngine(
+      request.slides.map((slide) => ({
+        presentation: slide.presentation,
+        dpi: slide.dpi ?? DEFAULT_VISUAL_DPI
+      })),
+      request.baseDir,
+      cacheDir,
+      request.fonts
+    );
+    return {
+      results: engineResults.map(
+        (result) => result.ok ? result : { ok: false, error: result.error, stage: result.stage }
+      )
+    };
+  };
+}
+
+// src/format-adapter.ts
+function emitGenerationWarnings(warnings) {
+  for (const warning of warnings) {
+    emitDiagnostic(
+      `${warning.component}: ${warning.message}`,
+      warning.severity === "info" ? "info" : "warning"
+    );
+  }
+}
+function toGenerationWarnings(raw) {
+  return (raw ?? []).map((w) => ({
+    component: w?.component ?? "pptx",
+    message: String(w?.message ?? ""),
+    severity: w?.severity === "info" ? "info" : "warning",
+    context: {
+      ...w?.context && typeof w.context === "object" ? w.context : {},
+      ...w?.code !== void 0 && { code: w.code },
+      ...w?.slide !== void 0 && { slide: w.slide }
+    }
+  }));
+}
+var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function safeThemeKey(name) {
+  return name && !UNSAFE_KEYS.has(name) ? name : "custom";
+}
+var CLI_THEME_KEY = "jto-cli-theme";
+function withRequestedTheme(document, theme, customThemes) {
+  if (!theme || typeof document !== "object" || document === null) {
+    return { document, customThemes };
+  }
+  return {
+    document: {
+      ...document,
+      props: { ...document.props, theme: CLI_THEME_KEY }
+    },
+    customThemes: { ...customThemes, [CLI_THEME_KEY]: theme }
+  };
+}
+function buildServicesFromEnv() {
+  const serverUrl = process.env.HIGHCHARTS_SERVER_URL;
+  const apiKey = process.env.HIGHCHARTS_API_KEY;
+  const apiKeyHeader = process.env.HIGHCHARTS_API_KEY_HEADER ?? "x-api-key";
+  if (!serverUrl && !apiKey) return void 0;
+  return {
+    highcharts: {
+      serverUrl,
+      ...apiKey && { headers: { [apiKeyHeader]: apiKey } }
+    }
+  };
+}
+var cachedRasterizer;
+function getPptxRasterizer() {
+  if (!cachedRasterizer) {
+    cachedRasterizer = createLibreOfficePptxRasterizer();
+  }
+  return cachedRasterizer;
+}
+var cachedBatchRasterizer;
+function getPptxBatchRasterizer() {
+  if (!cachedBatchRasterizer) {
+    cachedBatchRasterizer = createLibreOfficePptxBatchRasterizer();
+  }
+  return cachedBatchRasterizer;
+}
+function buildDocxServices() {
+  const base = buildServicesFromEnv() ?? {};
+  const serverUrl = process.env.JTO_PPTX_RASTERIZER_URL?.trim();
+  const apiKey = process.env.JTO_PPTX_RASTERIZER_API_KEY || process.env.HIGHCHARTS_API_KEY;
+  const apiKeyHeader = process.env.JTO_PPTX_RASTERIZER_API_KEY_HEADER || process.env.HIGHCHARTS_API_KEY_HEADER || "x-api-key";
+  return {
+    ...base,
+    pptx: serverUrl ? {
+      serverUrl,
+      ...apiKey && { headers: { [apiKeyHeader]: apiKey } }
+    } : {
+      render: getPptxRasterizer(),
+      renderBatch: getPptxBatchRasterizer()
+    }
+  };
+}
+var DocxFormatAdapter = class {
+  name = "docx";
+  extension = ".docx";
+  label = "document";
+  defaultPort = 3003;
+  async rendererIds() {
+    const core = await import("@json-to-office/core-docx");
+    return core.docxRendererIds();
+  }
+  async generateBuffer(json, options) {
+    const core = await import("@json-to-office/core-docx");
+    const parsed = typeof json === "string" ? JSON.parse(json) : json;
+    const resolved = await this.resolveThemes(options);
+    const { document: docDefinition, customThemes } = withRequestedTheme(
+      parsed,
+      resolved.requested,
+      resolved.customThemes
+    );
+    const services = buildDocxServices();
+    const warnings = [];
+    const buffer = await core.generateBufferFromJson(docDefinition, {
+      customThemes,
+      services,
+      fonts: options.fonts,
+      validation: {
+        allowUnknownFields: options.validation?.allowUnknownFields
+      },
+      deterministic: options.deterministic,
+      generatedAt: options.generatedAt,
+      baseDir: options.baseDir,
+      renderer: options.renderer,
+      warnings
+    });
+    emitGenerationWarnings(warnings);
+    options.warnings?.push(...toGenerationWarnings(warnings));
+    return buffer;
+  }
+  async createGenerator(plugins, options) {
+    const core = await import("@json-to-office/core-docx");
+    const hasPlugins = plugins.length > 0;
+    const pluginNames = plugins.map((p) => p.name);
+    const services = buildDocxServices();
+    const {
+      requested: requestedTheme,
+      customThemes,
+      label: themeLabel
+    } = await this.resolveThemes(options);
+    if (!hasPlugins) {
+      return {
+        generateBuffer: async (document) => {
+          const parsed = typeof document === "string" ? JSON.parse(document) : document;
+          const { document: docDefinition, customThemes: themes } = withRequestedTheme(parsed, requestedTheme, customThemes);
+          const warnings = [];
+          const buffer = await core.generateBufferFromJson(docDefinition, {
+            customThemes: themes,
+            services,
+            fonts: options.fonts,
+            validation: {
+              allowUnknownFields: options.validation?.allowUnknownFields
+            },
+            deterministic: options.deterministic,
+            generatedAt: options.generatedAt,
+            baseDir: options.baseDir,
+            renderer: options.renderer,
+            warnings
+          });
+          emitGenerationWarnings(warnings);
+          options.warnings?.push(...toGenerationWarnings(warnings));
+          return buffer;
+        },
+        hasPlugins: false,
+        pluginNames: [],
+        themeLabel
+      };
+    }
+    let generator = core.createDocumentGenerator({
+      // Undefined when nothing was requested: a constructor theme beats the
+      // generator's own `props.theme` lookup, so forcing one here would render
+      // every document in it.
+      theme: requestedTheme,
+      customThemes: requestedTheme ? { ...customThemes, [CLI_THEME_KEY]: requestedTheme } : customThemes,
+      debug: process.env.DEBUG === "true",
+      services,
+      fonts: options.fonts,
+      validation: {
+        allowUnknownFields: options.validation?.allowUnknownFields
+      },
+      deterministic: options.deterministic,
+      generatedAt: options.generatedAt,
+      baseDir: options.baseDir,
+      renderer: options.renderer
+    });
+    for (const plugin of plugins) {
+      generator = generator.addComponent(plugin);
+    }
+    return {
+      generateBuffer: async (document) => {
+        const parsed = typeof document === "string" ? JSON.parse(document) : document;
+        const { document: docDefinition } = withRequestedTheme(
+          parsed,
+          requestedTheme,
+          customThemes
+        );
+        const result = await generator.generateBuffer(docDefinition, {
+          validation: {
+            allowUnknownFields: options.validation?.allowUnknownFields
+          },
+          deterministic: options.deterministic,
+          generatedAt: options.generatedAt,
+          baseDir: options.baseDir,
+          renderer: options.renderer
+        });
+        emitGenerationWarnings(result.warnings ?? []);
+        options.warnings?.push(...toGenerationWarnings(result.warnings));
+        return result.buffer;
+      },
+      getStandardDefinition: generator.expandStandardDefinition ? async (config) => {
+        const parsed = typeof config === "string" ? JSON.parse(config) : config;
+        const { document: docDefinition } = withRequestedTheme(
+          parsed,
+          requestedTheme,
+          customThemes
+        );
+        const result = await generator.expandStandardDefinition(
+          docDefinition,
+          {
+            validation: {
+              allowUnknownFields: options.validation?.allowUnknownFields
+            }
+          }
+        );
+        emitGenerationWarnings(result.warnings ?? []);
+        return result.standardDefinition;
+      } : void 0,
+      hasPlugins: true,
+      pluginNames,
+      themeLabel
+    };
+  }
+  parseJson(input) {
+    return typeof input === "string" ? JSON.parse(input) : input;
+  }
+  validateDocument(doc) {
+    const result = validateDocx.jsonDocument(doc);
+    return {
+      valid: result.valid,
+      ...result.errors.length > 0 && { errors: result.errors }
+    };
+  }
+  generateSchema(_options) {
+    return null;
+  }
+  getBuiltinThemes() {
+    try {
+      const core = __require("@json-to-office/core-docx");
+      return core.themes || {};
+    } catch {
+      return {};
+    }
+  }
+  async resolveTheme(options) {
+    const core = await import("@json-to-office/core-docx");
+    const { requested } = await this.resolveThemes(options);
+    return requested ?? core.themes?.minimal ?? {};
+  }
+  /**
+   * Resolve `theme`/`themePath` once for a whole run: `themePath` is read a
+   * single time and feeds both the requested theme and the custom-theme
+   * registry, so a bad path warns once instead of once per consumer.
+   */
+  async resolveThemes(options) {
+    const core = await import("@json-to-office/core-docx");
+    const registry = { ...options.customThemes };
+    if (typeof options.theme === "object" && options.theme !== null) {
+      registry[safeThemeKey(options.theme.name)] = options.theme;
+    }
+    let fileTheme;
+    if (options.themePath) {
+      try {
+        if (options.themePath.endsWith(".json")) {
+          fileTheme = await core.loadThemeFromFile(options.themePath);
+        } else {
+          const themePath = path5.resolve(process.cwd(), options.themePath);
+          const themeModule = await import(themePath);
+          fileTheme = themeModule.default || themeModule.theme;
+        }
+      } catch (error) {
+        emitDiagnostic(
+          `Failed to load theme from ${options.themePath}: ${error.message}`,
+          "warning"
+        );
+      }
+      if (fileTheme) {
+        registry[safeThemeKey(fileTheme.name)] = fileTheme;
+      }
+    }
+    const customThemes = Object.keys(registry).length > 0 ? registry : void 0;
+    if (fileTheme) {
+      return { requested: fileTheme, customThemes, label: options.themePath };
+    }
+    if (typeof options.theme === "string") {
+      const named = options.customThemes?.[options.theme] ?? core.themes?.[options.theme];
+      if (named)
+        return { requested: named, customThemes, label: options.theme };
+      if (options.theme.endsWith(".json") && fs5.existsSync(options.theme)) {
+        try {
+          return {
+            requested: await core.loadThemeFromFile(options.theme),
+            customThemes,
+            label: options.theme
+          };
+        } catch {
+        }
+      }
+      try {
+        const inline = await core.loadThemeFromJson(options.theme);
+        return {
+          requested: inline,
+          customThemes,
+          label: inline?.name || options.theme
+        };
+      } catch {
+      }
+      emitDiagnostic(
+        `Unknown theme "${options.theme}"; keeping the document's own theme`,
+        "warning"
+      );
+    }
+    if (typeof options.theme === "object" && options.theme !== null) {
+      return {
+        requested: options.theme,
+        customThemes,
+        label: safeThemeKey(options.theme.name)
+      };
+    }
+    return { requested: void 0, customThemes, label: void 0 };
+  }
+  async loadCustomThemes(options) {
+    return (await this.resolveThemes(options)).customThemes;
+  }
+  async getVisualPrepassStats() {
+    try {
+      const core = await import("@json-to-office/core-docx");
+      return core.getVisualPrepassStats?.() ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async resetCacheStats() {
+    try {
+      const core = await import("@json-to-office/core-docx");
+      core.resetVisualPrepassStats?.();
+    } catch {
+    }
+  }
+};
+var PptxFormatAdapter = class {
+  name = "pptx";
+  extension = ".pptx";
+  label = "presentation";
+  defaultPort = 3004;
+  async rendererIds() {
+    const core = await import("@json-to-office/core-pptx");
+    return core.pptxRendererIds();
+  }
+  async generateBuffer(json, options) {
+    const core = await import("@json-to-office/core-pptx");
+    const parsed = typeof json === "string" ? JSON.parse(json) : json;
+    const resolved = await this.resolveThemes(options);
+    const { document: docDefinition, customThemes } = withRequestedTheme(
+      parsed,
+      resolved.requested,
+      resolved.customThemes
+    );
+    const services = buildServicesFromEnv();
+    const result = await core.generateBufferWithWarnings(docDefinition, {
+      customThemes,
+      services,
+      fonts: options.fonts,
+      validation: {
+        allowUnknownFields: options.validation?.allowUnknownFields
+      },
+      deterministic: options.deterministic,
+      generatedAt: options.generatedAt,
+      baseDir: options.baseDir,
+      renderer: options.renderer
+    });
+    const normalized = toGenerationWarnings(result.warnings);
+    emitGenerationWarnings(normalized);
+    options.warnings?.push(...normalized);
+    return result.buffer;
+  }
+  async createGenerator(plugins, options) {
+    const core = await import("@json-to-office/core-pptx");
+    const hasPlugins = plugins.length > 0;
+    const pluginNames = plugins.map((p) => p.name);
+    const services = buildServicesFromEnv();
+    const {
+      requested: requestedTheme,
+      customThemes,
+      label: themeLabel
+    } = await this.resolveThemes(options);
+    if (!hasPlugins) {
+      return {
+        generateBuffer: async (document) => {
+          const parsed = typeof document === "string" ? JSON.parse(document) : document;
+          const { document: docDefinition, customThemes: themes } = withRequestedTheme(parsed, requestedTheme, customThemes);
+          const result = await core.generateBufferWithWarnings(docDefinition, {
+            customThemes: themes,
+            services,
+            fonts: options.fonts,
+            validation: {
+              allowUnknownFields: options.validation?.allowUnknownFields
+            },
+            deterministic: options.deterministic,
+            generatedAt: options.generatedAt,
+            baseDir: options.baseDir,
+            renderer: options.renderer
+          });
+          const normalized = toGenerationWarnings(result.warnings);
+          emitGenerationWarnings(normalized);
+          options.warnings?.push(...normalized);
+          return result.buffer;
+        },
+        hasPlugins: false,
+        pluginNames: [],
+        themeLabel
+      };
+    }
+    let generator = core.createPresentationGenerator({
+      // Undefined when nothing was requested: a constructor theme beats the
+      // generator's own `props.theme` lookup, so forcing one here would render
+      // every document in it.
+      theme: requestedTheme,
+      customThemes: requestedTheme ? { ...customThemes, [CLI_THEME_KEY]: requestedTheme } : customThemes,
+      debug: process.env.DEBUG === "true",
+      services,
+      fonts: options.fonts,
+      validation: {
+        allowUnknownFields: options.validation?.allowUnknownFields
+      },
+      deterministic: options.deterministic,
+      generatedAt: options.generatedAt,
+      baseDir: options.baseDir,
+      renderer: options.renderer
+    });
+    for (const plugin of plugins) {
+      generator = generator.addComponent(plugin);
+    }
+    return {
+      generateBuffer: async (document) => {
+        const parsed = typeof document === "string" ? JSON.parse(document) : document;
+        const { document: docDefinition } = withRequestedTheme(
+          parsed,
+          requestedTheme,
+          customThemes
+        );
+        const result = await generator.generateBuffer(docDefinition, {
+          validation: {
+            allowUnknownFields: options.validation?.allowUnknownFields
+          },
+          deterministic: options.deterministic,
+          generatedAt: options.generatedAt,
+          baseDir: options.baseDir,
+          renderer: options.renderer
+        });
+        const normalized = toGenerationWarnings(result.warnings);
+        emitGenerationWarnings(normalized);
+        options.warnings?.push(...normalized);
+        return result.buffer;
+      },
+      hasPlugins: true,
+      pluginNames,
+      themeLabel
+    };
+  }
+  parseJson(input) {
+    return typeof input === "string" ? JSON.parse(input) : input;
+  }
+  validateDocument(doc) {
+    const result = validatePresentationDocument(doc);
+    return {
+      valid: result.valid,
+      ...result.errors.length > 0 && { errors: result.errors }
+    };
+  }
+  generateSchema(_options) {
+    return null;
+  }
+  getBuiltinThemes() {
+    try {
+      const core = __require("@json-to-office/core-pptx");
+      return core.pptxThemes || {};
+    } catch {
+      return {};
+    }
+  }
+  async resolveTheme(options) {
+    const core = await import("@json-to-office/core-pptx");
+    const themes = core.pptxThemes || {};
+    const { requested } = await this.resolveThemes(options);
+    return requested ?? themes.minimal ?? {};
+  }
+  /**
+   * Resolve `theme`/`themePath` once for a whole run: `themePath` is read a
+   * single time and feeds both the requested theme and the custom-theme
+   * registry, so a bad path warns once instead of once per consumer.
+   */
+  async resolveThemes(options) {
+    const core = await import("@json-to-office/core-pptx");
+    const themes = core.pptxThemes || {};
+    const registry = { ...options.customThemes };
+    if (typeof options.theme === "object" && options.theme !== null) {
+      registry[safeThemeKey(options.theme.name)] = options.theme;
+    }
+    let fileTheme;
+    if (options.themePath) {
+      try {
+        if (options.themePath.endsWith(".json")) {
+          const content = fs5.readFileSync(
+            path5.resolve(process.cwd(), options.themePath),
+            "utf-8"
+          );
+          fileTheme = JSON.parse(content);
+        } else {
+          const themePath = path5.resolve(process.cwd(), options.themePath);
+          const themeModule = await import(themePath);
+          fileTheme = themeModule.default || themeModule.theme;
+        }
+      } catch (error) {
+        emitDiagnostic(
+          `Failed to load theme from ${options.themePath}: ${error.message}`,
+          "warning"
+        );
+      }
+      if (fileTheme) {
+        registry[safeThemeKey(fileTheme.name)] = fileTheme;
+      }
+    }
+    const customThemes = Object.keys(registry).length > 0 ? registry : void 0;
+    if (fileTheme) {
+      return { requested: fileTheme, customThemes, label: options.themePath };
+    }
+    if (typeof options.theme === "string") {
+      const named = options.customThemes?.[options.theme] ?? themes[options.theme];
+      if (named)
+        return { requested: named, customThemes, label: options.theme };
+      if (options.theme.endsWith(".json") && fs5.existsSync(options.theme)) {
+        try {
+          const content = fs5.readFileSync(
+            path5.resolve(process.cwd(), options.theme),
+            "utf-8"
+          );
+          return {
+            requested: JSON.parse(content),
+            customThemes,
+            label: options.theme
+          };
+        } catch {
+        }
+      }
+      emitDiagnostic(
+        `Unknown theme "${options.theme}"; keeping the document's own theme`,
+        "warning"
+      );
+    }
+    if (typeof options.theme === "object" && options.theme !== null) {
+      return {
+        requested: options.theme,
+        customThemes,
+        label: safeThemeKey(options.theme.name)
+      };
+    }
+    return { requested: void 0, customThemes, label: void 0 };
+  }
+  async loadCustomThemes(options) {
+    return (await this.resolveThemes(options)).customThemes;
+  }
+};
+function createAdapter(format) {
+  switch (format) {
+    case "docx":
+      return new DocxFormatAdapter();
+    case "pptx":
+      return new PptxFormatAdapter();
+    default:
+      throw new Error(`Unknown format: ${format}`);
+  }
+}
+export {
+  DocxFormatAdapter,
+  FontconfigStager,
+  MacOSCoreTextStager,
+  NoopFontStager,
+  PptxFormatAdapter,
+  WindowsFontStager,
+  clearRasterizerCache,
+  createAdapter,
+  createLibreOfficePptxBatchRasterizer,
+  createLibreOfficePptxRasterizer,
+  emitDiagnostic,
+  getFontStager,
+  getRasterizerCacheStats,
+  runWithDiagnosticSink,
+  stderrDiagnosticSink
+};
+//# sourceMappingURL=index.js.map