md-pdf-studio 2.1.0 → 2.3.0

package/src/core/index.js

@@ -3,13 +3,40 @@ const path = require('path');
 const { parseMarkdownToHtml } = require('./parser');
 const { renderHtmlToPdf } = require('../browser/renderer');
 const { resolvePath } = require('./utils');
+const { expandIncludes } = require('./include');
+const { markdownToDocx } = require('./docx');
+const { markdownToEpub } = require('./epub');
+
+const FORMATS = ['pdf', 'html', 'docx', 'epub'];
+
+/**
+ * Where the page the browser prints is written: beside the Markdown file, so
+ * that its relative pictures and links resolve as they do in the source, also
+ * when the PDF goes to another folder. Falls back to the PDF's folder when the
+ * source's folder cannot be written to.
+ * @param {string} absInputPath
+ * @param {string} absOutputPath
+ * @returns {string}
+ */
+function temporaryHtmlPath(absInputPath, absOutputPath) {
+  const name = `_temp_${Date.now()}_${Math.random().toString(36).substring(7)}.html`;
+  const sourceDir = path.dirname(absInputPath);
+  try {
+    fs.accessSync(sourceDir, fs.constants.W_OK);
+    return path.join(sourceDir, name);
+  } catch (_) {
+    return path.join(path.dirname(absOutputPath), name);
+  }
+}
 
 /**
- * Main function to convert Markdown file to PDF
+ * Main function to convert a Markdown file: to PDF by default, or to the
+ * format named in `options.format` (`html`, `docx`, `epub`)
  * @param {string} inputPath Path to source .md file
- * @param {string} [outputPath] Path to target .pdf file
+ * @param {string} [outputPath] Path to the target file
  * @param {Object} [options] Conversion options
- * @returns {Promise<{ htmlPath: string, pdfPath: string }>}
+ * @returns {Promise<{ outputPath: string, htmlPath: string, pdfPath: string, includedFiles: string[] }>}
+ *   `outputPath` is the file that was asked for, whatever its format
  */
 async function convertMarkdownToPdf(inputPath, outputPath, options = {}) {
   const absInputPath = resolvePath(inputPath);
@@ -19,6 +46,9 @@ async function convertMarkdownToPdf(inputPath, outputPath, options = {}) {
   }
 
   const format = options.format ? options.format.toLowerCase() : 'pdf';
+  if (!FORMATS.includes(format)) {
+    throw new Error(`Unknown output format "${options.format}". Use one of: ${FORMATS.join(', ')}`);
+  }
 
   // Derive output path if omitted
   let absOutputPath;
@@ -29,8 +59,24 @@ async function convertMarkdownToPdf(inputPath, outputPath, options = {}) {
     absOutputPath = path.join(parsed.dir, `${parsed.name}.${format}`);
   }
 
-  // Read Markdown
-  const markdownContent = fs.readFileSync(absInputPath, 'utf8');
+  // Read Markdown, pulling in the files it imports with `@import "path"`
+  let markdownContent = fs.readFileSync(absInputPath, 'utf8');
+  let includedFiles = [];
+  if (options.include !== false) {
+    ({ content: markdownContent, files: includedFiles } = expandIncludes(markdownContent, absInputPath));
+  }
+
+  // Word and EPUB are written from the Markdown itself, without a browser
+  if (format === 'docx' || format === 'epub') {
+    const build = format === 'docx' ? markdownToDocx : markdownToEpub;
+    fs.writeFileSync(absOutputPath, build(markdownContent, { ...options, baseDir: path.dirname(absInputPath) }));
+    return {
+      outputPath: absOutputPath,
+      htmlPath: null,
+      pdfPath: null,
+      includedFiles
+    };
+  }
 
   // Parse to HTML
   const htmlContent = parseMarkdownToHtml(markdownContent, options);
@@ -38,13 +84,15 @@ async function convertMarkdownToPdf(inputPath, outputPath, options = {}) {
   if (format === 'html') {
     fs.writeFileSync(absOutputPath, htmlContent, 'utf8');
     return {
+      outputPath: absOutputPath,
       htmlPath: absOutputPath,
-      pdfPath: null
+      pdfPath: null,
+      includedFiles
     };
   }
 
   // Temporary HTML path
-  const tempHtmlPath = path.join(path.parse(absOutputPath).dir, `_temp_${Date.now()}_${Math.random().toString(36).substring(7)}.html`);
+  const tempHtmlPath = temporaryHtmlPath(absInputPath, absOutputPath);
 
   try {
     // Save temporary HTML file
@@ -61,8 +109,10 @@ async function convertMarkdownToPdf(inputPath, outputPath, options = {}) {
     }
 
     return {
+      outputPath: absOutputPath,
       htmlPath: tempHtmlPath,
-      pdfPath: absOutputPath
+      pdfPath: absOutputPath,
+      includedFiles
     };
   } catch (error) {
     // Clean up on failure
@@ -75,6 +125,10 @@ async function convertMarkdownToPdf(inputPath, outputPath, options = {}) {
 
 module.exports = {
   convertMarkdownToPdf,
+  expandIncludes,
+  markdownToDocx,
+  markdownToEpub,
   parseMarkdownToHtml,
-  renderHtmlToPdf
+  renderHtmlToPdf,
+  temporaryHtmlPath
 };

package/src/core/parser.js

@@ -10,6 +10,7 @@ const {
   escapeHtml 
 } = require('./utils');
 const { getHtmlTemplate } = require('./templates');
+const { applyFootnotes } = require('./footnotes');
 
 /**
  * Builds marked custom renderer for diagrams, UI mockups, and headings
@@ -100,8 +101,8 @@ function parseMarkdownToHtml(rawMarkdownContent, options = {}) {
     cssFile: options.cssFile || frontMatter.cssFile || frontMatter.css
   };
 
-  // 3. Preprocess Markdown (LaTeX, pagebreaks, alerts)
-  const processedMd = preprocessMarkdown(markdownContent);
+  // 3. Preprocess Markdown (footnotes, LaTeX, pagebreaks, alerts)
+  const processedMd = preprocessMarkdown(applyFootnotes(markdownContent));
 
   // 4. Generate TOC & Cover Page
   let tocHtml = '';

package/src/core/templates.js

@@ -99,6 +99,12 @@ function getHtmlTemplate({ title, author = '', bodyHtml, options = {} }) {
       page-break-after: always;
     }
 
+    .footnote-ref { font-size: 0.75em; line-height: 0; }
+    .footnote-ref a, .footnote-backref { text-decoration: none; }
+    .footnotes { margin-top: 28px; padding-top: 10px; border-top: 1px solid currentColor; font-size: 0.85em; break-inside: avoid-page; }
+    .footnotes ol { margin: 0; padding-left: 1.6em; }
+    .footnotes li { margin: 3px 0; }
+
     img {
       max-width: 100% !important;
       height: auto !important;

package/src/core/utils.js

@@ -18,11 +18,11 @@ function preprocessMarkdown(mdContent = '') {
 
   return mdContent
     // GitHub Callouts / Alerts
-    .replace(/^>\s*\[!NOTE\]\s*\r?\n/gm, '> **ℹ️ NOTE:** ')
-    .replace(/^>\s*\[!TIP\]\s*\r?\n/gm, '> **💡 TIP:** ')
-    .replace(/^>\s*\[!WARNING\]\s*\r?\n/gm, '> **⚠️ WARNING:** ')
-    .replace(/^>\s*\[!IMPORTANT\]\s*\r?\n/gm, '> **❗ IMPORTANT:** ')
-    .replace(/^>\s*\[!CAUTION\]\s*\r?\n/gm, '> **🚫 CAUTION:** ')
+    .replace(/^>[ \t]*\[!NOTE\][ \t]*(?:\r?\n>[ \t]?)?/gm, '> **ℹ️ NOTE:** ')
+    .replace(/^>[ \t]*\[!TIP\][ \t]*(?:\r?\n>[ \t]?)?/gm, '> **💡 TIP:** ')
+    .replace(/^>[ \t]*\[!WARNING\][ \t]*(?:\r?\n>[ \t]?)?/gm, '> **⚠️ WARNING:** ')
+    .replace(/^>[ \t]*\[!IMPORTANT\][ \t]*(?:\r?\n>[ \t]?)?/gm, '> **❗ IMPORTANT:** ')
+    .replace(/^>[ \t]*\[!CAUTION\][ \t]*(?:\r?\n>[ \t]?)?/gm, '> **🚫 CAUTION:** ')
     // Pagebreaks
     .replace(/<!--\s*page-?break\s*-->/gi, '<div class="page-break"></div>')
     .replace(/\\pagebreak/gi, '<div class="page-break"></div>')

package/src/core/zip.js

@@ -0,0 +1,77 @@
+const zlib = require('zlib');
+
+/**
+ * A ZIP archive writer, enough for the two container formats built on ZIP
+ * that this tool exports: DOCX and EPUB.
+ *
+ * Entries are written in the order given, which EPUB relies on: its
+ * `mimetype` entry has to come first and uncompressed. Timestamps are fixed,
+ * so the same input gives the same bytes.
+ */
+
+// 1980-01-01 00:00:00, the earliest date the format can express.
+const DOS_TIME = 0;
+const DOS_DATE = (0 << 9) | (1 << 5) | 1;
+
+/**
+ * @param {{ name: string, data: Buffer | string, store?: boolean }[]} entries
+ * @returns {Buffer}
+ */
+function createZip(entries) {
+  const localParts = [];
+  const centralParts = [];
+  let offset = 0;
+
+  for (const entry of entries) {
+    const name = Buffer.from(entry.name, 'utf8');
+    const data = Buffer.isBuffer(entry.data) ? entry.data : Buffer.from(entry.data, 'utf8');
+    const compressed = entry.store ? data : zlib.deflateRawSync(data, { level: 9 });
+    const method = entry.store ? 0 : 8;
+    const crc = zlib.crc32(data);
+
+    const local = Buffer.alloc(30);
+    local.writeUInt32LE(0x04034b50, 0);
+    local.writeUInt16LE(20, 4); // version needed
+    local.writeUInt16LE(0x0800, 6); // names are UTF-8
+    local.writeUInt16LE(method, 8);
+    local.writeUInt16LE(DOS_TIME, 10);
+    local.writeUInt16LE(DOS_DATE, 12);
+    local.writeUInt32LE(crc, 14);
+    local.writeUInt32LE(compressed.length, 18);
+    local.writeUInt32LE(data.length, 22);
+    local.writeUInt16LE(name.length, 26);
+    local.writeUInt16LE(0, 28);
+
+    const central = Buffer.alloc(46);
+    central.writeUInt32LE(0x02014b50, 0);
+    central.writeUInt16LE(20, 4); // version made by
+    central.writeUInt16LE(20, 6); // version needed
+    central.writeUInt16LE(0x0800, 8);
+    central.writeUInt16LE(method, 10);
+    central.writeUInt16LE(DOS_TIME, 12);
+    central.writeUInt16LE(DOS_DATE, 14);
+    central.writeUInt32LE(crc, 16);
+    central.writeUInt32LE(compressed.length, 20);
+    central.writeUInt32LE(data.length, 24);
+    central.writeUInt16LE(name.length, 28);
+    central.writeUInt32LE(offset, 42);
+
+    localParts.push(local, name, compressed);
+    centralParts.push(central, name);
+    offset += local.length + name.length + compressed.length;
+  }
+
+  const centralSize = centralParts.reduce((size, part) => size + part.length, 0);
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(0x06054b50, 0);
+  end.writeUInt16LE(entries.length, 8);
+  end.writeUInt16LE(entries.length, 10);
+  end.writeUInt32LE(centralSize, 12);
+  end.writeUInt32LE(offset, 16);
+
+  return Buffer.concat([...localParts, ...centralParts, end]);
+}
+
+module.exports = {
+  createZip
+};