md-pdf-studio 2.1.0 → 2.3.0

package/README.md

@@ -29,6 +29,9 @@
 - 📊 **Mermaid Diagrams**: Sequence diagrams (with auto note wrapping), flowcharts, class diagrams, and gantt charts.
 - 🌈 **Syntax Highlighting**: Fenced code blocks that name a language (` ```js `, ` ```python `, ` ```diff `, …) are coloured at build time with highlight.js — no CDN, so it also works offline and in static HTML export. Colours follow the theme's code block background. Works in the CLI and in the extension preview.
 - 📐 **LaTeX Math Support**: Mathematical equations rendered with KaTeX.
+- 📝 **Footnotes**: `text[^1]` with `[^1]: the note` anywhere in the file. Notes are numbered in the order they are first referenced, gathered at the end of the document, and linked both ways. Works in the CLI and in the extension preview.
+- 📘 **Word & EPUB Export (CLI)**: `-f docx` writes a Word document and `-f epub` an EPUB 3 e-book, straight from the Markdown and without a browser. Headings, lists (nested, numbered from any start, task lists), tables with their alignment, code blocks, quotes, footnotes, links and local images become the real thing in each format — Word styles you can restyle, a chapter per top-level heading and a navigation menu in the EPUB. `--toc`, `--cover`, page size, orientation and margins apply to Word; `--toc` and `--cover` to EPUB. Themes, custom CSS, Mermaid diagrams and KaTeX math are for PDF and HTML only: a diagram or formula is kept as its source. An image on the web is not downloaded — it is named in Word and becomes a link in the EPUB — and a link to a neighbouring file keeps its text only.
+- 📎 **File Includes (CLI)**: A line that holds only `@import "chapters/intro.md"` is replaced by that file, relative to the file the line is in. A Markdown file is inserted as Markdown (without its front matter) and may import further files; any other file — `@import "src/app.js"` — is inserted as a code block labelled with its extension. Lines inside a code block are left alone, a missing file or files that import each other stop the conversion with the file and line, and watch mode follows the imported files. `--no-include` turns it off.
 - 💡 **GitHub Callout Box Alerts**: Support for `> [!NOTE]`, `> [!TIP]`, `> [!WARNING]`, `> [!IMPORTANT]`, and `> [!CAUTION]`.
 - 💻 **ASCII UI Mockups**: Styled dark-theme boxes for terminal output & ASCII wireframe mockups.
 
@@ -82,6 +85,29 @@ npx md-pdf-studio file1.md file2.md -o output_dir/
 
 # Convert entire directory of .md files
 npx md-pdf-studio ./docs/ -o ./dist/
+
+# Word document with a cover page and a table of contents
+npx md-pdf-studio report.md -f docx --cover --toc
+
+# EPUB e-book, one chapter per top-level heading
+npx md-pdf-studio book.md -f epub -o book.epub
+```
+
+A book kept as one file per chapter is one document with includes:
+
+```markdown
+---
+title: Handbook
+toc: true
+---
+# Handbook
+
+@import "chapters/01-intro.md"
+@import "chapters/02-setup.md"
+
+## Example config
+
+@import "examples/config.yml"
 ```
 
 ---
@@ -90,8 +116,8 @@ npx md-pdf-studio ./docs/ -o ./dist/
 
 | Flag | Alias | Description | Default |
 | :--- | :--- | :--- | :--- |
-| `-o, --output <path>`| | Output PDF/HTML file path or target directory | Auto-derived |
-| `-f, --format <format>`| | Output format: `pdf`, `html` | `pdf` |
+| `-o, --output <path>`| | Output file path or target directory | Auto-derived |
+| `-f, --format <format>`| | Output format: `pdf`, `html`, `docx`, `epub` | `pdf` |
 | `-w, --watch` | | Live watch input file and auto-recompile on change | `false` |
 | `-t, --theme <theme>` | | Theme: `modern`, `dark`, `academic`, `github`, `ebook`, `cyberpunk`, `minimal` | `modern` |
 | `--font <font>` | | Font family: `Inter`, `Roboto`, `Lora`, `Merriweather`, `JetBrains Mono`, `Fira Code` | `Inter` |
@@ -105,6 +131,7 @@ npx md-pdf-studio ./docs/ -o ./dist/
 | `--no-mermaid` | | Disable Mermaid diagram rendering | `false` |
 | `--no-katex` | | Disable KaTeX math formula rendering | `false` |
 | `--no-highlight` | | Disable syntax highlighting of code blocks | `false` |
+| `--no-include` | | Leave `@import "file"` lines as they are instead of inserting the file | `false` |
 
 ---
 
@@ -180,6 +207,12 @@ convert-md-to-pdf/
 │   │   │   ├── cyberpunk.js # Cyberpunk neon dark theme
 │   │   │   └── minimal.js   # Minimal monochrome theme
 │   │   ├── frontmatter.js   # YAML front matter parser
+│   │   ├── include.js       # @import "file" expansion
+│   │   ├── docmodel.js      # Format-neutral document model (blocks of flat runs)
+│   │   ├── docx.js          # Word (.docx) writer
+│   │   ├── epub.js          # EPUB 3 writer
+│   │   ├── images.js        # Local image reading & sizes
+│   │   ├── zip.js           # ZIP container writer for docx/epub
 │   │   ├── cover.js         # Cover page generator
 │   │   ├── toc.js           # Dotted leader line TOC generator
 │   │   ├── sanitizer.js     # HTML sanitizer & escaping

package/bin/cli.js

@@ -6,6 +6,10 @@ const fs = require('fs');
 const { convertMarkdownToPdf } = require('../src/core/index');
 const packageJson = require('../package.json');
 
+const OUTPUT_FORMATS = ['pdf', 'html', 'docx', 'epub'];
+// An --output that names a file rather than a folder.
+const OUTPUT_FILE = /\.(pdf|html|docx|epub)$/i;
+
 const program = new Command();
 
 program
@@ -14,8 +18,8 @@ program
   .description('High-quality Markdown to PDF converter CLI with Mermaid, Math, TOC, Custom CSS, and Batch conversion.')
   .version(packageJson.version, '-v, --version', 'Output tool version')
   .argument('<inputs...>', 'Input Markdown file(s) or wildcard pattern (.md)')
-  .option('-o, --output <path>', 'Output PDF/HTML file path or destination directory')
-  .option('-f, --format <format>', 'Output format: pdf (default), html', 'pdf')
+  .option('-o, --output <path>', 'Output file path or destination directory')
+  .option('-f, --format <format>', 'Output format: pdf (default), html, docx, epub', 'pdf')
   .option('-w, --watch', 'Watch input file(s) and recompile automatically on changes', false)
   .option('-t, --theme <theme>', 'Theme name: modern (default), dark, academic, minimal, github, ebook, cyberpunk', 'modern')
   .option('--font <font>', 'Font family: Inter (default), Roboto, Lora, Merriweather, JetBrains Mono, Fira Code', 'Inter')
@@ -29,9 +33,13 @@ program
   .option('--no-mermaid', 'Disable Mermaid diagram rendering')
   .option('--no-katex', 'Disable KaTeX math formula rendering')
   .option('--no-highlight', 'Disable syntax highlighting of code blocks')
+  .option('--no-include', 'Leave @import "file" lines as they are instead of inserting the file')
   .option('-b, --browser <path>', 'Custom Chrome/Edge executable path')
   .action(async (inputArgs, options) => {
     try {
+      // Files pulled in with @import, so watch mode can follow them too.
+      const importedFiles = new Set();
+
       const runConversion = async () => {
         const startTime = Date.now();
         const inputFiles = expandInputFiles(inputArgs);
@@ -43,6 +51,9 @@ program
         }
 
         const targetFormat = (options.format || 'pdf').toLowerCase();
+        if (!OUTPUT_FORMATS.includes(targetFormat)) {
+          throw new Error(`Unknown format "${options.format}". Use one of: ${OUTPUT_FORMATS.join(', ')}`);
+        }
         console.log(`\n\x1b[36m🚀 Converting ${inputFiles.length} file(s) to ${targetFormat.toUpperCase()}...\x1b[0m`);
         console.log(`   Theme:  ${options.theme}`);
         console.log(`   Font:   ${options.font}`);
@@ -54,7 +65,7 @@ program
         let targetOutputDir = null;
         if (options.output) {
           const resolvedOut = path.resolve(options.output);
-          if (inputFiles.length === 1 && (resolvedOut.endsWith('.pdf') || resolvedOut.endsWith('.html'))) {
+          if (inputFiles.length === 1 && OUTPUT_FILE.test(resolvedOut)) {
             targetOutputDir = null;
           } else {
             targetOutputDir = resolvedOut;
@@ -71,7 +82,7 @@ program
 
           if (targetOutputDir) {
             fileOutPath = path.join(targetOutputDir, `${fileBaseName}.${targetFormat}`);
-          } else if (options.output && (options.output.endsWith('.pdf') || options.output.endsWith('.html'))) {
+          } else if (options.output && OUTPUT_FILE.test(options.output)) {
             fileOutPath = options.output;
           }
 
@@ -91,10 +102,12 @@ program
             mermaid: options.mermaid,
             katex: options.katex,
             highlight: options.highlight,
+            include: options.include,
             executablePath: options.browser
           });
 
-          const outPathDisplay = result.pdfPath || result.htmlPath;
+          result.includedFiles.forEach(includedFile => importedFiles.add(includedFile));
+          const outPathDisplay = result.outputPath;
           console.log(`   \x1b[32m✔ File saved:\x1b[0m ${outPathDisplay}`);
           count++;
         }
@@ -112,27 +125,35 @@ program
         console.log('\n\x1b[35m👀 Watch mode enabled. Monitoring files for changes...\x1b[0m');
 
         let debounceTimer = null;
+        let watchImports = () => {};
         const triggerRecompile = (filename) => {
           if (debounceTimer) clearTimeout(debounceTimer);
           debounceTimer = setTimeout(async () => {
             console.log(`\n\x1b[33m🔄 Change detected in ${filename}. Recompiling...\x1b[0m`);
             try {
               await runConversion();
+              watchImports();
             } catch (err) {
               console.error(`\x1b[31m✖ Error during watch recompile:\x1b[0m ${err.message}`);
             }
           }, 300);
         };
 
-        inputFiles.forEach(filePath => {
-          if (fs.existsSync(filePath)) {
-            fs.watch(filePath, (eventType) => {
-              if (eventType === 'change') {
-                triggerRecompile(path.basename(filePath));
-              }
-            });
-          }
-        });
+        const watched = new Set();
+        const watchFile = (filePath) => {
+          if (watched.has(filePath) || !fs.existsSync(filePath)) return;
+          watched.add(filePath);
+          fs.watch(filePath, (eventType) => {
+            if (eventType === 'change') {
+              triggerRecompile(path.basename(filePath));
+            }
+          });
+        };
+        // An edit can add an @import, so the list is read again after every run.
+        watchImports = () => importedFiles.forEach(watchFile);
+
+        inputFiles.forEach(watchFile);
+        watchImports();
 
         if (options.css && fs.existsSync(options.css)) {
           fs.watch(options.css, (eventType) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "md-pdf-studio",
-  "version": "2.1.0",
-  "description": "A powerful CLI tool and Manifest V3 Browser Extension to convert Markdown files, text, or web pages into beautifully styled PDFs with Mermaid diagrams, LaTeX math, TOC, and themes.",
+  "version": "2.3.0",
+  "description": "A powerful CLI tool and Manifest V3 Browser Extension to convert Markdown files, text, or web pages into beautifully styled PDFs with Mermaid diagrams, LaTeX math, TOC, and themes. The CLI also writes Word (.docx) and EPUB.",
   "main": "src/core/index.js",
   "bin": {
     "md-pdf-studio": "bin/cli.js",
@@ -33,7 +33,9 @@
     "md2pdf",
     "marked",
     "md-pdf-studio",
-    "markdown-to-pdf"
+    "markdown-to-pdf",
+    "docx",
+    "epub"
   ],
   "author": "vannt-dev",
   "license": "MIT",

package/src/core/cover.js

@@ -31,8 +31,7 @@ function generateCoverPage(metadata = {}) {
       ${docDate ? `<div class="cover-meta-item"><span class="cover-meta-label">Ngày lập:</span> <span class="cover-meta-val">${escapeHtml(docDate)}</span></div>` : ''}
     </div>
   </div>
-</div>
-<div class="page-break"></div>\n`;
+</div>\n`;
 }
 
 module.exports = {

package/src/core/docmodel.js

@@ -0,0 +1,323 @@
+const { marked } = require('marked');
+const { parseFrontMatter } = require('./frontmatter');
+const { applyFootnotes } = require('./footnotes');
+const { preprocessMarkdown } = require('./utils');
+
+/**
+ * A format-neutral model of a Markdown document, for the exporters that do
+ * not go through HTML (DOCX, EPUB).
+ *
+ * Blocks:
+ *   { type: 'heading', depth, id, runs }
+ *   { type: 'paragraph', runs }
+ *   { type: 'code', lang, text }
+ *   { type: 'quote', blocks }
+ *   { type: 'list', ordered, start, items: [{ checked, blocks }] }
+ *   { type: 'table', header: [{ align, runs }], rows: [[{ align, runs }]] }
+ *   { type: 'rule' } | { type: 'pageBreak' }
+ *
+ * Runs are flat: nested emphasis becomes flags on each piece of text, so a
+ * writer never has to balance tags.
+ *   { text, bold, italic, strike, code, sup, sub, href }
+ *   { image: { src, alt }, href } | { lineBreak: true }
+ */
+
+const NAMED_ENTITIES = {
+  amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ', copy: '©', reg: '®',
+  trade: '™', hellip: '…', mdash: '—', ndash: '–', lsquo: '‘', rsquo: '’', ldquo: '“',
+  rdquo: '”', laquo: '«', raquo: '»', times: '×', divide: '÷', deg: '°', plusmn: '±',
+  micro: 'µ', para: '¶', sect: '§', euro: '€', pound: '£', yen: '¥', cent: '¢', minus: '−',
+  larr: '←', rarr: '→', uarr: '↑', darr: '↓', bull: '•', middot: '·'
+};
+
+/**
+ * Turns HTML character references into the characters they stand for.
+ * A reference that is not known is left as it was written.
+ * @param {string} text
+ * @returns {string}
+ */
+function decodeEntities(text = '') {
+  return text.replace(/&(#x[0-9a-fA-F]+|#\d+|[a-zA-Z]+);/g, (whole, name) => {
+    if (name[0] === '#') {
+      const code = name[1] === 'x' || name[1] === 'X' ? parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);
+      return code > 0 && code <= 0x10FFFF ? String.fromCodePoint(code) : whole;
+    }
+    return Object.hasOwn(NAMED_ENTITIES, name) ? NAMED_ENTITIES[name] : whole;
+  });
+}
+
+/** The same slugs as the table of contents of the HTML output, kept unique. */
+function createSlugger() {
+  const counts = new Map();
+  return (title, fallback) => {
+    let slug = title
+      .toLowerCase()
+      .replace(/[^\wÀ-ɏẠ-ỹ]+/g, '-')
+      .replace(/^-+|-+$/g, '') || fallback;
+    const seen = counts.get(slug) || 0;
+    counts.set(slug, seen + 1);
+    if (seen > 0) slug = `${slug}-${seen + 1}`;
+    return slug;
+  };
+}
+
+const HTML_TAG = /<(\/?)([a-zA-Z][\w-]*)((?:\s+[^<>]*?)?)\s*(\/?)>/g;
+const FLAG_TAGS = {
+  b: 'bold', strong: 'bold', i: 'italic', em: 'italic', s: 'strike', del: 'strike',
+  strike: 'strike', code: 'code', kbd: 'code', sup: 'sup', sub: 'sub'
+};
+
+function attribute(source, name) {
+  const match = new RegExp(`\\b${name}\\s*=\\s*("([^"]*)"|'([^']*)'|([^\\s"'>]+))`, 'i').exec(source);
+  return match ? decodeEntities(match[2] ?? match[3] ?? match[4] ?? '') : null;
+}
+
+/**
+ * Collects the runs of one block. Raw HTML is reduced to what it means for
+ * the text: emphasis, line breaks, links and images are kept, any other tag
+ * is dropped and its content stays.
+ */
+function createRunCollector() {
+  const runs = [];
+  const flags = { bold: 0, italic: 0, strike: 0, code: 0, sup: 0, sub: 0 };
+  // Raw <a> elements still open: a link target, or null for one whose text is skipped.
+  const anchors = [];
+  let skipping = 0;
+
+  const styleNow = (style) => {
+    const run = {};
+    for (const flag of Object.keys(flags)) {
+      if (style[flag] || flags[flag] > 0) run[flag] = true;
+    }
+    const href = style.href || anchors.filter(anchor => anchor && anchor.href).map(anchor => anchor.href).pop();
+    if (href) run.href = href;
+    return run;
+  };
+
+  const pushText = (text, style) => {
+    if (!text || skipping > 0) return;
+    const run = { text, ...styleNow(style) };
+    const previous = runs[runs.length - 1];
+    // Neighbouring pieces that look the same are one run.
+    if (previous && previous.text !== undefined && sameStyle(previous, run)) previous.text += text;
+    else runs.push(run);
+  };
+
+  const pushHtml = (html, style) => {
+    let last = 0;
+    HTML_TAG.lastIndex = 0;
+    for (let match = HTML_TAG.exec(html); match; match = HTML_TAG.exec(html)) {
+      pushText(decodeEntities(html.slice(last, match.index)), style);
+      last = HTML_TAG.lastIndex;
+      const closing = match[1] === '/';
+      const tag = match[2].toLowerCase();
+      const attributes = match[3] || '';
+
+      if (FLAG_TAGS[tag]) {
+        const flag = FLAG_TAGS[tag];
+        flags[flag] = Math.max(0, flags[flag] + (closing ? -1 : 1));
+      } else if (tag === 'br' && !closing) {
+        if (skipping === 0) runs.push({ lineBreak: true });
+      } else if (tag === 'img' && !closing) {
+        const src = attribute(attributes, 'src');
+        if (src && skipping === 0) {
+          runs.push({ image: { src, alt: attribute(attributes, 'alt') || '' }, ...styleNow(style) });
+        }
+      } else if (tag === 'a') {
+        if (closing) {
+          const anchor = anchors.pop();
+          if (anchor === null) skipping = Math.max(0, skipping - 1);
+        } else if (/\bfootnote-backref\b/.test(attributes)) {
+          // The arrow back to the text means nothing without the link.
+          anchors.push(null);
+          skipping += 1;
+        } else {
+          const href = attribute(attributes, 'href');
+          // A footnote number stays a number; its target is a list item further down.
+          anchors.push({ href: href && !/^#fn-?/.test(href) ? href : null });
+        }
+      }
+    }
+    pushText(decodeEntities(html.slice(last)), style);
+  };
+
+  const walk = (tokens, style) => {
+    for (const token of tokens || []) {
+      switch (token.type) {
+        case 'strong': walk(token.tokens, { ...style, bold: true }); break;
+        case 'em': walk(token.tokens, { ...style, italic: true }); break;
+        case 'del': walk(token.tokens, { ...style, strike: true }); break;
+        case 'codespan': pushText(decodeEntities(token.text), { ...style, code: true }); break;
+        case 'br': if (skipping === 0) runs.push({ lineBreak: true }); break;
+        case 'link': walk(token.tokens, { ...style, href: token.href }); break;
+        case 'image':
+          if (skipping === 0) runs.push({ image: { src: token.href, alt: token.text || '' }, ...styleNow(style) });
+          break;
+        case 'html': pushHtml(token.text, style); break;
+        case 'checkbox': break;
+        case 'escape': pushText(token.text, style); break;
+        default:
+          if (token.tokens) walk(token.tokens, style);
+          else if (typeof token.text === 'string') pushText(decodeEntities(token.text), style);
+      }
+    }
+  };
+
+  return { runs, walk, pushHtml };
+}
+
+function sameStyle(a, b) {
+  for (const key of ['bold', 'italic', 'strike', 'code', 'sup', 'sub', 'href']) {
+    if ((a[key] || false) !== (b[key] || false)) return false;
+  }
+  return true;
+}
+
+function inlineRuns(tokens) {
+  const collector = createRunCollector();
+  collector.walk(tokens, {});
+  return trimRuns(collector.runs);
+}
+
+function htmlRuns(html) {
+  const collector = createRunCollector();
+  collector.pushHtml(html, {});
+  return trimRuns(collector.runs);
+}
+
+/**
+ * Drops the whitespace at both ends of a block: all that a block of bare tags
+ * leaves, or what stood before a tag whose content was skipped.
+ */
+function trimRuns(runs) {
+  const blank = run => run.text !== undefined && run.text.trim() === '';
+  while (runs.length && blank(runs[0])) runs.shift();
+  while (runs.length && blank(runs[runs.length - 1])) runs.pop();
+  const first = runs[0];
+  const last = runs[runs.length - 1];
+  if (first && first.text !== undefined) first.text = first.text.replace(/^\s+/, '');
+  if (last && last.text !== undefined) last.text = last.text.replace(/\s+$/, '');
+  return runs;
+}
+
+/**
+ * Whether a link still means something once the document is a single file:
+ * a web or mail address does, a path to a neighbouring file does not.
+ * @param {string} href
+ * @returns {boolean}
+ */
+function isPortableLink(href) {
+  return /^(https?:|mailto:|tel:|ftp:)/i.test(href || '');
+}
+
+/** The text of a list of runs, for slugs, titles and alt text. */
+function plainText(runs) {
+  return runs.map(run => (run.text !== undefined ? run.text : run.image ? run.image.alt : ' ')).join('');
+}
+
+function toBlocks(tokens, slug) {
+  const blocks = [];
+  for (const token of tokens || []) {
+    switch (token.type) {
+      case 'space':
+      case 'def':
+        break;
+      case 'heading': {
+        const runs = inlineRuns(token.tokens);
+        blocks.push({ type: 'heading', depth: token.depth, id: slug(plainText(runs), `heading-${blocks.length + 1}`), runs });
+        break;
+      }
+      case 'code':
+        blocks.push({ type: 'code', lang: (token.lang || '').trim().split(/\s+/)[0], text: token.text || '' });
+        break;
+      case 'blockquote':
+        blocks.push({ type: 'quote', blocks: toBlocks(token.tokens, slug) });
+        break;
+      case 'list':
+        blocks.push({
+          type: 'list',
+          ordered: Boolean(token.ordered),
+          start: Number.isInteger(token.start) ? token.start : 1,
+          items: token.items.map(item => ({
+            checked: item.task ? Boolean(item.checked) : null,
+            blocks: toBlocks(item.tokens, slug)
+          }))
+        });
+        break;
+      case 'table': {
+        const cell = (source, index) => ({ align: token.align[index] || null, runs: inlineRuns(source.tokens) });
+        blocks.push({ type: 'table', header: token.header.map(cell), rows: token.rows.map(row => row.map(cell)) });
+        break;
+      }
+      case 'hr':
+        blocks.push({ type: 'rule' });
+        break;
+      case 'html': {
+        if (/class=["'][^"']*\bpage-break\b/.test(token.text)) {
+          blocks.push({ type: 'pageBreak' });
+        } else if (/<section class="footnotes">/.test(token.text)) {
+          // The notes follow as an ordinary numbered list; a rule sets them apart.
+          blocks.push({ type: 'rule' });
+        } else {
+          const runs = htmlRuns(token.text);
+          if (runs.length) blocks.push({ type: 'paragraph', runs });
+        }
+        break;
+      }
+      default: {
+        const runs = inlineRuns(token.tokens || [token]);
+        if (runs.length) blocks.push({ type: 'paragraph', runs });
+      }
+    }
+  }
+  return blocks;
+}
+
+/**
+ * Reads a Markdown document into its metadata and blocks.
+ * @param {string} rawMarkdown
+ * @param {Object} [options] The converter's options; front matter fills in what they leave out
+ * @returns {{ meta: Object, blocks: Object[], settings: Object }}
+ */
+function buildDocument(rawMarkdown = '', options = {}) {
+  const { data: frontMatter, content } = parseFrontMatter(rawMarkdown);
+  const titleMatch = content.match(/^#\s+(.+)$/m);
+  const meta = {
+    title: frontMatter.title || options.title || (titleMatch ? titleMatch[1].trim() : 'Converted Document'),
+    subtitle: frontMatter.subtitle || options.subtitle || '',
+    author: frontMatter.author || options.author || '',
+    date: frontMatter.date || options.date || '',
+    language: frontMatter.lang || frontMatter.language || options.language || 'en'
+  };
+  const settings = {
+    font: options.font || frontMatter.font || 'Inter',
+    pageSize: options.pageSize || frontMatter.pageSize || 'A4',
+    orientation: options.orientation || frontMatter.orientation || (frontMatter.landscape ? 'landscape' : 'portrait'),
+    margin: options.margin || frontMatter.margin || '14mm 12mm 16mm 12mm',
+    toc: options.toc !== undefined ? options.toc : Boolean(frontMatter.toc),
+    cover: options.cover !== undefined ? options.cover : Boolean(frontMatter.cover),
+    highlight: options.highlight !== undefined ? options.highlight : frontMatter.highlight !== false
+  };
+
+  const processed = preprocessMarkdown(applyFootnotes(content));
+  const tokens = marked.lexer(processed, { gfm: true, breaks: true });
+  return { meta, blocks: toBlocks(tokens, createSlugger()), settings };
+}
+
+/** Every heading of the document, at any depth of nesting, in order. */
+function collectHeadings(blocks, found = []) {
+  for (const block of blocks) {
+    if (block.type === 'heading') found.push(block);
+    else if (block.type === 'quote') collectHeadings(block.blocks, found);
+    else if (block.type === 'list') block.items.forEach(item => collectHeadings(item.blocks, found));
+  }
+  return found;
+}
+
+module.exports = {
+  buildDocument,
+  collectHeadings,
+  decodeEntities,
+  isPortableLink,
+  plainText
+};