@bendyline/squisq-formats 1.3.0 → 1.4.0

package/src/html/import.ts

@@ -0,0 +1,297 @@
+/**
+ * HTML Import Module — @bendyline/squisq-formats/html
+ *
+ * Converts an HTML document (or fragment) into a squisq `MarkdownDocument`.
+ * Built on the existing `parseHtmlToNodes` (parse5-backed) + `sanitizeHtmlNodes`
+ * from `@bendyline/squisq/markdown`, so no new dependency is introduced.
+ *
+ * The primary consumer is email: HTML mail bodies are hostile input, so the
+ * parse is sanitized by default (scripts/styles/event handlers/dangerous URLs
+ * stripped) before the tree is walked into markdown nodes.
+ *
+ * Two entry points mirror the docx/pdf importers:
+ *   - `htmlToMarkdownDoc(data, options?)` → `MarkdownDocument`
+ *   - `htmlToMarkdown(html, options?)` → markdown string (convenience for the
+ *     string-in/string-out path email body conversion needs)
+ */
+
+import {
+  type MarkdownBlockNode,
+  type MarkdownDocument,
+  type MarkdownInlineNode,
+  type MarkdownListItem,
+  type MarkdownTableCell,
+  type MarkdownTableRow,
+  type HtmlElement,
+  type HtmlNode,
+  parseHtmlToNodes,
+  sanitizeHtmlNodes,
+  stringifyMarkdown,
+} from '@bendyline/squisq/markdown';
+
+export interface HtmlImportOptions {
+  /**
+   * Strip scripts / styles / event handlers / dangerous URLs before walking
+   * the tree. Default `true` — HTML email is untrusted; only disable for
+   * trusted input where you want raw fidelity.
+   */
+  sanitize?: boolean;
+}
+
+// ── tag classification ──────────────────────────────────────────────
+
+const HEADINGS: Record<string, 1 | 2 | 3 | 4 | 5 | 6> = {
+  h1: 1,
+  h2: 2,
+  h3: 3,
+  h4: 4,
+  h5: 5,
+  h6: 6,
+};
+
+// Containers with no semantic block meaning — unwrap and walk their children.
+const TRANSPARENT_BLOCK = new Set([
+  'div',
+  'section',
+  'article',
+  'header',
+  'footer',
+  'main',
+  'aside',
+  'nav',
+  'figure',
+  'figcaption',
+  'form',
+  'fieldset',
+  'body',
+  'html',
+  'center',
+]);
+
+// Elements that carry no content we want (and whose text must not leak).
+const DROP = new Set(['script', 'style', 'head', 'title', 'noscript', 'template', 'svg']);
+
+const INLINE_STRONG = new Set(['strong', 'b']);
+const INLINE_EM = new Set(['em', 'i']);
+const INLINE_DEL = new Set(['del', 's', 'strike']);
+const INLINE_TRANSPARENT = new Set(['span', 'font', 'abbr', 'mark', 'small', 'sub', 'sup', 'u']);
+
+const isElement = (n: HtmlNode): n is HtmlElement => n.type === 'htmlElement';
+const isText = (n: HtmlNode): n is { type: 'htmlText'; value: string } => n.type === 'htmlText';
+
+const collapseWs = (s: string): string => s.replace(/\s+/g, ' ');
+
+// ── inline conversion ───────────────────────────────────────────────
+
+function inlinesFromNodes(nodes: HtmlNode[]): MarkdownInlineNode[] {
+  const out: MarkdownInlineNode[] = [];
+  for (const node of nodes) {
+    if (isText(node)) {
+      const value = collapseWs(node.value);
+      if (value) out.push({ type: 'text', value });
+      continue;
+    }
+    if (!isElement(node)) continue; // comment
+    const tag = node.tagName.toLowerCase();
+    if (DROP.has(tag)) continue;
+
+    if (tag === 'br') {
+      out.push({ type: 'break' });
+    } else if (INLINE_STRONG.has(tag)) {
+      out.push({ type: 'strong', children: inlinesFromNodes(node.children) });
+    } else if (INLINE_EM.has(tag)) {
+      out.push({ type: 'emphasis', children: inlinesFromNodes(node.children) });
+    } else if (INLINE_DEL.has(tag)) {
+      out.push({ type: 'delete', children: inlinesFromNodes(node.children) });
+    } else if (tag === 'code' || tag === 'kbd' || tag === 'samp' || tag === 'tt') {
+      out.push({ type: 'inlineCode', value: textContent(node) });
+    } else if (tag === 'a') {
+      const url = node.attributes.href ?? '';
+      const children = inlinesFromNodes(node.children);
+      out.push({
+        type: 'link',
+        url,
+        children: children.length > 0 ? children : [{ type: 'text', value: url }],
+      });
+    } else if (tag === 'img') {
+      const url = node.attributes.src ?? '';
+      const alt = node.attributes.alt;
+      if (url) out.push({ type: 'image', url, ...(alt ? { alt } : {}) });
+    } else {
+      // Unknown / transparent inline (span, font, …): flatten children.
+      out.push(...inlinesFromNodes(node.children));
+    }
+  }
+  return out;
+}
+
+/** Flatten an element's descendant text (for code blocks / inline code). */
+function textContent(node: HtmlNode): string {
+  if (isText(node)) return node.value;
+  if (isElement(node)) return node.children.map(textContent).join('');
+  return '';
+}
+
+const onlyWhitespace = (inlines: MarkdownInlineNode[]): boolean =>
+  inlines.every((n) => n.type === 'text' && n.value.trim() === '');
+
+// ── block conversion ────────────────────────────────────────────────
+
+function blocksFromNodes(nodes: HtmlNode[]): MarkdownBlockNode[] {
+  const out: MarkdownBlockNode[] = [];
+  let inlineBuffer: HtmlNode[] = [];
+
+  const flush = () => {
+    if (inlineBuffer.length === 0) return;
+    const inlines = inlinesFromNodes(inlineBuffer);
+    inlineBuffer = [];
+    if (inlines.length > 0 && !onlyWhitespace(inlines)) {
+      out.push({ type: 'paragraph', children: inlines });
+    }
+  };
+
+  for (const node of nodes) {
+    if (isText(node)) {
+      inlineBuffer.push(node);
+      continue;
+    }
+    if (!isElement(node)) continue;
+    const tag = node.tagName.toLowerCase();
+    if (DROP.has(tag)) continue;
+
+    const block = blockForElement(node, tag);
+    if (block === 'inline') {
+      inlineBuffer.push(node);
+    } else if (block) {
+      flush();
+      out.push(...block);
+    }
+  }
+  flush();
+  return out;
+}
+
+/** Returns the block node(s) for a block element, `'inline'` for inline ones. */
+function blockForElement(node: HtmlElement, tag: string): MarkdownBlockNode[] | 'inline' | null {
+  if (tag in HEADINGS) {
+    const children = inlinesFromNodes(node.children);
+    return [{ type: 'heading', depth: HEADINGS[tag]!, children }];
+  }
+  if (tag === 'p') {
+    const children = inlinesFromNodes(node.children);
+    return children.length > 0 && !onlyWhitespace(children)
+      ? [{ type: 'paragraph', children }]
+      : [];
+  }
+  if (tag === 'br') return 'inline';
+  if (tag === 'hr') return [{ type: 'thematicBreak' }];
+  if (tag === 'blockquote') {
+    return [{ type: 'blockquote', children: blocksFromNodes(node.children) }];
+  }
+  if (tag === 'pre') {
+    return [{ type: 'code', value: stripTrailingNewline(textContent(node)) }];
+  }
+  if (tag === 'ul' || tag === 'ol') {
+    return [listFromElement(node, tag === 'ol')];
+  }
+  if (tag === 'table') {
+    const table = tableFromElement(node);
+    return table ? [table] : [];
+  }
+  if (TRANSPARENT_BLOCK.has(tag)) {
+    return blocksFromNodes(node.children);
+  }
+  if (
+    INLINE_STRONG.has(tag) ||
+    INLINE_EM.has(tag) ||
+    INLINE_DEL.has(tag) ||
+    INLINE_TRANSPARENT.has(tag) ||
+    tag === 'a' ||
+    tag === 'img' ||
+    tag === 'code' ||
+    tag === 'kbd' ||
+    tag === 'samp'
+  ) {
+    return 'inline';
+  }
+  // Unknown element: treat as a transparent container so its content survives.
+  return blocksFromNodes(node.children);
+}
+
+function listFromElement(node: HtmlElement, ordered: boolean): MarkdownBlockNode {
+  const items: MarkdownListItem[] = [];
+  for (const child of node.children) {
+    if (isElement(child) && child.tagName.toLowerCase() === 'li') {
+      const blocks = blocksFromNodes(child.children);
+      items.push({ type: 'listItem', children: blocks });
+    }
+  }
+  const startAttr = node.attributes.start;
+  const start = ordered && startAttr ? Number.parseInt(startAttr, 10) : undefined;
+  return {
+    type: 'list',
+    ordered,
+    ...(start !== undefined && Number.isFinite(start) ? { start } : {}),
+    children: items,
+  };
+}
+
+function tableFromElement(node: HtmlElement): MarkdownBlockNode | null {
+  const rows: MarkdownTableRow[] = [];
+  const collectRows = (n: HtmlElement) => {
+    for (const child of n.children) {
+      if (!isElement(child)) continue;
+      const t = child.tagName.toLowerCase();
+      if (t === 'tr') {
+        const cells: MarkdownTableCell[] = [];
+        for (const cell of child.children) {
+          if (
+            isElement(cell) &&
+            (cell.tagName.toLowerCase() === 'td' || cell.tagName.toLowerCase() === 'th')
+          ) {
+            cells.push({ type: 'tableCell', children: inlinesFromNodes(cell.children) });
+          }
+        }
+        if (cells.length > 0) rows.push({ type: 'tableRow', children: cells });
+      } else if (t === 'thead' || t === 'tbody' || t === 'tfoot') {
+        collectRows(child);
+      }
+    }
+  };
+  collectRows(node);
+  if (rows.length === 0) return null;
+  return { type: 'table', children: rows };
+}
+
+const stripTrailingNewline = (s: string): string => s.replace(/\n+$/, '');
+
+// ── public API ──────────────────────────────────────────────────────
+
+function toHtmlString(data: ArrayBuffer | Uint8Array | string): string {
+  if (typeof data === 'string') return data;
+  const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+  return new TextDecoder('utf-8').decode(bytes);
+}
+
+/** Parse HTML into a squisq `MarkdownDocument`. */
+export function htmlToMarkdownDocSync(
+  html: string,
+  options: HtmlImportOptions = {},
+): MarkdownDocument {
+  let nodes = parseHtmlToNodes(html);
+  if (options.sanitize !== false) nodes = sanitizeHtmlNodes(nodes);
+  return { type: 'document', children: blocksFromNodes(nodes) };
+}
+
+/** Async, ArrayBuffer-accepting entry mirroring docx/pdf importers. */
+export async function htmlToMarkdownDoc(
+  data: ArrayBuffer | Uint8Array | string,
+  options: HtmlImportOptions = {},
+): Promise<MarkdownDocument> {
+  return htmlToMarkdownDocSync(toHtmlString(data), options);
+}
+
+/** Convenience string→string conversion (used for email HTML bodies). */
+export function htmlToMarkdown(html: string, options: HtmlImportOptions = {}): string {
+  return stringifyMarkdown(htmlToMarkdownDocSync(html, options));
+}

