@openpresentation/opf 0.16.0 → 0.18.1

package/dist/chunk-KXBZ6ZSB.js

@@ -0,0 +1,991 @@
+import { OPFApiError, parseSlideSelection, OPFExportError, asApiError, OPFImportError } from './chunk-QLFWWHRF.js';
+import { defaultCatalog } from './chunk-WCG3THTD.js';
+import { deckFormatOf, readDeckReport, stringify } from './chunk-ZOHFLP3O.js';
+import { paginate } from './chunk-64YSJZDH.js';
+import { validate, OPFValidationError } from './chunk-JT3QXA22.js';
+import { stat, readdir, lstat, mkdir, writeFile, rename, unlink, readFile } from 'fs/promises';
+import path6 from 'path';
+import { readFileSync, realpathSync, statSync } from 'fs';
+import { pathToFileURL, fileURLToPath } from 'url';
+import { createRequire } from 'module';
+import { randomUUID } from 'crypto';
+import { crc32 } from 'zlib';
+
+// src/node/catalogs.ts
+var DEFAULT_CATALOGS = [defaultCatalog];
+var MEDIA = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp", ".svg": "image/svg+xml" };
+var MAX_BYTES = 32 * 1024 * 1024;
+var startsWith = (bytes, signature, offset = 0) => signature.every((value, index) => bytes[offset + index] === value);
+function looksLike(type, bytes) {
+  switch (type) {
+    case "image/png":
+      return startsWith(bytes, [137, 80, 78, 71]);
+    case "image/jpeg":
+      return startsWith(bytes, [255, 216, 255]);
+    case "image/gif":
+      return startsWith(bytes, [71, 73, 70, 56]);
+    case "image/webp":
+      return startsWith(bytes, [82, 73, 70, 70]) && startsWith(bytes, [87, 69, 66, 80], 8);
+    default:
+      return /<svg[\s>]/i.test(new TextDecoder().decode(bytes.subarray(0, 4096)));
+  }
+}
+var AssetError = class extends Error {
+  constructor(message, details) {
+    super(message);
+    this.details = details;
+  }
+  details;
+  code = "asset-unresolved";
+};
+function createImageResolver(root, reporter, passDirectory = "pass --asset-dir") {
+  const base = root === void 0 ? void 0 : realpathSync(root);
+  const cache2 = /* @__PURE__ */ new Map();
+  const shown = (source) => source.length > 80 ? `${source.slice(0, 77)}...` : source;
+  function load(source) {
+    if (/^[a-z][a-z0-9+.-]*:/i.test(source) && !/^file:/i.test(source) && !/^[a-z]:[\\/]/i.test(source)) return { skipped: true };
+    if (base === void 0) return { problem: "blocked", reason: "no asset directory was given, so no local file is read." };
+    let file;
+    try {
+      file = /^file:/i.test(source) ? fileURLToPath(source) : path6.resolve(base, source);
+    } catch {
+      return { problem: "blocked", reason: "the path is not valid." };
+    }
+    let real;
+    try {
+      real = realpathSync(file);
+    } catch {
+      return { problem: "missing", reason: `no such file under ${base}.` };
+    }
+    const relative = path6.relative(base, real);
+    if (relative.startsWith("..") || path6.isAbsolute(relative)) return { problem: "blocked", reason: `it is outside the asset directory ${base}.` };
+    const mediaType = MEDIA[path6.extname(real).toLowerCase()];
+    if (!mediaType) return { problem: "blocked", reason: "only .png, .jpg, .jpeg, .gif, .webp and .svg files are read." };
+    const info = statSync(real);
+    if (!info.isFile() || info.size > MAX_BYTES) return { problem: "blocked", reason: `it is not a regular file under ${MAX_BYTES / 1024 / 1024} MB.` };
+    const bytes = new Uint8Array(readFileSync(real));
+    if (!looksLike(mediaType, bytes)) return { problem: "blocked", reason: `the content is not a ${mediaType} image.` };
+    return { image: { bytes, mediaType } };
+  }
+  function read(source) {
+    let outcome = cache2.get(source);
+    if (!outcome) {
+      outcome = load(source);
+      cache2.set(source, outcome);
+    }
+    return outcome;
+  }
+  return {
+    /** opf-render: a data URI string, or null for the placeholder (a missing file is reported by the renderer as unresolved-asset). */
+    forSvg: (source, context) => {
+      if (!source) return null;
+      const outcome = read(source);
+      if ("image" in outcome) return `data:${outcome.image.mediaType};base64,${Buffer.from(outcome.image.bytes).toString("base64")}`;
+      if ("problem" in outcome && outcome.problem === "blocked") reporter.add("cli", { code: "asset-blocked", path: context.path, message: `Image "${shown(source)}" was not read: ${outcome.reason}` });
+      return null;
+    },
+    /** opf-pptx: bytes and media type; null for URLs and references it handles itself. An unreadable local file stops the export. */
+    forPptx: (source, context) => {
+      const outcome = read(source);
+      if ("image" in outcome) return { data: outcome.image.bytes, mediaType: outcome.image.mediaType };
+      if ("skipped" in outcome) return null;
+      throw new AssetError(`Image "${shown(source)}" was not read: ${outcome.reason} Fix the path, embed the image as a data URI, or ${passDirectory}.`, { path: context.path });
+    }
+  };
+}
+var RENDER_PACKAGE = "@openpresentation/opf-render";
+var PPTX_PACKAGE = "@openpresentation/opf-pptx";
+var PEER_RANGES = { [RENDER_PACKAGE]: "^0.18.0", [PPTX_PACKAGE]: "^0.18.0" };
+var RENDER_EXTRAS = {
+  /** The faces of the office pack, which the CLI and `convert` always load (every format). */
+  fonts: ["@expo-google-fonts/roboto@0.4.3", "@expo-google-fonts/roboto-mono@0.4.2", "@expo-google-fonts/caladea@0.4.2", "@expo-google-fonts/arimo@0.4.3", "@expo-google-fonts/tinos@0.4.2", "@expo-google-fonts/cousine@0.4.3", "@expo-google-fonts/gelasio@0.4.1", "@expo-google-fonts/noto-sans@0.4.2"],
+  /** PNG output (and raster fallbacks): the SVG rasterizer, and sharp for WebP and rotated JPEG pictures. */
+  png: ["@resvg/resvg-js@^2.6.2", "sharp@^0.35.5"],
+  /** PDF: vector mode (the default) needs nothing for text; raster mode needs pdf-lib; pictures in a vector PDF need sharp. */
+  pdfRaster: ["pdf-lib@^1.17.1"],
+  pdfPictures: ["sharp@^0.35.5"]
+};
+var renderHint = () => `  ${RENDER_PACKAGE} also needs its optional peers, by output:
+    every format (fonts):  npm install ${RENDER_EXTRAS.fonts.join(" ")}
+    png:                   npm install ${RENDER_EXTRAS.png.join(" ")}
+    pdf:                   npm install ${RENDER_EXTRAS.pdfRaster.join(" ")}  (raster mode), ${RENDER_EXTRAS.pdfPictures.join(" ")}  (when the deck has pictures)
+    svg:                   fonts only`;
+var hint = (name) => `${name} is not installed. It is an optional peer of @openpresentation/opf, loaded only by the file API of @openpresentation/opf in Node (convert, open) and the opf commands that need it. Install it next to the CLI or in your project:
+  npm install -g ${name}@${PEER_RANGES[name]}      (global CLI)
+  npm install ${name}@${PEER_RANGES[name]}      (project that calls convert or open of @openpresentation/opf, or depends on the CLI)
+  npx -p @openpresentation/cli -p @openpresentation/opf-render -p @openpresentation/opf-pptx opf <command> ...      (one run)` + (name === RENDER_PACKAGE ? `
+${renderHint()}` : "");
+function bases() {
+  return [import.meta.url, pathToFileURL(path6.join(process.cwd(), "noop.js")).href];
+}
+function locate(specifier) {
+  for (const base of bases()) {
+    try {
+      return createRequire(base).resolve(specifier);
+    } catch (error) {
+      const code = error.code;
+      if (code !== "MODULE_NOT_FOUND" && code !== "ERR_PACKAGE_PATH_NOT_EXPORTED") throw error;
+    }
+  }
+  return void 0;
+}
+function locatePackage(name, from) {
+  const starts = [...bases(), ...from === void 0 ? [] : [pathToFileURL(from).href]];
+  for (const base of starts) {
+    const manifest = manifestFrom(name, base);
+    if (!manifest) continue;
+    try {
+      return { manifest, version: JSON.parse(readFileSync(manifest, "utf8")).version ?? "unknown" };
+    } catch {
+      return { manifest, version: "unknown" };
+    }
+  }
+  return void 0;
+}
+function manifestFrom(name, base) {
+  const require2 = createRequire(base);
+  try {
+    return require2.resolve(`${name}/package.json`);
+  } catch {
+  }
+  let entry;
+  try {
+    entry = require2.resolve(name);
+  } catch {
+    return void 0;
+  }
+  for (let folder = path6.dirname(entry); folder !== path6.dirname(folder); folder = path6.dirname(folder)) {
+    const candidate = path6.join(folder, "package.json");
+    try {
+      if (JSON.parse(readFileSync(candidate, "utf8")).name === name) return candidate;
+    } catch {
+    }
+  }
+  return void 0;
+}
+var cache = /* @__PURE__ */ new Map();
+async function loadPeer(name, subpath = "") {
+  const key = `${name}${subpath}`;
+  const cached = cache.get(key);
+  if (cached) return cached;
+  const manifestPath = locate(`${name}/package.json`);
+  const entry = locate(`${name}${subpath}`);
+  if (!manifestPath || !entry) throw new OPFApiError(hint(name), "peer-not-installed", { details: { package: name, range: PEER_RANGES[name] } });
+  let module;
+  try {
+    module = await import(pathToFileURL(entry).href);
+  } catch (error) {
+    throw new OPFApiError(`${name} is installed at ${path6.dirname(manifestPath)} but did not load: ${error.message}`, "peer-load-failed", { details: { package: name }, cause: error });
+  }
+  const version = JSON.parse(readFileSync(manifestPath, "utf8")).version ?? "unknown";
+  const peer = { module, version, name };
+  cache.set(key, peer);
+  return peer;
+}
+function requireFeature(peer, names) {
+  const missing = names.filter((name) => typeof peer.module[name] !== "function");
+  if (missing.length)
+    throw new OPFApiError(`${peer.name}@${peer.version} does not provide ${missing.join(", ")}. Install ${peer.name}@${PEER_RANGES[peer.name]}.`, "peer-too-old", { details: { package: peer.name } });
+}
+function missingPeerFrom(error) {
+  let current = error;
+  for (let depth = 0; current && typeof current === "object" && depth < 4; depth++, current = current.cause) {
+    const details = current.details ?? {};
+    const fontPackages = current.code === "font-resource-unavailable" && (Array.isArray(details.packages) || typeof details.package === "string");
+    if (current.code !== "converter-missing" && !fontPackages) continue;
+    const kept = Object.fromEntries(["package", "packages", "range", "install", "purpose"].filter((key) => details[key] !== void 0).map((key) => [key, details[key]]));
+    return new OPFApiError(current.message ?? String(current.code), details.installed === true ? "peer-load-failed" : "peer-not-installed", { details: kept, cause: error });
+  }
+  return void 0;
+}
+async function loadRenderer() {
+  const render = await loadPeer(RENDER_PACKAGE);
+  requireFeature(render, ["toSvg", "toPng", "toPdf"]);
+  const fonts = await loadPeer(RENDER_PACKAGE, "/fonts-node");
+  requireFeature(fonts, ["loadFonts"]);
+  return { render, fonts: fonts.module };
+}
+async function loadPptx() {
+  const pptx = await loadPeer(PPTX_PACKAGE);
+  requireFeature(pptx, ["toPptx", "fromPptx", "inventoryTypefaces"]);
+  return pptx;
+}
+
+// src/node/fonts.ts
+var FONT_FILE = /\.(ttf|otf)$/i;
+async function listFontDirectories(directories, label = "--fonts") {
+  const files = [];
+  for (const directory of directories) {
+    const resolved = path6.resolve(directory);
+    let names;
+    try {
+      if (!(await stat(resolved)).isDirectory()) throw new OPFApiError(`${label} ${directory} is not a directory.`, "invalid-option");
+      names = await readdir(resolved);
+    } catch (error) {
+      if (error instanceof OPFApiError) throw error;
+      throw new OPFApiError(`Cannot read ${label} ${directory}: ${error.code ?? error.message}.`, "invalid-option");
+    }
+    const found = names.filter((name) => FONT_FILE.test(name)).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    if (!found.length) throw new OPFApiError(`${label} ${directory} contains no .ttf or .otf files.`, "invalid-option");
+    files.push(...found.map((name) => path6.join(resolved, name)));
+  }
+  return files;
+}
+async function prepareFonts(renderer, presentation, userFonts, reporter, embedScriptFonts = false) {
+  try {
+    const handle = await renderer.fonts.loadFonts({
+      pack: "office",
+      substitutionPolicy: "visual",
+      scripts: "auto",
+      embedScriptFonts,
+      presentation,
+      faces: userFonts.map((file) => ({ path: file })),
+      onDiagnostic: (diagnostic) => reporter.add("fonts", scriptDiagnostic(diagnostic))
+    });
+    return { handle, userFonts };
+  } catch (error) {
+    const missing = missingPeerFrom(error);
+    if (missing) throw missing;
+    const failure = error;
+    throw new OPFApiError(failure.message ?? String(error), failure.code ?? "font-preparation-failed", {
+      details: failure.details?.package ? { package: failure.details.package } : {},
+      cause: error
+    });
+  }
+}
+var NEUTRAL_DECK = { slides: [] };
+var shared = /* @__PURE__ */ new Map();
+async function leaseSharedFonts(renderer, presentation, userFonts, reporter, embedScriptFonts = false) {
+  const select = renderer.fonts.autoScriptSelection;
+  if (typeof select !== "function") return void 0;
+  const selection = select(presentation);
+  if (selection.detected?.length || selection.scripts?.length || selection.unavailable?.length) return void 0;
+  const key = JSON.stringify([userFonts, embedScriptFonts]);
+  let entry = shared.get(key);
+  if (!entry) {
+    const diagnostics2 = [];
+    const sink = { add: (_source, diagnostic) => void diagnostics2.push(diagnostic) };
+    const ready = prepareFonts(renderer, NEUTRAL_DECK, userFonts, sink, embedScriptFonts).then((prepared) => ({ handle: prepared.handle, diagnostics: diagnostics2 }));
+    const created = { ready, queue: Promise.resolve() };
+    entry = created;
+    shared.set(key, created);
+    ready.catch(() => {
+      if (shared.get(key) === created) shared.delete(key);
+    });
+  }
+  const { handle, diagnostics } = await entry.ready;
+  let release;
+  const previous = entry.queue;
+  entry.queue = new Promise((resolve) => {
+    release = resolve;
+  });
+  await previous;
+  const pending = handle.pending;
+  if (typeof pending === "function" && pending.call(handle, presentation).length) {
+    release();
+    return void 0;
+  }
+  handle.registry?.clearSubstitutions?.();
+  for (const diagnostic of diagnostics) reporter.add("fonts", diagnostic);
+  return { handle, release };
+}
+function scriptDiagnostic(diagnostic) {
+  if (diagnostic.code !== "script-font-not-installed") return diagnostic;
+  const name = typeof diagnostic.package === "string" ? diagnostic.package : "the Noto script package";
+  return { ...diagnostic, message: `${diagnostic.message} Install ${name} next to the CLI (npm install -g ${name}) to draw this script with a bundled open font.` };
+}
+function embeddedFor(handle, text = "fonts") {
+  return text === "fonts" ? handle.embeddedFonts.map((face) => ({ ...face, embed: "used" })) : [];
+}
+function substitutionRows(handle) {
+  const rows = /* @__PURE__ */ new Map();
+  for (const item of handle.substitutions) {
+    if (!item.substitute) continue;
+    rows.set(`${item.requestedFamily}\0${item.resolvedFamily}`, { requested: item.requestedFamily, resolved: item.resolvedFamily, compatibility: item.compatibility });
+  }
+  return [...rows.values()].sort((a, b) => a.requested + a.resolved < b.requested + b.resolved ? -1 : 1);
+}
+function stemOf(input) {
+  if (input === "-") return "deck";
+  return path6.basename(input).replace(/\.opf\.json$/i, "").replace(/\.(json|pptx|potx)$/i, "") || "deck";
+}
+function deckStem(deck, input) {
+  const root = deck && typeof deck === "object" && !Array.isArray(deck) ? deck : {};
+  const clean = (value) => value.replace(/[/:*?"<>|\p{Cc}]+/gu, "-").replace(/\s+/g, "-").replace(/-{2,}/g, "-").replace(/^[-.\s]+|[-.\s]+$/g, "");
+  const text = (value) => typeof value === "string" ? value : "";
+  const slug = (value) => value.replace(/[^\p{L}\p{N}_-]+/gu, "-").replace(/-{2,}/g, "-").replace(/^-|-$/g, "");
+  return clean(text(root.filename).trim().replace(/\.(pptx|pdf|png|svg)$/i, "")) || slug(text(root.name)) || stemOf(input);
+}
+async function checkDestinations(files, overwrite, flags = true) {
+  for (const file of files) {
+    try {
+      const stat2 = await lstat(file);
+      if (!overwrite) throw new OPFApiError(`Output already exists: ${file}. ${flags ? "Use --force." : "Pass overwrite: true (the default) to replace it."}`, "output-exists", { details: { path: file } });
+      if (!stat2.isFile()) throw new OPFApiError(`Refusing to replace a symlink or non-regular file${flags ? "" : `: ${file}`}.`, "output-not-file", { details: { path: file } });
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+}
+async function writeFiles(files, overwrite, flags = true) {
+  const unique = new Set(files.map((entry) => path6.resolve(entry.file)));
+  if (unique.size !== files.length) throw new OPFApiError("Two outputs would write the same file.", "invalid-option");
+  await checkDestinations([...unique], overwrite, flags);
+  const staged = [];
+  try {
+    for (const entry of files) {
+      const output = path6.resolve(entry.file);
+      await mkdir(path6.dirname(output), { recursive: true });
+      const temporary = path6.join(path6.dirname(output), `.${path6.basename(output)}.${randomUUID()}.tmp`);
+      await writeFile(temporary, entry.bytes, { flag: "wx" });
+      staged.push({ temporary, output });
+    }
+    for (const item of staged) {
+      await rename(item.temporary, item.output);
+      item.temporary = "";
+    }
+  } finally {
+    for (const item of staged) if (item.temporary) await unlink(item.temporary).catch(() => void 0);
+  }
+}
+function pointerOf(location) {
+  if (location === "" || location.startsWith("/")) return location;
+  return /^[A-Za-z_$][\w$-]*(\.[\w$-]+)*$/.test(location) ? `/${location.split(".").join("/")}` : location;
+}
+
+// src/node/reporter.ts
+var rank = { error: 3, warning: 2, info: 1 };
+var reaches = (findings, level) => findings.some((finding) => rank[finding.severity] >= rank[level]);
+var INFO = /* @__PURE__ */ new Set([
+  "font-glyph-fallback",
+  "font-substituted",
+  "pdf-font-embedded",
+  "pdf-font-fallback",
+  "svg-image-rasterized",
+  "svg-sanitized",
+  "script-font-unavailable",
+  "media-provenance-omitted"
+]);
+var HELP = {
+  "text-overflow": "Shorten the text, or split the slide: add --paginate (measured with the same fonts) or run opf paginate.",
+  "small-cell": "Give the table more room or fewer columns, or run opf paginate.",
+  "unresolved-asset": "Embed the image as a data URI, or keep the file inside the deck folder (see --asset-dir). URLs are never fetched.",
+  "asset-blocked": "Move the file under the deck folder or pass --asset-dir <directory> that contains it.",
+  "script-font-not-installed": "Install the Noto script package named in the message next to the CLI, then run the command again.",
+  "font-glyph-fallback": "The chosen font lacks these characters; a bundled font draws them. Supply a font with --fonts to change that.",
+  "unresolved-reference": "Use an id from opf catalog <kind>, define the record in catalogs.custom, or run opf embed to embed what the deck references.",
+  "unresolved-content": "Check the content at this path; it could not be drawn.",
+  "chart-data-adapted": "The chart data was reshaped to export a native chart; see the message.",
+  "chart-data-unplottable": "Provide inline chart data with at least one numeric column.",
+  "content-placeholder": "This content has no PowerPoint form; a placeholder frame stands in for it.",
+  "unsupported-image-treatment": "Remove or change the image treatment at this path.",
+  "date-needs-value": "Pass --date YYYY-MM-DD. The CLI never reads a clock, so output stays reproducible.",
+  "font-unavailable": "Pass --fonts with the font files, or choose a font the bundled pack covers (opf catalog fontSchemes).",
+  "missing-glyph": "Install the script font package named by script-font-not-installed, or supply a covering font with --fonts.",
+  "duplicate-font-face": "A --fonts face repeats a bundled family, weight and style; remove it or rename the family."
+};
+var Reporter = class {
+  findings = [];
+  seen = /* @__PURE__ */ new Set();
+  constructor(initial = []) {
+    for (const item of initial) this.findings.push(item);
+  }
+  /** Add a library diagnostic (`code`, `path`, `message` and details). Identical entries are kept once. */
+  add(source, diagnostic, severity) {
+    const { code, path: where, message, ...details } = diagnostic;
+    const entry = {
+      ruleId: `${source}/${code}`,
+      severity: severity ?? (INFO.has(code) ? "info" : "warning"),
+      category: source,
+      path: pointerOf(where ?? ""),
+      scope: "document",
+      message,
+      help: HELP[code] ?? "",
+      ...Object.fromEntries(Object.entries(details).filter(([, value]) => value !== void 0))
+    };
+    const key = JSON.stringify([entry.ruleId, entry.path, entry.message]);
+    if (this.seen.has(key)) return;
+    this.seen.add(key);
+    this.findings.push(entry);
+  }
+  /** Add a finding as the library made it (the `findings` of a thrown OPFRenderError, OPFPptxError or core validation error). Identical entries are kept once. */
+  addFinding(finding) {
+    const key = JSON.stringify([finding.ruleId, finding.path, finding.message]);
+    if (this.seen.has(key)) return;
+    this.seen.add(key);
+    this.findings.push(finding);
+  }
+  error(source, code, message, where = "", details = {}) {
+    this.add(source, { code, path: where, message, ...details }, "error");
+  }
+  get counts() {
+    const counts = { error: 0, warning: 0, info: 0 };
+    for (const item of this.findings) counts[item.severity] += 1;
+    return counts;
+  }
+  get failed() {
+    return this.counts.error > 0;
+  }
+};
+function reportThrown(reporter, source, error) {
+  const failure = error;
+  const thrown = Array.isArray(failure.findings) ? failure.findings.filter((item) => typeof item?.ruleId === "string" && typeof item.message === "string") : [];
+  if (thrown.some((item) => item.severity === "error")) {
+    for (const item of thrown) reporter.addFinding(item);
+    return;
+  }
+  const code = typeof failure.code === "string" ? failure.code : "failed";
+  const details = failure.details ?? {};
+  const where = typeof details.path === "string" ? details.path : typeof failure.path === "string" ? failure.path : "";
+  const extra = {};
+  for (const key of ["fontFamily", "character", "family", "package", "script"]) if (details[key] !== void 0) extra[key] = details[key];
+  reporter.error(source, code, failure.message ?? String(error), where, extra);
+}
+function finishReport(base, reporter, failOn) {
+  const counts = reporter.counts;
+  const ok = base.valid && counts.error === 0 && !reaches(reporter.findings, failOn);
+  return { ok, valid: base.valid && counts.error === 0, schemaValid: base.schemaValid, findings: reporter.findings, counts, checks: base.checks };
+}
+var DOS_TIME = 0;
+var DOS_DATE = 1980 - 1980 << 9 | 1 << 5 | 1;
+function createZip(entries) {
+  const encoder = new TextEncoder();
+  const chunks = [];
+  const central = [];
+  let offset = 0;
+  for (const entry of [...entries].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
+    const name = encoder.encode(entry.name);
+    const crc = crc32(entry.bytes);
+    if (entry.bytes.length > 4294967294 || offset > 4294967294 || entries.length > 65534) throw new RangeError("The archive is too large for a plain ZIP file.");
+    const local = new DataView(new ArrayBuffer(30));
+    local.setUint32(0, 67324752, true);
+    local.setUint16(4, 20, true);
+    local.setUint16(6, 2048, true);
+    local.setUint16(8, 0, true);
+    local.setUint16(10, DOS_TIME, true);
+    local.setUint16(12, DOS_DATE, true);
+    local.setUint32(14, crc, true);
+    local.setUint32(18, entry.bytes.length, true);
+    local.setUint32(22, entry.bytes.length, true);
+    local.setUint16(26, name.length, true);
+    local.setUint16(28, 0, true);
+    const header = new DataView(new ArrayBuffer(46));
+    header.setUint32(0, 33639248, true);
+    header.setUint16(4, 20, true);
+    header.setUint16(6, 20, true);
+    header.setUint16(8, 2048, true);
+    header.setUint16(10, 0, true);
+    header.setUint16(12, DOS_TIME, true);
+    header.setUint16(14, DOS_DATE, true);
+    header.setUint32(16, crc, true);
+    header.setUint32(20, entry.bytes.length, true);
+    header.setUint32(24, entry.bytes.length, true);
+    header.setUint16(28, name.length, true);
+    header.setUint32(42, offset, true);
+    chunks.push(new Uint8Array(local.buffer), name, entry.bytes);
+    central.push(new Uint8Array(header.buffer), name);
+    offset += 30 + name.length + entry.bytes.length;
+  }
+  const size = central.reduce((total, chunk) => total + chunk.length, 0);
+  const end = new DataView(new ArrayBuffer(22));
+  end.setUint32(0, 101010256, true);
+  end.setUint16(8, entries.length, true);
+  end.setUint16(10, entries.length, true);
+  end.setUint32(12, size, true);
+  end.setUint32(16, offset, true);
+  return Buffer.concat([...chunks, ...central, new Uint8Array(end.buffer)]);
+}
+
+// src/node/export.ts
+var EXPORT_FORMATS = ["svg", "png", "pdf", "pptx"];
+var EXPORT_TEXT = ["fonts", "system", "paths"];
+var NO_FONTS = { fontFiles: [], useBundledFonts: false, loadSystemFonts: false };
+var invalid = (message) => new OPFApiError(message, "invalid-option");
+var oneOf = (name, value, allowed) => {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !allowed.includes(value)) throw invalid(`${name} must be one of: ${allowed.join(", ")}.`);
+  return value;
+};
+function checkDate(value, label = "date") {
+  if (value === void 0) return void 0;
+  const text = String(value);
+  const parsed = /^\d{4}-\d{2}-\d{2}$/.test(text) ? /* @__PURE__ */ new Date(`${text}T00:00:00Z`) : void 0;
+  if (!parsed || Number.isNaN(parsed.getTime()) || parsed.toISOString().slice(0, 10) !== text) throw invalid(`${label} must be a real calendar date, YYYY-MM-DD.`);
+  return text;
+}
+function checkScale(value, label = "scale") {
+  if (value === void 0) return 1;
+  const scale = Number(value);
+  if (typeof value === "boolean" || !Number.isFinite(scale) || scale < 0.1 || scale > 8) throw invalid(`${label} must be a number from 0.1 to 8 (1 draws the 1280 x 720 reference slide at 1280 x 720 pixels).`);
+  return scale;
+}
+var RENAMED = {
+  svgFonts: 'text ("fonts", "system" or "paths")',
+  pdfMode: "raster (true for a picture PDF)",
+  chartex: 'charts ("auto", "native" or "picture")',
+  imageFormat: "images",
+  fontDirs: "fonts (a folder or a list of folders)",
+  filename: "name"
+};
+function checkRenamedOptions(options) {
+  for (const [old, replacement] of Object.entries(RENAMED)) if (old in options) throw invalid(`${old} was renamed ${replacement} in 0.18.`);
+}
+var isHandle = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+function resolveExportOptions(options) {
+  if (!options || typeof options !== "object") throw invalid("An export needs options with a format: svg, png, pdf or pptx.");
+  checkRenamedOptions(options);
+  const format = oneOf("format", options.format, EXPORT_FORMATS);
+  if (!format) throw invalid("An export needs options.format: svg, png, pdf or pptx.");
+  if (options.raster !== void 0 && typeof options.raster !== "boolean") throw invalid("raster must be true or false.");
+  const charts = oneOf("charts", options.charts, ["auto", "native", "picture"]);
+  const provenance = oneOf("provenance", options.provenance, ["full", "references-only", "none"]);
+  const images = oneOf("images", options.images, ["compatible", "preserve"]);
+  const text = oneOf("text", options.text, EXPORT_TEXT);
+  if (options.raster && format !== "pdf") throw invalid("raster applies to format pdf.");
+  if ((charts !== void 0 || provenance !== void 0 || images !== void 0) && format !== "pptx") throw invalid("charts, provenance and images apply to format pptx.");
+  if (options.scale !== void 0 && format !== "png" && format !== "pdf") throw invalid("scale applies to format png (and raster pdf).");
+  if (options.includeHidden && format === "pptx") throw invalid("includeHidden applies to per-slide image and PDF output; the PPTX keeps a hidden slide as a hidden slide.");
+  if (options.slides !== void 0 && format === "pptx") throw invalid("slides is not available for pptx: the whole presentation is exported.");
+  if (text !== void 0 && format !== "svg") throw invalid("text applies to format svg.");
+  if (options.zip && format !== "svg" && format !== "png") throw invalid("zip applies to format svg and png.");
+  if (options.slides !== void 0 && typeof options.slides !== "string" && !(typeof options.slides === "number" && Number.isInteger(options.slides) && options.slides >= 1) && !(Array.isArray(options.slides) && options.slides.every((n) => Number.isInteger(n) && n >= 1))) throw invalid('slides must be a slide number, an array of slide numbers counted from 1, or a selection such as "1,3-5".');
+  const scale = checkScale(options.scale);
+  checkDate(options.date);
+  const { fonts, ...rest } = options;
+  if (fonts !== void 0 && typeof fonts !== "string" && !isHandle(fonts) && !(Array.isArray(fonts) && fonts.every((folder) => typeof folder === "string"))) throw invalid("fonts must be a fonts handle (loadFonts() of @openpresentation/opf-render/fonts-node), a folder of font files or a list of folders.");
+  const folders = typeof fonts === "string" ? [fonts] : Array.isArray(fonts) ? [...fonts] : [];
+  return { ...rest, format, text: text ?? "fonts", scale, ...isHandle(fonts) ? { fonts } : {}, fontFolders: folders };
+}
+function assetRoot(directory, flags = false) {
+  if (directory === void 0) return void 0;
+  const resolved = path6.resolve(directory);
+  try {
+    if (!statSync(resolved).isDirectory()) throw new Error("not a directory");
+  } catch (error) {
+    throw invalid(`${flags ? "--asset-dir" : "assetDir"} ${directory} is not a readable directory (${error.code ?? error.message}).`);
+  }
+  return resolved;
+}
+var svgSize = (svg) => {
+  const tag = /<svg\b[^>]*>/.exec(svg)?.[0] ?? "";
+  const width = Number(/\bwidth="([\d.]+)"/.exec(tag)?.[1]);
+  const height = Number(/\bheight="([\d.]+)"/.exec(tag)?.[1]);
+  return Number.isFinite(width) && Number.isFinite(height) ? { width, height } : {};
+};
+var pngSize = (bytes) => bytes.length > 24 ? { width: new DataView(bytes.buffer, bytes.byteOffset).getUint32(16), height: new DataView(bytes.buffer, bytes.byteOffset).getUint32(20) } : {};
+var MEDIA2 = { svg: "image/svg+xml", png: "image/png", pdf: "application/pdf", pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation", zip: "application/zip" };
+async function runExport(presentation, options, ctx) {
+  const { format, scale } = options;
+  const reporter = ctx.reporter;
+  const catalogs = options.catalogs ?? DEFAULT_CATALOGS;
+  const date = checkDate(options.date);
+  const renderer = ctx.renderer ?? await loadRenderer();
+  const pptx = format === "pptx" ? ctx.pptx ?? await loadPptx() : void 0;
+  const userFonts = options.fonts ? [] : ctx.userFonts ?? await listFontDirectories(options.fontFolders, ctx.flags ? "--fonts" : "fonts");
+  const resolver = createImageResolver(assetRoot(options.assetDir, ctx.flags), reporter, ctx.flags ? "pass --asset-dir" : "pass assetDir");
+  const embedScripts = format === "svg" && options.text === "fonts";
+  const lease = options.fonts ? void 0 : await leaseSharedFonts(renderer, presentation, userFonts, reporter, embedScripts);
+  try {
+    const handle = options.fonts ?? lease?.handle ?? (await prepareFonts(renderer, presentation, userFonts, reporter, embedScripts)).handle;
+    return await drawWith(presentation, handle, options, ctx, { reporter, catalogs, date, renderer, ...pptx ? { pptx } : {}, userFonts, resolver });
+  } finally {
+    lease?.release();
+  }
+}
+async function drawWith(presentation, handle, options, ctx, environment) {
+  const { format, scale } = options;
+  const { reporter, catalogs, date, renderer, pptx, userFonts, resolver } = environment;
+  let deck = presentation;
+  const fontSummary = () => ({
+    pack: "office",
+    substitutionPolicy: "visual",
+    userFonts,
+    substitutions: substitutionRows(handle),
+    ...handle.registry?.scriptSelection ? { scripts: handle.registry.scriptSelection } : {}
+  });
+  let pagination;
+  if (options.paginate) {
+    try {
+      const result = paginate(deck, { fonts: handle, catalogs });
+      deck = result.presentation;
+      pagination = { pages: result.pages };
+    } catch (error) {
+      reportThrown(reporter, "render", error);
+      return { files: [], fonts: fontSummary(), skippedHidden: [], failure: failureOf(error) };
+    }
+  }
+  const slideCount = deck.slides?.length ?? 0;
+  const isHidden = (number) => deck.slides?.[number - 1]?.hidden === true;
+  const everySlide = Array.from({ length: slideCount }, (_, index) => index + 1);
+  const slidesLabel = ctx.flags ? "--slides" : "slides";
+  const named = options.slides === void 0 ? void 0 : parseSlideSelection(options.slides, slideCount, slidesLabel);
+  const selected = format === "pptx" ? [] : named ?? (options.includeHidden ? everySlide : everySlide.filter((number) => !isHidden(number)));
+  const skippedHidden = format === "pptx" || named || options.includeHidden ? [] : everySlide.filter(isHidden);
+  if (format !== "pptx" && !selected.length)
+    throw new OPFApiError(skippedHidden.length ? ctx.flags ? "Every slide is hidden. Use --include-hidden to write them, or --slides to name slides." : "Every slide is hidden. Use includeHidden to write them, or slides to name slides." : "The presentation has no slides.", skippedHidden.length ? "all-slides-hidden" : "no-slides");
+  const stem = deckStem(options.name === void 0 ? deck : { filename: options.name }, "-");
+  const run = (extra) => ({ fonts: fontSummary(), ...pagination ? { pagination } : {}, skippedHidden, ...extra });
+  try {
+    if (format === "pptx") {
+      const module = pptx.module;
+      const bytes = await module.toPptx(deck, {
+        fonts: handle,
+        imageResolver: resolver.forPptx,
+        // The PNG fallback of an SVG picture is drawn by the same renderer the preview uses, with the same fonts handle,
+        // so SVG pictures export whichever way opf-pptx would find opf-render. A picture without text needs no faces.
+        svgRasterizer: async (svg, size) => new Uint8Array(await renderer.render.module.toPng(svg, { scale: size.scale, background: "rgba(0, 0, 0, 0)", fonts: size.text ? handle : NO_FONTS })),
+        onDiagnostic: (diagnostic) => reporter.add("pptx", diagnostic),
+        catalogs,
+        // opf-pptx still names its option `chartex` and its picture choice `fallback`.
+        ...options.charts ? { chartex: options.charts === "picture" ? "fallback" : options.charts } : {},
+        ...options.provenance ? { provenance: options.provenance === "none" ? false : options.provenance } : {},
+        ...options.images ? { imageFormat: options.images } : {},
+        ...date ? { date } : {}
+      });
+      return run({ files: [{ name: `${stem}.pptx`, type: MEDIA2.pptx, bytes }], skippedHidden: [] });
+    }
+    const embedded = format === "svg" ? embeddedFor(handle, options.text) : [];
+    const svgOptions = {
+      fonts: options.text === "paths" && format === "svg" ? handle : { textMeasurement: handle.textMeasurement, embeddedFonts: embedded },
+      ...format === "svg" && options.text !== "fonts" ? { text: options.text } : {},
+      imageResolver: resolver.forSvg,
+      onDiagnostic: (diagnostic) => reporter.add("render", diagnostic),
+      catalogs,
+      ...date ? { date } : {}
+    };
+    const svgs = [];
+    for (const number of selected) {
+      const svg = renderer.render.module.toSvg(deck, number, svgOptions);
+      svgs.push({ slide: number, id: deck.slides[number - 1]?.id, svg });
+    }
+    const width = Math.max(3, String(slideCount).length);
+    const name = (slide, extension) => `${stem}-${String(slide).padStart(width, "0")}.${extension}`;
+    if (format === "pdf") {
+      const mode = options.raster ? "raster" : "vector";
+      const title = typeof deck.name === "string" ? deck.name : void 0;
+      const bytes = await renderer.render.module.toPdf(
+        svgs.map((item) => item.svg),
+        { fonts: handle, scale, ...options.raster ? { raster: true } : {}, ...mode === "vector" && title ? { metadata: { title } } : {}, onDiagnostic: (diagnostic) => reporter.add("pdf", diagnostic) }
+      );
+      return run({ files: [{ name: `${stem}.pdf`, type: MEDIA2.pdf, bytes, pages: svgs.length, slides: selected }], pdf: { mode } });
+    }
+    const items = [];
+    for (const item of svgs) {
+      if (format === "svg") {
+        const bytes = new TextEncoder().encode(item.svg);
+        items.push({ name: name(item.slide, "svg"), type: MEDIA2.svg, bytes, slide: item.slide, ...item.id === void 0 ? {} : { id: item.id }, ...svgSize(item.svg) });
+      } else {
+        const bytes = await renderer.render.module.toPng(item.svg, { fonts: handle, scale });
+        items.push({ name: name(item.slide, "png"), type: MEDIA2.png, bytes, slide: item.slide, ...item.id === void 0 ? {} : { id: item.id }, ...pngSize(bytes) });
+      }
+    }
+    if (options.zip) {
+      const bytes = createZip(items.map((item) => ({ name: item.name, bytes: item.bytes })));
+      return run({ files: [{ name: `${stem}.zip`, type: MEDIA2.zip, bytes, entries: items.map((item) => item.name) }] });
+    }
+    return run({ files: items });
+  } catch (error) {
+    if (error instanceof OPFApiError) throw error;
+    const missing = missingPeerFrom(error);
+    if (missing) throw missing;
+    reportThrown(reporter, format === "pptx" ? "pptx" : "render", error);
+    return { files: [], fonts: fontSummary(), ...pagination ? { pagination } : {}, skippedHidden: [], failure: failureOf(error) };
+  }
+}
+var failureOf = (error) => {
+  const failure = error;
+  return { code: typeof failure?.code === "string" ? failure.code : "failed", message: failure?.message ?? String(error) };
+};
+var VERSIONS = (renderer, pptx) => ({
+  renderer: { package: RENDER_PACKAGE, version: renderer.render.version },
+  ...pptx ? { pptx: { package: PPTX_PACKAGE, version: pptx.version } } : {}
+});
+
+// src/node/pptx-import.ts
+async function runImport(bytes, options, reporter, loaded) {
+  const pptx = loaded ?? await loadPptx();
+  try {
+    const onDiagnostic = (diagnostic) => reporter.add("import", diagnostic);
+    if (options.signals) {
+      const result = await pptx.module.fromPptx(bytes, { onDiagnostic, signals: true });
+      return { presentation: result.presentation, signals: result.signals, pptx };
+    }
+    return { presentation: await pptx.module.fromPptx(bytes, { onDiagnostic }), pptx };
+  } catch (error) {
+    reportThrown(reporter, "import", error);
+    const failure = error;
+    return { pptx, failure: { code: typeof failure?.code === "string" ? failure.code : "failed", message: failure?.message ?? String(error) } };
+  }
+}
+
+// src/node/pipeline.ts
+var checkOptions = (catalogs) => ({ only: ["format", "references"], catalogs: catalogs ?? DEFAULT_CATALOGS });
+var firstError = (findings) => {
+  const first = findings.find((found) => found.severity === "error");
+  return first ? `${first.message} [${first.ruleId}]` : "see findings.";
+};
+async function prepareExport(options, flags = false) {
+  const resolved = resolveExportOptions(options);
+  const renderer = await loadRenderer();
+  const pptx = resolved.format === "pptx" ? await loadPptx() : void 0;
+  const userFonts = resolved.fonts ? [] : await listFontDirectories(resolved.fontFolders, flags ? "--fonts" : "fonts");
+  return { options: resolved, renderer, ...pptx ? { pptx } : {}, userFonts, flags };
+}
+async function runPreparedExport(prepared, presentation, checked) {
+  let initial = checked;
+  if (!initial) {
+    const check = validate(presentation, checkOptions(prepared.options.catalogs));
+    if (!check.valid) throw new OPFApiError(`The presentation is not valid OPF: ${firstError(check.findings)}`, "invalid-presentation", { findings: check.findings });
+    initial = check.findings;
+  }
+  const reporter = new Reporter(initial);
+  const { renderer, pptx, userFonts } = prepared;
+  const run = await runExport(presentation, prepared.options, { reporter, renderer, ...pptx ? { pptx } : {}, userFonts, flags: prepared.flags });
+  if (run.failure) throw new OPFApiError(run.failure.message, "export-failed", { details: { reason: run.failure.code }, findings: reporter.findings });
+  return {
+    files: run.files,
+    findings: reporter.findings,
+    fonts: run.fonts,
+    skippedHidden: run.skippedHidden,
+    ...run.pagination ? { pagination: run.pagination } : {},
+    ...run.pdf ? { pdf: run.pdf } : {},
+    ...VERSIONS(renderer, pptx)
+  };
+}
+async function importPresentation(bytes, options, loaded) {
+  const pptx = loaded ?? await loadPptx();
+  const reporter = new Reporter();
+  const run = await runImport(bytes, { signals: options.signals === true }, reporter, pptx);
+  if (run.failure || !run.presentation) throw new OPFApiError(run.failure?.message ?? "The file could not be read.", "import-failed", { details: { reason: run.failure?.code }, findings: reporter.findings });
+  const check = validate(run.presentation, checkOptions(options.catalogs));
+  for (const found of check.findings) reporter.addFinding(found);
+  if (!check.valid) throw new OPFApiError(`The imported presentation is not valid OPF: ${firstError(check.findings)}`, "invalid-presentation", { findings: reporter.findings });
+  return { result: { presentation: run.presentation, findings: reporter.findings, ...run.signals ? { signals: run.signals } : {}, pptx: { package: PPTX_PACKAGE, version: pptx.version } }, check };
+}
+
+// src/node/conversion.ts
+var EXPORT_EXTENSIONS = { ".pdf": "pdf", ".pptx": "pptx", ".png": "png", ".svg": "svg" };
+var FORMATS = ["pdf", "pptx", "png", "svg", "json", "yaml", "markdown"];
+var DECK_MEDIA = { json: "application/json", yaml: "application/yaml", markdown: "text/markdown" };
+var ZIP_MEDIA = "application/zip";
+var INPUTS = ".pptx, .opf.md, .yaml, .yml or .json";
+var OUTPUTS = ".pdf, .pptx, .png, .svg, .zip, .opf.md, .yaml, .yml or .json";
+var DECKS = ".opf.md, .yaml, .yml or .json";
+var invalid2 = (message, details) => new OPFApiError(message, "invalid-option", details ? { details } : {});
+function deckFileFormat(file) {
+  const format = deckFormatOf(file);
+  return format !== "json" ? format : /\.json$/i.test(file) ? "json" : void 0;
+}
+function exportFormatOf(file) {
+  return EXPORT_EXTENSIONS[path6.extname(file).toLowerCase()];
+}
+function fileStem(file) {
+  return path6.basename(file).replace(/\.opf\.(md|json|ya?ml)$/i, "").replace(/\.(json|ya?ml|pptx)$/i, "") || "deck";
+}
+function sourceOf(input, flags) {
+  if (typeof input === "string") {
+    if (/\.pptx$/i.test(input)) return { kind: "pptx" };
+    const format = deckFileFormat(input);
+    if (format) return { kind: "deck", format };
+    throw invalid2(`${flags ? "opf convert" : "convert"} reads ${INPUTS} files; ${input} is none of them.`, { path: input });
+  }
+  if (input instanceof Uint8Array) return { kind: "pptx", bytes: input };
+  if (input instanceof ArrayBuffer) return { kind: "pptx", bytes: new Uint8Array(input) };
+  if (input && typeof input === "object" && !Array.isArray(input)) return { kind: "presentation" };
+  throw invalid2("convert takes a file path, a presentation object or the bytes of a .pptx file.");
+}
+function targetOf(output, options, flags) {
+  const format = options.format;
+  const formatLabel = flags ? "--format" : "format";
+  if (format !== void 0 && !FORMATS.includes(format)) throw invalid2(`${formatLabel} must be one of: ${FORMATS.join(", ")}.`);
+  if (output === void 0) {
+    if (format === void 0) throw invalid2(`convert without an output path needs ${formatLabel}: ${FORMATS.join(", ")}.`);
+    if (options.zip && format !== "png" && format !== "svg") throw invalid2("zip applies to format png and svg.");
+    return format === "json" || format === "yaml" || format === "markdown" ? { kind: "deck", format } : { kind: "export", format, zip: options.zip === true };
+  }
+  if (typeof output !== "string" || !output) throw invalid2(`${flags ? "opf convert" : "convert"} needs an output file path ending ${OUTPUTS}.`);
+  if (options.zip) throw invalid2(`${flags ? "--zip" : "zip"} is for output without a path; a .zip output path makes the archive.`);
+  if (options.name !== void 0) throw invalid2(`${flags ? "--name" : "name"} is for output without a path; the output path names the file.`);
+  if (path6.extname(output).toLowerCase() === ".zip") {
+    if (format !== void 0 && format !== "png" && format !== "svg") throw invalid2(`A .zip output holds png or svg slides; ${formatLabel} ${format} is neither.`);
+    return { kind: "export", format: format ?? "png", zip: true };
+  }
+  const exported = exportFormatOf(output);
+  const deck = exported ? void 0 : deckFileFormat(output);
+  const named = exported ?? deck;
+  if (!named) throw invalid2(`${flags ? "opf convert" : "convert"} writes ${OUTPUTS} files; ${output} is none of them.`, { path: output });
+  if (format !== void 0 && format !== named) throw invalid2(`${formatLabel} ${format} does not match the output ${output}, which is ${named}.`);
+  return exported ? { kind: "export", format: exported, zip: false } : { kind: "deck", format: deck };
+}
+var EXPORT_ONLY = ["slides", "includeHidden", "paginate", "scale", "raster", "text", "charts", "provenance", "images", "date", "fonts", "assetDir"];
+var given = (value) => value !== void 0 && value !== false && !(Array.isArray(value) && value.length === 0);
+function checkApplicable(source, target, options, flags) {
+  const name = (key) => flags ? `--${key.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)}` : key;
+  const names = (...keys) => keys.map(name).join(", ").replace(/, ([^,]*)$/, " and $1");
+  if (given(options.signals) && source.kind !== "pptx") throw invalid2(`${name("signals")} applies to a .pptx input.`);
+  if (target.kind === "deck") {
+    const extra = EXPORT_ONLY.filter((key) => given(options[key]));
+    if (extra.length) throw invalid2(`${names(...extra)} ${extra.length === 1 ? "applies" : "apply"} to export outputs (pdf, pptx, png, svg), not to a deck written as ${target.format}.`);
+    return;
+  }
+  const format = target.format;
+  if (given(options.raster) && format !== "pdf") throw invalid2(`${name("raster")} applies to pdf output.`);
+  if ((options.charts !== void 0 || options.provenance !== void 0 || options.images !== void 0) && format !== "pptx") throw invalid2(`${names("charts", "provenance", "images")} apply to pptx output.`);
+  if (options.scale !== void 0 && format !== "png" && format !== "pdf") throw invalid2(`${name("scale")} applies to png output (and raster pdf).`);
+  if (given(options.includeHidden) && format === "pptx") throw invalid2(`${name("includeHidden")} applies to per-slide image and PDF output; the PPTX keeps a hidden slide as a hidden slide.`);
+  if (options.slides !== void 0 && format === "pptx") throw invalid2(`${name("slides")} is not available for pptx output: the whole presentation is exported.`);
+  if (options.text !== void 0 && format !== "svg") throw invalid2(`${name("text")} applies to svg output.`);
+  checkScale(options.scale, name("scale"));
+  checkDate(options.date, name("date"));
+}
+async function readInput(file) {
+  try {
+    return new Uint8Array(await readFile(file));
+  } catch (error) {
+    const reason = error.code ?? error.message;
+    const missing = reason === "ENOENT" || reason === "ENOTDIR";
+    throw new OPFApiError(`Cannot read ${file}: ${missing ? "no such file" : reason}.`, missing ? "input-not-found" : "input-unreadable", { details: { path: file, reason }, cause: error });
+  }
+}
+var inStep = async (Class, fallback, step) => {
+  try {
+    return await step();
+  } catch (error) {
+    throw asApiError(Class, error, fallback);
+  }
+};
+function deckText(presentation, format, schemaComment = false) {
+  try {
+    return stringify(presentation, { format, schemaComment });
+  } catch (error) {
+    const failure = error;
+    const findings = Array.isArray(failure.report?.findings) ? failure.report.findings : Array.isArray(failure.findings) ? failure.findings : [];
+    throw new OPFApiError(failure.message ?? String(error), "invalid-presentation", { findings, cause: error });
+  }
+}
+function stemOfDeck(presentation) {
+  const root = presentation;
+  const text = typeof root.filename === "string" ? root.filename.replace(/\.(opf\.)?(json|ya?ml|md)$/i, "") : typeof root.name === "string" ? root.name : "";
+  return text.replace(/[^\p{L}\p{N}_.-]+/gu, "-").replace(/-{2,}/g, "-").replace(/^[-.]+|[-.]+$/g, "") || "deck";
+}
+async function planConversion(input, output, options = {}, flags = false) {
+  if (!options || typeof options !== "object") throw invalid2("convert takes options as an object.");
+  checkRenamedOptions(options);
+  const source = sourceOf(input, flags);
+  const target = targetOf(output, options, flags);
+  checkApplicable(source, target, options, flags);
+  const catalogs = options.catalogs ?? DEFAULT_CATALOGS;
+  const ExportClass = target.kind === "export" ? OPFExportError : OPFApiError;
+  const inputFile = typeof input === "string" ? input : void 0;
+  let prepared;
+  if (target.kind === "export") {
+    const { format: _format, zip: _zip, name: _name, signals: _signals, overwrite: _overwrite, ...rest } = options;
+    const assetDir = options.assetDir ?? (inputFile === void 0 ? void 0 : path6.dirname(path6.resolve(inputFile)));
+    const exportOptions = {
+      ...rest,
+      format: target.format,
+      ...assetDir === void 0 ? {} : { assetDir },
+      ...output === void 0 && target.zip ? { zip: true } : {}
+    };
+    prepared = await inStep(OPFExportError, "export-failed", () => prepareExport(exportOptions, flags));
+  }
+  let pptx;
+  if (source.kind === "pptx") pptx = await inStep(OPFImportError, "import-failed", () => loadPptx());
+  let presentation;
+  let check;
+  let findings;
+  let imported;
+  const read = inputFile === void 0 ? void 0 : { file: inputFile, bytes: await readInput(inputFile) };
+  if (source.kind === "pptx") {
+    const bytes = source.bytes ?? read?.bytes;
+    const result = await inStep(OPFImportError, "import-failed", () => importPresentation(bytes, { catalogs, signals: options.signals === true }, pptx));
+    imported = result.result;
+    presentation = result.result.presentation;
+    check = result.check;
+    findings = result.result.findings;
+  } else {
+    const report = source.kind === "deck" ? readDeckReport(Buffer.from(read.bytes).toString("utf8"), { format: source.format, validate: checkOptions(catalogs) }, "convert") : validate(input, checkOptions(catalogs));
+    if (!report.valid) throw new ExportClass(`${inputFile ?? "The presentation"} is not valid OPF: ${firstError(report.findings)}`, "invalid-presentation", { findings: report.findings });
+    presentation = source.kind === "deck" ? report.presentation : input;
+    check = report;
+    findings = report.findings;
+  }
+  const base = { check, format: target.format, zip: target.kind === "export" && target.zip, ...read ? { input: read } : {}, ...imported ? { imported } : {} };
+  if (target.kind === "deck") {
+    const bytes = new TextEncoder().encode(deckText(presentation, target.format));
+    const extension = `opf.${target.format === "markdown" ? "md" : target.format}`;
+    const name = output === void 0 ? `${options.name ?? (inputFile === void 0 ? stemOfDeck(presentation) : fileStem(inputFile))}.${extension}` : path6.basename(output);
+    return { ...base, files: [{ name, ...output === void 0 ? {} : { path: output }, type: DECK_MEDIA[target.format], bytes }], findings };
+  }
+  if (output === void 0 && prepared) prepared.options = { ...prepared.options, name: options.name ?? deckStem(presentation, inputFile === void 0 ? "-" : fileStem(inputFile)) };
+  const exported = await inStep(OPFExportError, "export-failed", () => runPreparedExport(prepared, presentation, findings));
+  const drawn = exported.files;
+  const facts = (file) => ({
+    ...file.slide === void 0 ? {} : { slide: file.slide },
+    ...file.id === void 0 ? {} : { id: file.id },
+    ...file.width === void 0 || file.height === void 0 ? {} : { width: file.width, height: file.height },
+    ...file.pages === void 0 ? {} : { pages: file.pages },
+    ...file.slides === void 0 ? {} : { slides: file.slides },
+    ...file.entries === void 0 ? {} : { entries: file.entries }
+  });
+  const done = (files) => ({ ...base, exported, findings: exported.findings, files });
+  if (output === void 0) return done(drawn.map((file) => ({ name: file.name, type: file.type, bytes: file.bytes, ...facts(file) })));
+  const single = (file) => done([{ name: path6.basename(output), path: output, type: file.type, bytes: file.bytes, ...facts(file) }]);
+  if (target.format === "pdf" || target.format === "pptx") return single(drawn[0]);
+  const stem = path6.basename(output, path6.extname(output));
+  const numbered = (file) => `${stem}-${/-(\d+)\.(?:png|svg)$/.exec(file.name)?.[1] ?? String(file.slide).padStart(3, "0")}.${target.format}`;
+  if (target.zip) {
+    const entries = drawn.map((file) => ({ name: numbered(file), bytes: file.bytes }));
+    return done([{ name: path6.basename(output), path: output, type: ZIP_MEDIA, bytes: createZip(entries), entries: entries.map((entry) => entry.name).sort() }]);
+  }
+  if (drawn.length === 1) return single(drawn[0]);
+  const folder = path6.dirname(output);
+  return done(drawn.map((file) => ({ name: numbered(file), path: path6.join(folder, numbered(file)), type: file.type, bytes: file.bytes, ...facts(file) })));
+}
+async function writePlanned(files, overwrite, flags = false) {
+  try {
+    await writeFiles(
+      files.map((file) => ({ file: file.path, bytes: file.bytes })),
+      overwrite,
+      flags
+    );
+  } catch (error) {
+    if (error instanceof OPFApiError) throw error;
+    const reason = error.code ?? error.message;
+    throw new OPFApiError(`Cannot write the output: ${error.message ?? reason}`, "output-unwritable", { details: { reason }, cause: error });
+  }
+}
+async function convertFiles(input, output, options = {}) {
+  const plan = await planConversion(input, output, options);
+  if (output !== void 0) await writePlanned(plan.files, options.overwrite !== false);
+  return { files: plan.files, findings: plan.findings, ...plan.imported?.signals ? { signals: plan.imported.signals } : {} };
+}
+async function openDeck(input, options = {}) {
+  const catalogs = options.catalogs ?? DEFAULT_CATALOGS;
+  if (input instanceof Uint8Array || input instanceof ArrayBuffer || typeof input === "string" && /\.pptx$/i.test(input)) {
+    const bytes = typeof input === "string" ? await readInput(input) : input instanceof Uint8Array ? input : new Uint8Array(input);
+    return (await inStep(OPFImportError, "import-failed", () => importPresentation(bytes, { catalogs }))).result.presentation;
+  }
+  if (typeof input !== "string" || !input) throw invalid2("open takes a file path or the bytes of a .pptx file.");
+  const format = deckFileFormat(input);
+  if (!format) throw invalid2(`open reads ${DECKS} and .pptx files; ${input} is none of them.`, { path: input });
+  const text = Buffer.from(await readInput(input)).toString("utf8");
+  const { presentation, format: _format, ...report } = readDeckReport(text, { format, catalogs, validate: checkOptions(catalogs) }, "open");
+  if (!report.valid) throw new OPFValidationError(report);
+  return presentation;
+}
+async function saveDeck(presentation, file, options = {}) {
+  if (!presentation || typeof presentation !== "object" || Array.isArray(presentation)) throw invalid2("save takes a presentation object.");
+  if (typeof file !== "string" || !file) throw invalid2("save takes a file path.");
+  const format = deckFileFormat(file);
+  if (!format) throw invalid2(`save writes ${DECKS} files; ${file} is none of them.${exportFormatOf(file) || /\.zip$/i.test(file) ? ` Export with convert(deck, "${file}").` : ""}`, { path: file });
+  if (options.validate !== false) {
+    const report = validate(presentation, checkOptions(options.catalogs ?? DEFAULT_CATALOGS));
+    if (!report.valid) throw new OPFValidationError(report);
+  }
+  const bytes = new TextEncoder().encode(deckText(presentation, format, options.schemaComment === true));
+  await writePlanned([{ name: path6.basename(file), path: file, type: DECK_MEDIA[format], bytes }], true);
+  return { path: file, format };
+}
+
+export { DEFAULT_CATALOGS, EXPORT_FORMATS, EXPORT_TEXT, PEER_RANGES, PPTX_PACKAGE, RENDER_EXTRAS, RENDER_PACKAGE, Reporter, VERSIONS, checkDate, checkDestinations, checkOptions, checkRenamedOptions, checkScale, convertFiles, createZip, deckFileFormat, deckStem, embeddedFor, exportFormatOf, finishReport, importPresentation, leaseSharedFonts, listFontDirectories, loadPptx, loadRenderer, locatePackage, missingPeerFrom, openDeck, planConversion, pointerOf, prepareExport, prepareFonts, reaches, readInput, reportThrown, resolveExportOptions, runExport, runImport, runPreparedExport, saveDeck, stemOf, writeFiles, writePlanned };