@bendyline/squisq-formats 1.4.2 → 2.0.1

package/dist/{chunk-RTS5XBZ7.js → chunk-HTW2M27H.js}

@@ -1,3 +1,11 @@
+import {
+  ConversionError
+} from "./chunk-ODL3SSPT.js";
+import {
+  ZipSafetyError,
+  openBoundedZipArchive
+} from "./chunk-FE6OJV6O.js";
+
 // src/registry/types.ts
 var BUILTIN_FORMAT_IDS = [
   "md",
@@ -12,19 +20,97 @@ var BUILTIN_FORMAT_IDS = [
   "dbk"
 ];
 
-// src/registry/errors.ts
-var ConversionError = class extends Error {
-  constructor(code, message, opts = {}) {
-    super(message);
-    this.name = "ConversionError";
-    this.code = code;
-    this.format = opts.format;
-    this.hint = opts.hint;
-    if (opts.cause !== void 0) {
-      this.cause = opts.cause;
-    }
-  }
+// src/shared/fidelity.ts
+var CONTENT_NODE_TYPES = {
+  heading: true,
+  paragraph: true,
+  blockquote: true,
+  list: true,
+  code: true,
+  thematicBreak: true,
+  table: true,
+  htmlBlock: true,
+  math: true,
+  definition: true,
+  footnoteDefinition: true,
+  containerDirective: true,
+  leafDirective: true,
+  definitionList: true,
+  text: true,
+  emphasis: true,
+  strong: true,
+  delete: true,
+  inlineCode: true,
+  link: true,
+  image: true,
+  break: true,
+  htmlInline: true,
+  inlineMath: true,
+  footnoteReference: true,
+  linkReference: true,
+  imageReference: true,
+  textDirective: true,
+  mention: true,
+  inlineIcon: true
+};
+var COMMON_SUPPORTED = [
+  "heading",
+  "paragraph",
+  "blockquote",
+  "list",
+  "code",
+  "thematicBreak",
+  "table",
+  "htmlBlock",
+  "math",
+  "text",
+  "emphasis",
+  "strong",
+  "delete",
+  "inlineCode",
+  "link",
+  "image",
+  "break",
+  "htmlInline",
+  "inlineMath"
+];
+var PROFILE_SUPPORT = {
+  docx: /* @__PURE__ */ new Set([...COMMON_SUPPORTED, "footnoteDefinition", "footnoteReference"]),
+  pdf: /* @__PURE__ */ new Set([...COMMON_SUPPORTED, "footnoteDefinition", "footnoteReference"]),
+  pptx: new Set(COMMON_SUPPORTED),
+  epub: new Set(COMMON_SUPPORTED)
 };
+var PROFILE_LABELS = {
+  docx: "DOCX",
+  pdf: "PDF",
+  pptx: "PPTX",
+  epub: "EPUB"
+};
+function markdownFidelityWarnings(document2, profile) {
+  const supported = PROFILE_SUPPORT[profile];
+  const omitted = /* @__PURE__ */ new Map();
+  const visit = (candidate) => {
+    if (!candidate || typeof candidate !== "object") return;
+    const node = candidate;
+    const type = node.type;
+    if (type && Object.prototype.hasOwnProperty.call(CONTENT_NODE_TYPES, type)) {
+      if (!supported.has(type)) {
+        omitted.set(type, (omitted.get(type) ?? 0) + 1);
+        return;
+      }
+    }
+    if (Array.isArray(node.children)) {
+      for (const child of node.children) visit(child);
+    }
+  };
+  for (const child of document2.children) visit(child);
+  if (omitted.size === 0) return [];
+  const total = [...omitted.values()].reduce((sum, count) => sum + count, 0);
+  const details = [...omitted].map(([type, count]) => `${type} (${count})`).join(", ");
+  return [
+    `${PROFILE_LABELS[profile]} export omitted ${total} unsupported Markdown node(s): ${details}.`
+  ];
+}
 
 // src/registry/defaultFormats.ts
 var MIME = {
@@ -55,6 +141,9 @@ async function toBytes(data) {
 function resolveThemeId(input, options) {
   return options.themeId ?? input.doc.themeId;
 }
+function optionsFor(options, id) {
+  return options.formatOptions?.[id] ?? {};
+}
 async function markdownOf(input) {
   if (input.markdownDoc) return input.markdownDoc;
   const { docToMarkdown } = await import("@bendyline/squisq/doc");
@@ -73,6 +162,29 @@ async function collectContainerImages(container) {
   }
   return images;
 }
+async function collectContainerDocxImages(container) {
+  const images = await collectContainerImages(container);
+  const { extToMime } = await import("./images-7FBWPKE3.js");
+  return new Map(
+    [...images].map(([path, data]) => [
+      path,
+      { data, contentType: extToMime(path.split(".").pop() ?? "") }
+    ])
+  );
+}
+async function snapshotContainerWithDocument(input) {
+  const { MemoryContentContainer } = await import("@bendyline/squisq/storage");
+  const snapshot = new MemoryContentContainer();
+  const entries = await input.container.listFiles();
+  for (const entry of entries) {
+    const data = await input.container.readFile(entry.path);
+    if (data) await snapshot.writeFile(entry.path, new Uint8Array(data), entry.mimeType);
+  }
+  const { stringifyMarkdown } = await import("@bendyline/squisq/markdown");
+  const documentPath = await input.container.getDocumentPath() ?? "index.md";
+  await snapshot.writeDocument(stringifyMarkdown(await markdownOf(input)), documentPath);
+  return snapshot;
+}
 async function requirePlayerScript(options, format) {
   const script = await options.resolvePlayerScript?.();
   if (!script) {
@@ -86,19 +198,27 @@ async function requirePlayerScript(options, format) {
 function ok(bytes, mimeType, warnings = []) {
   return { bytes, mimeType, suggestedFilename: "", warnings };
 }
+function pptxImportOptionsFrom(options) {
+  const raw = optionsFor(options, "pptx");
+  return {
+    ...raw,
+    inferTheme: raw?.inferTheme !== false,
+    inferLayouts: raw?.inferLayouts !== false
+  };
+}
 function defaultFormats() {
   const md = {
     id: "md",
     label: "Markdown",
     mimeType: MIME.md,
     extensions: [".md", ".markdown"],
-    async importDoc(data) {
+    async importDoc(data, options) {
       const { parseMarkdown } = await import("@bendyline/squisq/markdown");
-      return parseMarkdown(new TextDecoder().decode(data));
+      return parseMarkdown(new TextDecoder().decode(data), optionsFor(options, "md").parse);
     },
-    async exportDoc(input) {
+    async exportDoc(input, options) {
       const { stringifyMarkdown } = await import("@bendyline/squisq/markdown");
-      const text = stringifyMarkdown(await markdownOf(input));
+      const text = stringifyMarkdown(await markdownOf(input), optionsFor(options, "md").stringify);
       return ok(new TextEncoder().encode(text), MIME.md);
     }
   };
@@ -107,20 +227,28 @@ function defaultFormats() {
     label: "Word (DOCX)",
     mimeType: MIME.docx,
     extensions: [".docx"],
-    async importContainer(data) {
+    async importContainer(data, options) {
       const { docxToContainer } = await import("./docx/index.js");
-      return docxToContainer(data);
+      return docxToContainer(data, optionsFor(options, "docx"));
     },
-    async importDoc(data) {
+    async importDoc(data, options) {
       const { docxToMarkdownDoc } = await import("./docx/index.js");
-      return docxToMarkdownDoc(data);
+      return docxToMarkdownDoc(data, optionsFor(options, "docx"));
     },
     async exportDoc(input, options) {
       const { markdownDocToDocx } = await import("./docx/index.js");
-      const buf = await markdownDocToDocx(await markdownOf(input), {
-        themeId: resolveThemeId(input, options)
+      const raw = optionsFor(options, "docx");
+      const markdownDoc = await markdownOf(input);
+      const containerImages = await collectContainerDocxImages(input.container);
+      const images = new Map([...containerImages, ...raw.images ?? /* @__PURE__ */ new Map()]);
+      const buf = await markdownDocToDocx(markdownDoc, {
+        ...raw,
+        ...options.title !== void 0 ? { title: options.title } : {},
+        themeId: resolveThemeId(input, options),
+        themeRegistry: options.themeRegistry ?? raw.themeRegistry,
+        images
       });
-      return ok(await toBytes(buf), MIME.docx);
+      return ok(await toBytes(buf), MIME.docx, markdownFidelityWarnings(markdownDoc, "docx"));
     }
   };
   const pdf = {
@@ -128,20 +256,25 @@ function defaultFormats() {
     label: "PDF",
     mimeType: MIME.pdf,
     extensions: [".pdf"],
-    async importContainer(data) {
+    async importContainer(data, options) {
       const { pdfToContainer } = await import("./pdf/index.js");
-      return pdfToContainer(data);
+      return pdfToContainer(data, optionsFor(options, "pdf"));
     },
-    async importDoc(data) {
+    async importDoc(data, options) {
       const { pdfToMarkdownDoc } = await import("./pdf/index.js");
-      return pdfToMarkdownDoc(data);
+      return pdfToMarkdownDoc(data, optionsFor(options, "pdf"));
     },
     async exportDoc(input, options) {
       const { markdownDocToPdf } = await import("./pdf/index.js");
-      const buf = await markdownDocToPdf(await markdownOf(input), {
-        themeId: resolveThemeId(input, options)
+      const raw = optionsFor(options, "pdf");
+      const markdownDoc = await markdownOf(input);
+      const buf = await markdownDocToPdf(markdownDoc, {
+        ...raw,
+        ...options.title !== void 0 ? { title: options.title } : {},
+        themeId: resolveThemeId(input, options),
+        themeRegistry: options.themeRegistry ?? raw.themeRegistry
       });
-      return ok(await toBytes(buf), MIME.pdf);
+      return ok(await toBytes(buf), MIME.pdf, markdownFidelityWarnings(markdownDoc, "pdf"));
     }
   };
   const pptx = {
@@ -149,22 +282,28 @@ function defaultFormats() {
     label: "PowerPoint (PPTX)",
     mimeType: MIME.pptx,
     extensions: [".pptx"],
-    async importContainer(data) {
+    async importContainer(data, options) {
       const { pptxToContainer } = await import("./pptx/index.js");
-      return pptxToContainer(data);
+      return pptxToContainer(data, pptxImportOptionsFrom(options));
     },
-    async importDoc(data) {
+    async importDoc(data, options) {
       const { pptxToMarkdownDoc } = await import("./pptx/index.js");
-      return pptxToMarkdownDoc(data);
+      return pptxToMarkdownDoc(data, pptxImportOptionsFrom(options));
     },
     async exportDoc(input, options) {
       const { markdownDocToPptx } = await import("./pptx/index.js");
-      const images = await collectContainerImages(input.container);
-      const buf = await markdownDocToPptx(await markdownOf(input), {
+      const raw = optionsFor(options, "pptx");
+      const markdownDoc = await markdownOf(input);
+      const containerImages = await collectContainerImages(input.container);
+      const images = new Map([...containerImages, ...raw.images ?? /* @__PURE__ */ new Map()]);
+      const buf = await markdownDocToPptx(markdownDoc, {
+        ...raw,
+        ...options.title !== void 0 ? { title: options.title } : {},
         themeId: resolveThemeId(input, options),
+        themeRegistry: options.themeRegistry ?? raw.themeRegistry,
         images
       });
-      return ok(await toBytes(buf), MIME.pptx);
+      return ok(await toBytes(buf), MIME.pptx, markdownFidelityWarnings(markdownDoc, "pptx"));
     }
   };
   const xlsx = {
@@ -172,18 +311,21 @@ function defaultFormats() {
     label: "Excel (XLSX)",
     mimeType: MIME.xlsx,
     extensions: [".xlsx"],
-    async importDoc(data) {
+    async importDoc(data, options) {
       const { xlsxToMarkdownDoc } = await import("./xlsx/index.js");
-      return xlsxToMarkdownDoc(data);
+      return xlsxToMarkdownDoc(data, optionsFor(options, "xlsx"));
     },
-    async exportDoc(input) {
+    async exportDoc(input, options) {
       const { markdownDocToXlsx } = await import("./xlsx/index.js");
       const markdownDoc = await markdownOf(input);
       const omitted = markdownDoc.children.filter(
         (n) => n.type !== "table" && n.type !== "heading"
       ).length;
       const warnings = omitted > 0 ? [`XLSX export is tables-only; ${omitted} non-table block(s) were omitted.`] : [];
-      const blob = await markdownDocToXlsx(markdownDoc);
+      const blob = await markdownDocToXlsx(markdownDoc, {
+        ...optionsFor(options, "xlsx"),
+        ...options.title !== void 0 ? { title: options.title } : {}
+      });
       return ok(await toBytes(blob), MIME.xlsx, warnings);
     }
   };
@@ -192,21 +334,22 @@ function defaultFormats() {
     label: "CSV",
     mimeType: MIME.csv,
     extensions: [".csv"],
-    async importDoc(data) {
+    async importDoc(data, options) {
       const { csvToMarkdownDoc } = await import("./csv/index.js");
-      return csvToMarkdownDoc(data);
+      return csvToMarkdownDoc(data, optionsFor(options, "csv"));
     },
-    async exportDoc(input) {
+    async exportDoc(input, options) {
       const { markdownDocToCsv } = await import("./csv/index.js");
       const markdownDoc = await markdownOf(input);
+      const raw = optionsFor(options, "csv");
       const tableCount = markdownDoc.children.filter((n) => n.type === "table").length;
       const warnings = [];
-      if (tableCount > 1) {
+      if (tableCount > 1 && raw.tableIndex === void 0) {
         warnings.push(
           `Document has ${tableCount} tables; CSV export emitted only the first. Use the csv converter's tableIndex option to select another.`
         );
       }
-      const text = markdownDocToCsv(markdownDoc);
+      const text = markdownDocToCsv(markdownDoc, raw);
       return ok(new TextEncoder().encode(text), MIME.csv, warnings);
     }
   };
@@ -215,22 +358,26 @@ function defaultFormats() {
     label: "HTML (single file)",
     mimeType: MIME.html,
     extensions: [".html", ".htm"],
-    async importDoc(data) {
+    async importDoc(data, options) {
       const { htmlToMarkdownDoc } = await import("./html/index.js");
-      return htmlToMarkdownDoc(data);
+      return htmlToMarkdownDoc(data, optionsFor(options, "html"));
     },
     // importContainer omitted: HTML import already inlines images as data URIs,
     // so there is nothing to extract into a container this wave.
     async exportDoc(input, options) {
       const playerScript = await requirePlayerScript(options, "html");
       const { docToHtml } = await import("./html/index.js");
-      const images = await collectContainerImages(input.container);
+      const raw = optionsFor(options, "html");
+      const containerImages = await collectContainerImages(input.container);
+      const images = new Map([...containerImages, ...raw.images ?? /* @__PURE__ */ new Map()]);
       const htmlText = docToHtml(input.doc, {
+        ...raw,
         playerScript,
         images,
         title: options.title ?? input.baseName,
-        mode: "static",
-        themeId: resolveThemeId(input, options)
+        mode: raw.mode ?? "static",
+        themeId: resolveThemeId(input, options),
+        themeRegistry: options.themeRegistry ?? raw.themeRegistry
       });
       return ok(new TextEncoder().encode(htmlText), MIME.html);
     }
@@ -243,13 +390,17 @@ function defaultFormats() {
     async exportDoc(input, options) {
       const playerScript = await requirePlayerScript(options, "htmlzip");
       const { docToHtmlZip } = await import("./html/index.js");
-      const images = await collectContainerImages(input.container);
+      const raw = optionsFor(options, "htmlzip");
+      const containerImages = await collectContainerImages(input.container);
+      const images = new Map([...containerImages, ...raw.images ?? /* @__PURE__ */ new Map()]);
       const blob = await docToHtmlZip(input.doc, {
+        ...raw,
         playerScript,
         images,
         title: options.title ?? input.baseName,
-        mode: "static",
-        themeId: resolveThemeId(input, options)
+        mode: raw.mode ?? "static",
+        themeId: resolveThemeId(input, options),
+        themeRegistry: options.themeRegistry ?? raw.themeRegistry
       });
       return ok(await toBytes(blob), MIME.zip);
     }
@@ -261,13 +412,18 @@ function defaultFormats() {
     extensions: [".epub"],
     async exportDoc(input, options) {
       const { markdownDocToEpub } = await import("./epub/index.js");
-      const images = await collectContainerImages(input.container);
-      const buf = await markdownDocToEpub(await markdownOf(input), {
+      const raw = optionsFor(options, "epub");
+      const markdownDoc = await markdownOf(input);
+      const containerImages = await collectContainerImages(input.container);
+      const images = new Map([...containerImages, ...raw.images ?? /* @__PURE__ */ new Map()]);
+      const buf = await markdownDocToEpub(markdownDoc, {
+        ...raw,
         title: options.title ?? input.baseName,
         themeId: resolveThemeId(input, options),
+        themeRegistry: options.themeRegistry ?? raw.themeRegistry,
         images
       });
-      return ok(await toBytes(buf), MIME.epub);
+      return ok(await toBytes(buf), MIME.epub, markdownFidelityWarnings(markdownDoc, "epub"));
     }
   };
   const dbk = {
@@ -275,13 +431,16 @@ function defaultFormats() {
     label: "Squisq container (DBK)",
     mimeType: MIME.zip,
     extensions: [".dbk", ".zip"],
-    async importContainer(data) {
+    async importContainer(data, options) {
       const { zipToContainer } = await import("./container/index.js");
-      return zipToContainer(data);
+      return zipToContainer(data, optionsFor(options, "dbk"));
     },
-    async exportDoc(input) {
+    async exportDoc(input, options) {
       const { containerToZip } = await import("./container/index.js");
-      const blob = await containerToZip(input.container);
+      const blob = await containerToZip(
+        await snapshotContainerWithDocument(input),
+        optionsFor(options, "dbk")
+      );
       return ok(await toBytes(blob), MIME.zip);
     }
   };
@@ -323,6 +482,16 @@ function defaultRegistry() {
 }
 
 // src/registry/convert.ts
+function markdownFormatOptions(options) {
+  return options.formatOptions?.md ?? {};
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  if (signal.reason !== void 0) throw signal.reason;
+  const error = new Error("Document conversion was cancelled.");
+  error.name = "AbortError";
+  throw error;
+}
 function hasPrefix(bytes, prefix) {
   if (bytes.length < prefix.length) return false;
   for (let i = 0; i < prefix.length; i++) {
@@ -333,13 +502,19 @@ function hasPrefix(bytes, prefix) {
 var ZIP_MAGIC = [80, 75, 3, 4];
 var PDF_MAGIC = [37, 80, 68, 70];
 async function sniffZip(bytes) {
-  const JSZip = (await import("jszip")).default;
-  const zip = await JSZip.loadAsync(bytes).catch(() => {
-    throw new ConversionError("invalid-input", "Input is not a readable ZIP archive.");
+  const archive = await openBoundedZipArchive(bytes).catch((cause) => {
+    if (cause instanceof ZipSafetyError && cause.code !== "invalid-archive") throw cause;
+    throw new ConversionError("invalid-input", "Input is not a readable ZIP archive.", { cause });
   });
-  const contentTypes = zip.file("[Content_Types].xml");
+  const contentTypes = archive.entries.find((entry) => entry.path === "[Content_Types].xml");
   if (!contentTypes) return "dbk";
-  const xml = await contentTypes.async("string");
+  const maxContentTypesBytes = 1024 * 1024;
+  if ((contentTypes.declaredSize ?? 0) > maxContentTypesBytes) {
+    throw new ConversionError("invalid-input", "OOXML content-types metadata is too large.");
+  }
+  const xmlBytes = await archive.read(contentTypes.path, maxContentTypesBytes);
+  if (!xmlBytes) return "dbk";
+  const xml = new TextDecoder().decode(xmlBytes);
   if (xml.includes("wordprocessingml")) return "docx";
   if (xml.includes("presentationml")) return "pptx";
   if (xml.includes("spreadsheetml")) return "xlsx";
@@ -357,13 +532,15 @@ async function detectByteFormat(bytes, filename, options, registry) {
   return "md";
 }
 function extractExt(filename) {
-  const base = filename.split("/").pop() ?? filename;
+  const normalized = filename.replace(/\\/g, "/");
+  const base = normalized.split("/").pop() ?? normalized;
   const dot = base.lastIndexOf(".");
   if (dot <= 0) return "";
   return base.slice(dot + 1).toLowerCase();
 }
 function baseNameOf(filename) {
-  const base = filename.split("/").pop() ?? filename;
+  const normalized = filename.replace(/\\/g, "/");
+  const base = normalized.split("/").pop() ?? normalized;
   const dot = base.lastIndexOf(".");
   return dot > 0 ? base.slice(0, dot) : base;
 }
@@ -403,7 +580,7 @@ async function normalizeBytes(source, options, registry) {
       );
     }
     const text = await container.readDocument();
-    markdownDoc = text ? parseMarkdown(text) : { type: "document", children: [] };
+    markdownDoc = text ? parseMarkdown(text, markdownFormatOptions(options).parse) : { type: "document", children: [] };
   } else {
     markdownDoc = await fromDef.importDoc(buffer, options);
     const { MemoryContentContainer } = await import("@bendyline/squisq/storage");
@@ -422,7 +599,7 @@ async function normalizeMarkdown(source, options) {
   const { markdownToDoc } = await import("@bendyline/squisq/doc");
   const { parseMarkdown } = await import("@bendyline/squisq/markdown");
   const { stringifyMarkdown } = await import("@bendyline/squisq/markdown");
-  const markdownDoc = typeof source.markdown === "string" ? parseMarkdown(source.markdown) : source.markdown;
+  const markdownDoc = typeof source.markdown === "string" ? parseMarkdown(source.markdown, markdownFormatOptions(options).parse) : source.markdown;
   let container = source.container;
   if (!container) {
     const { MemoryContentContainer } = await import("@bendyline/squisq/storage");
@@ -457,11 +634,11 @@ async function normalize(source, options, registry) {
       return normalizeDoc(source);
   }
 }
-async function applyTransformStyle(input, transformStyle, themeId) {
+async function applyTransformStyle(input, transformStyle, themeId, registry) {
   const { applyTransform, extractDocImages } = await import("@bendyline/squisq/transform");
   const { docToMarkdown, markdownToDoc } = await import("@bendyline/squisq/doc");
   const images = extractDocImages(input.doc.blocks);
-  const result = applyTransform(input.doc, transformStyle, { themeId, images });
+  const result = applyTransform(input.doc, transformStyle, { themeId, images, registry });
   input.doc = result.doc;
   const markdownDoc = docToMarkdown(result.doc);
   input.markdownDoc = markdownDoc;
@@ -473,8 +650,77 @@ async function applyTransformStyle(input, transformStyle, themeId) {
   }
   return [];
 }
-async function convert(source, to, options = {}) {
+async function prepareConversion(source, options = {}) {
+  return prepareConversionInternal(source, options);
+}
+async function prepareConversionInternal(source, options, failureFormat) {
+  throwIfAborted(options.signal);
   const registry = options.registry ?? defaultRegistry();
+  let normalized;
+  try {
+    normalized = await normalize(source, options, registry);
+    throwIfAborted(options.signal);
+  } catch (err) {
+    throwIfAborted(options.signal);
+    if (err instanceof ConversionError) throw err;
+    const message = err instanceof Error ? err.message : String(err);
+    throw new ConversionError("invalid-input", message, {
+      format: options.from,
+      cause: err
+    });
+  }
+  const { input, warnings } = normalized;
+  if (options.themeId && !input.doc.themeId) {
+    input.doc = { ...input.doc, themeId: options.themeId };
+  }
+  try {
+    if (options.transformStyle) {
+      warnings.push(
+        ...await applyTransformStyle(
+          input,
+          options.transformStyle,
+          options.themeId ?? input.doc.themeId,
+          options.transformRegistry
+        )
+      );
+      throwIfAborted(options.signal);
+    }
+  } catch (err) {
+    throwIfAborted(options.signal);
+    if (err instanceof ConversionError) throw err;
+    const message = err instanceof Error ? err.message : String(err);
+    throw new ConversionError("conversion-failed", message, {
+      format: failureFormat,
+      cause: err
+    });
+  }
+  const preparedWarnings = Object.freeze([...warnings]);
+  const preparedInput = { ...input };
+  return Object.freeze({
+    async convert(to, targetOptions = {}) {
+      const target = requireExportTarget(registry, to);
+      const exportOptions = mergePreparedExportOptions(options, targetOptions);
+      throwIfAborted(exportOptions.signal);
+      let result;
+      try {
+        result = await target.exportDoc({ ...preparedInput }, exportOptions);
+        throwIfAborted(exportOptions.signal);
+      } catch (err) {
+        throwIfAborted(exportOptions.signal);
+        if (err instanceof ConversionError) throw err;
+        const message = err instanceof Error ? err.message : String(err);
+        throw new ConversionError("conversion-failed", message, { format: to, cause: err });
+      }
+      const ext = target.extensions[0]?.replace(/^\.+/, "") ?? to;
+      return {
+        ...result,
+        suggestedFilename: `${preparedInput.baseName}.${ext}`,
+        warnings: [...preparedWarnings, ...result.warnings]
+      };
+    }
+  });
+}
+function requireExportTarget(registry, to) {
   const target = registry.get(to);
   if (!target) {
     throw new ConversionError("unknown-format", `Unknown target format "${to}".`, { format: to });
@@ -486,41 +732,36 @@ async function convert(source, to, options = {}) {
       { format: to, hint: "This format is import-only." }
     );
   }
-  const { input, warnings } = await normalize(source, options, registry);
-  if (options.themeId && !input.doc.themeId) {
-    input.doc.themeId = options.themeId;
-  }
-  if (options.transformStyle) {
-    warnings.push(
-      ...await applyTransformStyle(
-        input,
-        options.transformStyle,
-        options.themeId ?? input.doc.themeId
-      )
-    );
-  }
-  let result;
-  try {
-    result = await target.exportDoc(input, options);
-  } catch (err) {
-    if (err instanceof ConversionError) throw err;
-    const message = err instanceof Error ? err.message : String(err);
-    throw new ConversionError("conversion-failed", message, { format: to, cause: err });
-  }
-  const ext = target.extensions[0]?.replace(/^\.+/, "") ?? to;
+  return target;
+}
+function mergePreparedExportOptions(prepared, target) {
   return {
-    ...result,
-    suggestedFilename: `${input.baseName}.${ext}`,
-    warnings: [...warnings, ...result.warnings]
+    ...prepared,
+    signal: mergeAbortSignals(prepared.signal, target.signal),
+    title: target.title ?? prepared.title,
+    resolvePlayerScript: target.resolvePlayerScript ?? prepared.resolvePlayerScript,
+    formatOptions: target.formatOptions === void 0 ? prepared.formatOptions : { ...prepared.formatOptions ?? {}, ...target.formatOptions }
   };
 }
+function mergeAbortSignals(preparedSignal, targetSignal) {
+  if (!preparedSignal) return targetSignal;
+  if (!targetSignal || preparedSignal === targetSignal) return preparedSignal;
+  return AbortSignal.any([preparedSignal, targetSignal]);
+}
+async function convert(source, to, options = {}) {
+  throwIfAborted(options.signal);
+  const registry = options.registry ?? defaultRegistry();
+  requireExportTarget(registry, to);
+  const prepared = await prepareConversionInternal(source, { ...options, registry }, to);
+  return prepared.convert(to);
+}
 
 export {
   BUILTIN_FORMAT_IDS,
-  ConversionError,
   defaultFormats,
   createRegistry,
   defaultRegistry,
+  prepareConversion,
   convert
 };
-//# sourceMappingURL=chunk-RTS5XBZ7.js.map
+//# sourceMappingURL=chunk-HTW2M27H.js.map