package/src/html/index.ts

@@ -195,3 +195,7 @@ export { markdownDocsToPlainHtmlBundle, collectLinkRefs } from './plainHtmlBundl
 export type { PlainHtmlBundleOptions } from './plainHtmlBundle.js';
 export { markdownDocsToHtmlBundle } from './docsHtmlBundle.js';
 export type { HtmlBundleOptions } from './docsHtmlBundle.js';
+
+// ── Import (HTML → MarkdownDocument) ────────────────────────────────
+export { htmlToMarkdown, htmlToMarkdownDoc, htmlToMarkdownDocSync } from './import.js';
+export type { HtmlImportOptions } from './import.js';

package/src/html/plainHtml.ts

@@ -14,9 +14,18 @@
  * blob URLs (live preview) or data URIs (single-file export).
  */
 
-import type { MarkdownDocument, MarkdownNode, HtmlNode } from '@bendyline/squisq/markdown';
+import {
+  sanitizeHtmlNodes,
+  sanitizeUrl,
+  type HtmlPolicy,
+  type MarkdownDocument,
+  type MarkdownNode,
+  type HtmlNode,
+  readFrontmatterThemeId,
+} from '@bendyline/squisq/markdown';
 import type { Theme } from '@bendyline/squisq/schemas';
-import { resolveFontFamily, buildGoogleFontsUrl, resolveTheme } from '@bendyline/squisq/schemas';
+import { resolveFontFamily, buildGoogleFontsUrl } from '@bendyline/squisq/schemas';
+import { resolveThemeForDoc } from '@bendyline/squisq/doc';
 
 // ── Public Types ───────────────────────────────────────────────────
 
@@ -71,6 +80,11 @@ export interface PlainHtmlExportOptions {
    * option is not provided.
    */
   iconsCss?: string;
+  /**
+   * Raw HTML policy. Defaults to `sanitize`, which removes unsafe tags,
+   * event handlers, and executable URL schemes before emitting HTML.
+   */
+  htmlPolicy?: HtmlPolicy;
 }
 
 /**
@@ -81,6 +95,7 @@ export interface PlainHtmlExportOptions {
 interface RenderCtx {
   images?: Map<string, string>;
   links?: Map<string, string>;
+  htmlPolicy: HtmlPolicy;
 }
 
 // ── Public API ─────────────────────────────────────────────────────
@@ -97,19 +112,20 @@ export function markdownDocToPlainHtml(
   doc: MarkdownDocument,
   options: PlainHtmlExportOptions = {},
 ): string {
-  const { title = 'Document', images, links, themeId, iconsCss } = options;
+  const { title = 'Document', images, links, themeId, iconsCss, htmlPolicy = 'sanitize' } = options;
   // Fall back chain for theme: explicit `theme` → explicit `themeId`
   // option → doc frontmatter `themeId`. Hosts whose export dialog
   // tracks themes by id can pass `themeId` straight through; authored
   // docs with `themeId: warm-earth` in frontmatter get styled
   // automatically when neither is supplied.
-  const theme =
-    options.theme ??
-    (themeId ? resolveTheme(themeId) : undefined) ??
-    (typeof doc.frontmatter?.themeId === 'string'
-      ? resolveTheme(doc.frontmatter.themeId)
-      : undefined);
-  const ctx: RenderCtx = { images, links };
+  // Resolution is doc-scoped via `resolveThemeForDoc`, so an inline
+  // `squisq-custom-themes` id resolves here with no global registration —
+  // and `readFrontmatterThemeId` picks up the editor's canonical
+  // `squisq-theme` key. Stays undefined when nothing selects a theme so
+  // un-themed exports render unstyled (unchanged behavior).
+  const resolveId = themeId ?? readFrontmatterThemeId(doc.frontmatter);
+  const theme = options.theme ?? (resolveId ? resolveThemeForDoc(doc, resolveId) : undefined);
+  const ctx: RenderCtx = { images, links, htmlPolicy };
   const body = renderTopLevel(doc.children, ctx);
   const fontsLink = theme ? renderFontsLink(theme) : '';
   // Resolve how to load FontAwesome — only when the doc actually uses
@@ -258,7 +274,9 @@ interface FeaturedImage {
 
 function renderFeatureImage(img: FeaturedImage, ctx: RenderCtx | undefined): string {
   const resolved = ctx?.images?.get(img.src) ?? img.src;
-  const attrs = [`src="${escapeAttr(resolved)}"`, `alt="${escapeAttr(img.alt)}"`];
+  const safeSrc = sanitizeUrl(resolved, 'media');
+  if (!safeSrc) return '<div class="squisq-feature__media squisq-feature__media--empty"></div>';
+  const attrs = [`src="${escapeAttr(safeSrc)}"`, `alt="${escapeAttr(img.alt)}"`];
   // Emit `width` / `height` attributes only when the source HTML had
   // them. The CSS rules then know to honor those values rather than
   // stretching the image to fill the column.
@@ -604,12 +622,16 @@ function nodeToHtml(node: MarkdownNode | undefined | null, ctx?: RenderCtx): str
     case 'link': {
       const original = node.url ?? '';
       const rewritten = ctx?.links?.get(original) ?? original;
-      return `<a href="${escapeAttr(rewritten)}">${childrenToHtml(node, ctx)}</a>`;
+      const safeHref = sanitizeUrl(rewritten, 'link');
+      if (!safeHref) return childrenToHtml(node, ctx);
+      return `<a href="${escapeAttr(safeHref)}">${childrenToHtml(node, ctx)}</a>`;
     }
     case 'image': {
       const original = node.url ?? '';
       const resolved = ctx?.images?.get(original) ?? original;
-      return `<img src="${escapeAttr(resolved)}" alt="${escapeAttr(node.alt ?? '')}" />`;
+      const safeSrc = sanitizeUrl(resolved, 'media');
+      if (!safeSrc) return escapeHtml(node.alt ?? '');
+      return `<img src="${escapeAttr(safeSrc)}" alt="${escapeAttr(node.alt ?? '')}" />`;
     }
     case 'thematicBreak':
       return '<hr />';
@@ -626,11 +648,12 @@ function nodeToHtml(node: MarkdownNode | undefined | null, ctx?: RenderCtx): str
     }
     case 'htmlBlock':
     case 'htmlInline':
+      if (resolveHtmlPolicy(ctx) === 'strip') return '';
       // Resized images and other authored HTML survive the round-trip
       // as parsed `htmlChildren` — rewriting `<img src>` through the
       // image map keeps the preview consistent with the markdown-image
       // path. Other tags pass through unmodified.
-      return htmlChildrenToHtml(node.htmlChildren, ctx);
+      return htmlChildrenToHtml(resolveHtmlNodes(node.htmlChildren, ctx), ctx);
     default: {
       // Unknown / unhandled node — recurse into children if any so we
       // don't drop content (e.g. directives, footnotes).
@@ -682,18 +705,28 @@ function tableToHtml(
   return parts.join('');
 }
 
+function resolveHtmlPolicy(ctx: RenderCtx | undefined): HtmlPolicy {
+  return ctx?.htmlPolicy ?? 'sanitize';
+}
+
+function resolveHtmlNodes(nodes: HtmlNode[] | undefined, ctx: RenderCtx | undefined): HtmlNode[] {
+  if (!nodes || nodes.length === 0) return [];
+  return resolveHtmlPolicy(ctx) === 'trusted' ? nodes : sanitizeHtmlNodes(nodes);
+}
+
 function htmlChildrenToHtml(nodes: HtmlNode[] | undefined, ctx?: RenderCtx): string {
   if (!nodes || nodes.length === 0) return '';
+  const trusted = resolveHtmlPolicy(ctx) === 'trusted';
   const out: string[] = [];
   for (const node of nodes) {
     if (node.type === 'htmlText') {
       // HtmlText already represents authored HTML — emit verbatim so
       // entity references the user wrote (e.g. `&amp;`) survive.
-      out.push(node.value);
+      out.push(trusted ? node.value : escapeHtml(node.value));
       continue;
     }
     if (node.type === 'htmlComment') {
-      out.push(`<!--${node.value}-->`);
+      if (trusted) out.push(`<!--${node.value}-->`);
       continue;
     }
     // htmlElement
@@ -713,6 +746,23 @@ function htmlChildrenToHtml(nodes: HtmlNode[] | undefined, ctx?: RenderCtx): str
     if ((tag === 'video' || tag === 'audio') && typeof attrs.poster === 'string') {
       attrs.poster = ctx?.images?.get(attrs.poster) ?? attrs.poster;
     }
+    if (!trusted) {
+      if (typeof attrs.src === 'string') {
+        const safeSrc = sanitizeUrl(attrs.src, 'media');
+        if (!safeSrc) delete attrs.src;
+        else attrs.src = safeSrc;
+      }
+      if (typeof attrs.poster === 'string') {
+        const safePoster = sanitizeUrl(attrs.poster, 'media');
+        if (!safePoster) delete attrs.poster;
+        else attrs.poster = safePoster;
+      }
+      if (typeof attrs.href === 'string') {
+        const safeHref = sanitizeUrl(attrs.href, 'link');
+        if (!safeHref) delete attrs.href;
+        else attrs.href = safeHref;
+      }
+    }
     const attrStr = Object.entries(attrs)
       .map(([k, v]) => ` ${k}="${escapeAttr(v)}"`)
       .join('');

package/src/index.ts

@@ -7,8 +7,9 @@
  * Supported formats:
  * - **DOCX** — Microsoft Word (import + export) ✅
  * - **PDF**  — Portable Document Format (import + export) ✅
- * - **PPTX** — Microsoft PowerPoint (export ✅, import planned)
- * - **XLSX** — Microsoft Excel (planned)
+ * - **PPTX** — Microsoft PowerPoint (export ✅, import ✅)
+ * - **XLSX** — Microsoft Excel (import ✅, export planned)
+ * - **CSV**  — Comma-separated values (import ✅, export ✅)
  *
  * All converters run in the browser — no server or native binaries required.
  * The shared `ooxml/` subpath export provides reusable OOXML infrastructure.
@@ -32,10 +33,14 @@ export type { DocxExportOptions, DocxImportOptions } from './docx/index.js';
 export { markdownDocToPptx, docToPptx, pptxToMarkdownDoc, pptxToDoc } from './pptx/index.js';
 export type { PptxExportOptions, PptxImportOptions } from './pptx/index.js';
 
-// XLSX (stub)
+// XLSX (import implemented, export stub)
 export { markdownDocToXlsx, docToXlsx, xlsxToMarkdownDoc, xlsxToDoc } from './xlsx/index.js';
 export type { XlsxExportOptions, XlsxImportOptions } from './xlsx/index.js';
 
+// CSV (import + export)
+export { csvToMarkdownDoc, csvToDoc, markdownDocToCsv, parseCsv } from './csv/index.js';
+export type { CsvImportOptions, CsvExportOptions } from './csv/index.js';
+
 // PDF (fully implemented)
 export {
   markdownDocToPdf,
@@ -49,6 +54,8 @@ export type { PdfExportOptions, PdfImportOptions } from './pdf/index.js';
 // HTML (fully implemented)
 export { docToHtml, docToHtmlZip, collectImagePaths } from './html/index.js';
 export type { HtmlExportOptions, HtmlZipExportOptions } from './html/index.js';
+export { htmlToMarkdown, htmlToMarkdownDoc, htmlToMarkdownDocSync } from './html/index.js';
+export type { HtmlImportOptions } from './html/index.js';
 
 // EPUB (export)
 export { markdownDocToEpub, docToEpub } from './epub/index.js';

package/src/ooxml/namespaces.ts

@@ -77,6 +77,9 @@ export const NS_WML = 'http://schemas.openxmlformats.org/wordprocessingml/2006/m
 /** PresentationML main namespace (p:) */
 export const NS_PML = 'http://schemas.openxmlformats.org/presentationml/2006/main';
 
+/** PowerPoint 2010 extension namespace (p14:) */
+export const NS_PML_2010 = 'http://schemas.microsoft.com/office/powerpoint/2010/main';
+
 // ============================================
 // SpreadsheetML (XLSX)
 // ============================================

package/src/pdf/export.ts

@@ -22,8 +22,7 @@
 import { PDFDocument, StandardFonts, rgb, PDFFont, PDFPage } from 'pdf-lib';
 
 import type { Doc } from '@bendyline/squisq/schemas';
-import { resolveTheme } from '@bendyline/squisq/schemas';
-import { docToMarkdown } from '@bendyline/squisq/doc';
+import { docToMarkdown, resolveThemeForDoc } from '@bendyline/squisq/doc';
 import type {
   MarkdownDocument,
   MarkdownBlockNode,
@@ -51,6 +50,7 @@ import type {
   MarkdownInlineMath,
   MarkdownFootnoteReference,
 } from '@bendyline/squisq/markdown';
+import { readFrontmatterThemeId } from '@bendyline/squisq/markdown';
 
 import {
   PAGE_WIDTH_LETTER,
@@ -127,7 +127,7 @@ export async function markdownDocToPdf(
   pdfDoc.setCreationDate(new Date());
   pdfDoc.setModificationDate(new Date());
 
-  const ctx = await createExportContext(pdfDoc, options);
+  const ctx = await createExportContext(pdfDoc, options, doc);
 
   renderBlocks(doc.children, ctx, 0);
 
@@ -190,6 +190,7 @@ interface ExportContext {
 async function createExportContext(
   pdfDoc: PDFDocument,
   options: PdfExportOptions,
+  doc: MarkdownDocument,
 ): Promise<ExportContext> {
   const [regular, bold, italic, boldItalic, mono, monoBold] = await Promise.all([
     pdfDoc.embedFont(StandardFonts.Helvetica),
@@ -213,8 +214,12 @@ async function createExportContext(
   let colorHeading = COLOR_HEADING;
   let colorLink = COLOR_LINK;
 
-  if (options.themeId) {
-    const theme = resolveTheme(options.themeId);
+  // Honor an explicit themeId, else the doc's frontmatter theme (`squisq-theme`
+  // / legacy) — mirroring PPTX/DOCX/HTML so every format themes consistently,
+  // including inline custom themes (resolved doc-scoped).
+  const themeId = options.themeId ?? readFrontmatterThemeId(doc.frontmatter);
+  if (themeId) {
+    const theme = resolveThemeForDoc(doc, themeId);
     if (theme.colors) {
       colorText = hexToRgb(theme.colors.text) ?? COLOR_TEXT;
       colorHeading = hexToRgb(theme.colors.primary) ?? COLOR_HEADING;

package/src/pdf/import.ts

@@ -22,6 +22,7 @@
 
 import type { Doc } from '@bendyline/squisq/schemas';
 import { markdownToDoc } from '@bendyline/squisq/doc';
+import { stringifyMarkdown } from '@bendyline/squisq/markdown';
 import type {
   MarkdownDocument,
   MarkdownBlockNode,
@@ -169,7 +170,6 @@ export async function pdfToContainer(
 
   const markdownDoc: MarkdownDocument = { type: 'document', children: blocks };
 
-  const { stringifyMarkdown } = await import('@bendyline/squisq/markdown');
   const markdown = stringifyMarkdown(markdownDoc);
 
   const container = new MemoryContentContainer();