mirror of
https://github.com/amitwh/markdown-converter.git
synced 2026-08-02 18:10:18 +05:30
amitwhandClaude
478b404135
Major Features: - Template-based Word export with custom template selection - File menu option to select and persist Word templates - Table styling with orange headers and white data rows - ASCII art and flowchart rendering with perfect alignment - Red-colored arrows in flowcharts for enhanced visibility - Markdown numbering stripped from headings and lists Technical Improvements: - Enhanced ASCII art detection for arrows and flowchart patterns - Line-by-line rendering with no-wrap properties - Arrow character detection and red coloring (↓→←↑) - Template path persistence across sessions - Word XML manipulation using PizZip Files Modified: - src/wordTemplateExporter.js: Enhanced ASCII art rendering, table styling - src/main.js: Template selection function and menu integration - CLAUDE.md: Comprehensive v1.7.9 documentation - package.json: Version bump to 1.7.9 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
619 lines
21 KiB
JavaScript
619 lines
21 KiB
JavaScript
/**
|
|
* Word Template Exporter
|
|
* Loads word_template.docx, preserves first 2 pages (cover + TOC),
|
|
* and adds markdown content starting from page 3 using template styles
|
|
*/
|
|
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const PizZip = require('pizzip');
|
|
const Docx = require('docx4js').default;
|
|
|
|
class WordTemplateExporter {
|
|
constructor(templatePath) {
|
|
this.templatePath = templatePath || path.join(__dirname, '../word_template.docx');
|
|
}
|
|
|
|
/**
|
|
* Convert markdown to Word document using template
|
|
*/
|
|
async convert(markdownContent, outputPath) {
|
|
try {
|
|
// Load template
|
|
const templateBuffer = fs.readFileSync(this.templatePath);
|
|
const zip = new PizZip(templateBuffer);
|
|
|
|
// Extract document.xml
|
|
const documentXml = zip.file('word/document.xml').asText();
|
|
|
|
// Parse markdown and generate Word XML
|
|
const newContentXml = this.markdownToWordXml(markdownContent);
|
|
|
|
// Insert new content after page 2 (after the section break)
|
|
const modifiedXml = this.insertContentAfterPage2(documentXml, newContentXml);
|
|
|
|
// Update the zip with modified XML
|
|
zip.file('word/document.xml', modifiedXml);
|
|
|
|
// Generate and save the new document
|
|
const newDocBuffer = zip.generate({ type: 'nodebuffer' });
|
|
fs.writeFileSync(outputPath, newDocBuffer);
|
|
|
|
return outputPath;
|
|
} catch (error) {
|
|
console.error('Error in Word export:', error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Insert markdown content after page 2 in the document
|
|
*/
|
|
insertContentAfterPage2(documentXml, newContentXml) {
|
|
// Find the last section break (after page 2)
|
|
// Look for the section properties tag that marks page breaks
|
|
const sectionBreakRegex = /<w:sectPr[^>]*>[\s\S]*?<\/w:sectPr>/g;
|
|
const matches = [...documentXml.matchAll(sectionBreakRegex)];
|
|
|
|
if (matches.length >= 2) {
|
|
// Insert after the 2nd section break
|
|
const insertPoint = matches[1].index + matches[1][0].length;
|
|
return documentXml.slice(0, insertPoint) + newContentXml + documentXml.slice(insertPoint);
|
|
} else {
|
|
// If no section breaks found, insert before closing body tag
|
|
return documentXml.replace('</w:body>', newContentXml + '</w:body>');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Convert markdown to Word XML format
|
|
*/
|
|
markdownToWordXml(markdown) {
|
|
const lines = markdown.split('\n');
|
|
let xml = '';
|
|
let inCodeBlock = false;
|
|
let codeLines = [];
|
|
|
|
for (let i = 0; i < lines.length; i++) {
|
|
const line = lines[i];
|
|
|
|
// Handle code blocks
|
|
if (line.trim().startsWith('```')) {
|
|
if (inCodeBlock) {
|
|
// End code block
|
|
xml += this.createCodeBlockXml(codeLines.join('\n'));
|
|
codeLines = [];
|
|
inCodeBlock = false;
|
|
} else {
|
|
inCodeBlock = true;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (inCodeBlock) {
|
|
codeLines.push(line);
|
|
continue;
|
|
}
|
|
|
|
// Empty lines
|
|
if (!line.trim()) {
|
|
xml += '<w:p><w:pPr></w:pPr></w:p>';
|
|
continue;
|
|
}
|
|
|
|
// Tables - detect table lines
|
|
if (line.includes('|') && line.trim().startsWith('|')) {
|
|
const tableLines = [line];
|
|
i++;
|
|
// Collect all consecutive table lines
|
|
while (i < lines.length && lines[i].includes('|')) {
|
|
tableLines.push(lines[i]);
|
|
i++;
|
|
}
|
|
i--; // Back up one line
|
|
xml += this.createTableXml(tableLines);
|
|
continue;
|
|
}
|
|
|
|
// ASCII flowcharts/diagrams - detect box drawing characters
|
|
if (this.isAsciiArt(line)) {
|
|
const asciiLines = [line];
|
|
i++;
|
|
// Collect all consecutive ASCII art lines
|
|
while (i < lines.length && (this.isAsciiArt(lines[i]) || !lines[i].trim())) {
|
|
asciiLines.push(lines[i]);
|
|
i++;
|
|
if (i < lines.length && lines[i].trim() && !this.isAsciiArt(lines[i])) {
|
|
break;
|
|
}
|
|
}
|
|
i--; // Back up one line
|
|
xml += this.createAsciiArtXml(asciiLines.join('\n'));
|
|
continue;
|
|
}
|
|
|
|
// Headings - strip markdown numbering
|
|
if (line.trim().startsWith('#')) {
|
|
const level = (line.match(/^#+/) || [''])[0].length;
|
|
let text = line.replace(/^#+\s*/, '').trim();
|
|
// Remove markdown numbering like "1.1 Title" -> "Title"
|
|
text = text.replace(/^\d+(\.\d+)*\.?\s+/, '');
|
|
xml += this.createHeadingXml(text, level);
|
|
continue;
|
|
}
|
|
|
|
// Blockquotes
|
|
if (line.trim().startsWith('>')) {
|
|
const text = line.replace(/^>\s*/, '').trim();
|
|
xml += this.createQuoteXml(text);
|
|
continue;
|
|
}
|
|
|
|
// Ordered lists - strip markdown numbering, use template numbering
|
|
if (/^\s*\d+\.\s+/.test(line)) {
|
|
const text = line.replace(/^\s*\d+\.\s+/, '');
|
|
xml += this.createListItemXml(text, true);
|
|
continue;
|
|
}
|
|
|
|
// Unordered lists
|
|
if (/^\s*[-*+]\s+/.test(line)) {
|
|
const text = line.replace(/^\s*[-*+]\s+/, '');
|
|
xml += this.createListItemXml(text, false);
|
|
continue;
|
|
}
|
|
|
|
// Horizontal rule
|
|
if (/^[-*_]{3,}$/.test(line.trim())) {
|
|
xml += this.createHorizontalRuleXml();
|
|
continue;
|
|
}
|
|
|
|
// Normal paragraph
|
|
xml += this.createParagraphXml(line);
|
|
}
|
|
|
|
return xml;
|
|
}
|
|
|
|
/**
|
|
* Create heading XML using template styles
|
|
*/
|
|
createHeadingXml(text, level) {
|
|
const styleName = `Heading${level}`;
|
|
const runs = this.parseInlineFormatting(text);
|
|
|
|
return `<w:p>
|
|
<w:pPr>
|
|
<w:pStyle w:val="${styleName}"/>
|
|
</w:pPr>
|
|
${runs}
|
|
</w:p>`;
|
|
}
|
|
|
|
/**
|
|
* Create paragraph XML with Normal style
|
|
*/
|
|
createParagraphXml(text) {
|
|
const runs = this.parseInlineFormatting(text);
|
|
|
|
return `<w:p>
|
|
<w:pPr>
|
|
<w:pStyle w:val="Normal"/>
|
|
</w:pPr>
|
|
${runs}
|
|
</w:p>`;
|
|
}
|
|
|
|
/**
|
|
* Create quote XML
|
|
*/
|
|
createQuoteXml(text) {
|
|
const runs = this.parseInlineFormatting(text);
|
|
|
|
return `<w:p>
|
|
<w:pPr>
|
|
<w:pStyle w:val="Quote"/>
|
|
</w:pPr>
|
|
${runs}
|
|
</w:p>`;
|
|
}
|
|
|
|
/**
|
|
* Create list item XML using template numbering
|
|
*/
|
|
createListItemXml(text, numbered) {
|
|
const runs = this.parseInlineFormatting(text);
|
|
const numId = numbered ? '1' : '2'; // Template numbering IDs
|
|
|
|
return `<w:p>
|
|
<w:pPr>
|
|
<w:pStyle w:val="${numbered ? 'ListNumber' : 'ListBullet'}"/>
|
|
<w:numPr>
|
|
<w:ilvl w:val="0"/>
|
|
<w:numId w:val="${numId}"/>
|
|
</w:numPr>
|
|
</w:pPr>
|
|
${runs}
|
|
</w:p>`;
|
|
}
|
|
|
|
/**
|
|
* Create code block XML
|
|
*/
|
|
createCodeBlockXml(code) {
|
|
const escapedCode = this.escapeXml(code);
|
|
|
|
return `<w:p>
|
|
<w:pPr>
|
|
<w:pStyle w:val="Code"/>
|
|
</w:pPr>
|
|
<w:r>
|
|
<w:rPr>
|
|
<w:rFonts w:ascii="Consolas" w:hAnsi="Consolas"/>
|
|
<w:sz w:val="18"/>
|
|
</w:rPr>
|
|
<w:t xml:space="preserve">${escapedCode}</w:t>
|
|
</w:r>
|
|
</w:p>`;
|
|
}
|
|
|
|
/**
|
|
* Create horizontal rule XML
|
|
*/
|
|
createHorizontalRuleXml() {
|
|
return `<w:p>
|
|
<w:pPr>
|
|
<w:pBdr>
|
|
<w:bottom w:val="single" w:sz="6" w:space="1" w:color="auto"/>
|
|
</w:pBdr>
|
|
</w:pPr>
|
|
</w:p>`;
|
|
}
|
|
|
|
/**
|
|
* Create table XML from markdown table lines with template styling
|
|
*/
|
|
createTableXml(tableLines) {
|
|
// Parse table
|
|
const rows = [];
|
|
for (const line of tableLines) {
|
|
// Skip separator lines (e.g., |---|---|)
|
|
if (/^\s*\|[\s\-:]+\|\s*$/.test(line)) {
|
|
continue;
|
|
}
|
|
// Split by | and trim
|
|
const cells = line.split('|').filter(cell => cell.trim()).map(cell => cell.trim());
|
|
if (cells.length > 0) {
|
|
rows.push(cells);
|
|
}
|
|
}
|
|
|
|
if (rows.length === 0) return '';
|
|
|
|
// Calculate number of columns
|
|
const numCols = Math.max(...rows.map(row => row.length));
|
|
|
|
// Build table XML
|
|
let tableXml = '<w:tbl>';
|
|
|
|
// Table properties - use template table style
|
|
tableXml += `<w:tblPr>
|
|
<w:tblStyle w:val="TableGrid"/>
|
|
<w:tblW w:w="5000" w:type="pct"/>
|
|
<w:tblLook w:val="04A0" w:firstRow="1" w:lastRow="0" w:firstColumn="0" w:lastColumn="0" w:noHBand="0" w:noVBand="1"/>
|
|
<w:tblBorders>
|
|
<w:top w:val="single" w:sz="8" w:space="0" w:color="F58220"/>
|
|
<w:left w:val="single" w:sz="8" w:space="0" w:color="F58220"/>
|
|
<w:bottom w:val="single" w:sz="8" w:space="0" w:color="F58220"/>
|
|
<w:right w:val="single" w:sz="8" w:space="0" w:color="F58220"/>
|
|
<w:insideH w:val="single" w:sz="8" w:space="0" w:color="F58220"/>
|
|
<w:insideV w:val="single" w:sz="8" w:space="0" w:color="F58220"/>
|
|
</w:tblBorders>
|
|
</w:tblPr>`;
|
|
|
|
// Table grid
|
|
tableXml += '<w:tblGrid>';
|
|
for (let i = 0; i < numCols; i++) {
|
|
tableXml += '<w:gridCol/>';
|
|
}
|
|
tableXml += '</w:tblGrid>';
|
|
|
|
// Table rows
|
|
rows.forEach((rowCells, rowIndex) => {
|
|
const isHeader = rowIndex === 0;
|
|
const isEvenRow = rowIndex % 2 === 0;
|
|
|
|
tableXml += '<w:tr>';
|
|
|
|
// Pad row to have same number of columns
|
|
while (rowCells.length < numCols) {
|
|
rowCells.push('');
|
|
}
|
|
|
|
rowCells.forEach((cellText, colIndex) => {
|
|
tableXml += '<w:tc>';
|
|
tableXml += '<w:tcPr>';
|
|
|
|
// Cell shading - orange for header, white for data rows
|
|
if (isHeader) {
|
|
tableXml += '<w:shd w:val="clear" w:color="FFFFFF" w:fill="F58220"/>';
|
|
}
|
|
|
|
// Cell borders
|
|
tableXml += '<w:tcBorders>' +
|
|
'<w:top w:val="single" w:sz="8" w:space="0" w:color="F58220"/>' +
|
|
'<w:left w:val="single" w:sz="8" w:space="0" w:color="F58220"/>' +
|
|
'<w:bottom w:val="single" w:sz="8" w:space="0" w:color="F58220"/>' +
|
|
'<w:right w:val="single" w:sz="8" w:space="0" w:color="F58220"/>' +
|
|
'</w:tcBorders>';
|
|
tableXml += '</w:tcPr>';
|
|
|
|
// Cell content
|
|
tableXml += '<w:p>';
|
|
tableXml += '<w:pPr>';
|
|
tableXml += '<w:spacing w:before="100" w:after="100"/>';
|
|
tableXml += '</w:pPr>';
|
|
|
|
const runs = this.parseInlineFormatting(cellText);
|
|
|
|
if (isHeader) {
|
|
// Header: bold white text
|
|
tableXml += runs.replace(/<w:rPr>/g, '<w:rPr><w:b/><w:color w:val="FFFFFF"/>');
|
|
} else {
|
|
// Data rows: normal black text
|
|
tableXml += runs;
|
|
}
|
|
|
|
tableXml += '</w:p>';
|
|
tableXml += '</w:tc>';
|
|
});
|
|
|
|
tableXml += '</w:tr>';
|
|
});
|
|
|
|
tableXml += '</w:tbl>';
|
|
|
|
return tableXml;
|
|
}
|
|
|
|
/**
|
|
* Detect if line contains ASCII art/flowchart characters
|
|
*/
|
|
isAsciiArt(line) {
|
|
// Don't treat markdown tables as ASCII art
|
|
if (line.trim().startsWith('|') && line.trim().endsWith('|')) {
|
|
return false;
|
|
}
|
|
|
|
// Common ASCII art characters
|
|
const asciiArtChars = [
|
|
'─', '│', '┌', '┐', '└', '┘', '├', '┤', '┬', '┴', '┼', // Box drawing
|
|
'═', '║', '╔', '╗', '╚', '╝', '╠', '╣', '╦', '╩', '╬', // Double box
|
|
'▲', '▼', '◄', '►', '♦', '●', '○', '■', '□', // Shapes
|
|
'↓', '→', '←', '↑', // Arrows
|
|
];
|
|
|
|
// Check for box drawing characters
|
|
if (asciiArtChars.some(char => line.includes(char))) {
|
|
return true;
|
|
}
|
|
|
|
// Check for ASCII box patterns with regular characters
|
|
const asciiPatterns = [
|
|
/^\s*\+[-=_]+\+/, // +-----+
|
|
/^\s*\|[-=_]{3,}\|/, // |-----|
|
|
/^\s*[-=_]{5,}$/, // -----
|
|
/^\s*\([A-Z][a-z]+\)\s*\|\|/, // (Deformable) ||
|
|
/^\s*\|\s+[A-Z\s]+[-:]\s+[A-Z]/, // | TILE ADHESIVE - TYPE
|
|
/^\s*\|\s*\[[^\]]+\]/, // | [BIS Mark / CE Mark]
|
|
/^\s*\|\s{2,}\w+.*\|\|/, // || text ||
|
|
/^\s*\[[^\]]+\]/, // [Step in brackets]
|
|
];
|
|
|
|
return asciiPatterns.some(pattern => pattern.test(line));
|
|
}
|
|
|
|
/**
|
|
* Create ASCII art XML with monospace font
|
|
*/
|
|
createAsciiArtXml(asciiContent) {
|
|
// Split ASCII art into individual lines and create a paragraph for each
|
|
const lines = asciiContent.split('\n');
|
|
let xml = '';
|
|
|
|
lines.forEach((line, index) => {
|
|
xml += `<w:p>
|
|
<w:pPr>
|
|
<w:spacing w:before="${index === 0 ? '120' : '0'}" w:after="${index === lines.length - 1 ? '120' : '0'}" w:line="240" w:lineRule="exact"/>
|
|
<w:ind w:left="0" w:right="0"/>
|
|
<w:jc w:val="left"/>
|
|
<w:keepLines/>
|
|
<w:wordWrap w:val="0"/>
|
|
</w:pPr>`;
|
|
|
|
// Check if line contains arrow characters and color them red
|
|
const arrowChars = ['↓', '→', '←', '↑', '▼', '►', '◄', '▲'];
|
|
const hasArrow = arrowChars.some(arrow => line.includes(arrow));
|
|
|
|
if (hasArrow) {
|
|
// Split line into parts and color arrows red
|
|
let remainingLine = line;
|
|
let processedText = '';
|
|
|
|
while (remainingLine.length > 0) {
|
|
let foundArrow = false;
|
|
let arrowIndex = -1;
|
|
let foundArrowChar = '';
|
|
|
|
// Find the first arrow in the remaining text
|
|
for (const arrow of arrowChars) {
|
|
const idx = remainingLine.indexOf(arrow);
|
|
if (idx !== -1 && (arrowIndex === -1 || idx < arrowIndex)) {
|
|
arrowIndex = idx;
|
|
foundArrowChar = arrow;
|
|
foundArrow = true;
|
|
}
|
|
}
|
|
|
|
if (foundArrow) {
|
|
// Add text before arrow (if any)
|
|
if (arrowIndex > 0) {
|
|
const beforeArrow = this.escapeXml(remainingLine.substring(0, arrowIndex));
|
|
xml += `<w:r>
|
|
<w:rPr>
|
|
<w:rFonts w:ascii="Consolas" w:hAnsi="Consolas" w:cs="Consolas"/>
|
|
<w:sz w:val="16"/>
|
|
<w:szCs w:val="16"/>
|
|
<w:shd w:val="clear" w:color="auto" w:fill="F5F5F5"/>
|
|
<w:noProof/>
|
|
</w:rPr>
|
|
<w:t xml:space="preserve">${beforeArrow}</w:t>
|
|
</w:r>`;
|
|
}
|
|
|
|
// Add arrow in red
|
|
const escapedArrow = this.escapeXml(foundArrowChar);
|
|
xml += `<w:r>
|
|
<w:rPr>
|
|
<w:rFonts w:ascii="Consolas" w:hAnsi="Consolas" w:cs="Consolas"/>
|
|
<w:sz w:val="16"/>
|
|
<w:szCs w:val="16"/>
|
|
<w:color w:val="FF0000"/>
|
|
<w:shd w:val="clear" w:color="auto" w:fill="F5F5F5"/>
|
|
<w:noProof/>
|
|
</w:rPr>
|
|
<w:t xml:space="preserve">${escapedArrow}</w:t>
|
|
</w:r>`;
|
|
|
|
// Continue with remaining text
|
|
remainingLine = remainingLine.substring(arrowIndex + foundArrowChar.length);
|
|
} else {
|
|
// No more arrows, add remaining text
|
|
const escapedRemaining = this.escapeXml(remainingLine);
|
|
xml += `<w:r>
|
|
<w:rPr>
|
|
<w:rFonts w:ascii="Consolas" w:hAnsi="Consolas" w:cs="Consolas"/>
|
|
<w:sz w:val="16"/>
|
|
<w:szCs w:val="16"/>
|
|
<w:shd w:val="clear" w:color="auto" w:fill="F5F5F5"/>
|
|
<w:noProof/>
|
|
</w:rPr>
|
|
<w:t xml:space="preserve">${escapedRemaining}</w:t>
|
|
</w:r>`;
|
|
remainingLine = '';
|
|
}
|
|
}
|
|
} else {
|
|
// No arrows, just add the line normally
|
|
const escapedLine = this.escapeXml(line);
|
|
xml += `<w:r>
|
|
<w:rPr>
|
|
<w:rFonts w:ascii="Consolas" w:hAnsi="Consolas" w:cs="Consolas"/>
|
|
<w:sz w:val="16"/>
|
|
<w:szCs w:val="16"/>
|
|
<w:shd w:val="clear" w:color="auto" w:fill="F5F5F5"/>
|
|
<w:noProof/>
|
|
</w:rPr>
|
|
<w:t xml:space="preserve">${escapedLine}</w:t>
|
|
</w:r>`;
|
|
}
|
|
|
|
xml += `</w:p>`;
|
|
});
|
|
|
|
return xml;
|
|
}
|
|
|
|
/**
|
|
* Parse inline formatting (bold, italic, code)
|
|
*/
|
|
parseInlineFormatting(text) {
|
|
let xml = '';
|
|
let pos = 0;
|
|
|
|
// Patterns for inline formatting
|
|
const patterns = [
|
|
{ regex: /\*\*\*(.+?)\*\*\*/g, bold: true, italic: true },
|
|
{ regex: /\*\*(.+?)\*\*/g, bold: true },
|
|
{ regex: /\*(.+?)\*/g, italic: true },
|
|
{ regex: /`(.+?)`/g, code: true }
|
|
];
|
|
|
|
// Simple approach: process text sequentially
|
|
let remaining = text;
|
|
|
|
while (remaining.length > 0) {
|
|
let foundMatch = false;
|
|
let earliestPos = remaining.length;
|
|
let matchedPattern = null;
|
|
let match = null;
|
|
|
|
// Find earliest match
|
|
for (const pattern of patterns) {
|
|
pattern.regex.lastIndex = 0;
|
|
const m = pattern.regex.exec(remaining);
|
|
if (m && m.index < earliestPos) {
|
|
earliestPos = m.index;
|
|
matchedPattern = pattern;
|
|
match = m;
|
|
foundMatch = true;
|
|
}
|
|
}
|
|
|
|
if (foundMatch) {
|
|
// Add text before match
|
|
if (earliestPos > 0) {
|
|
xml += this.createRunXml(remaining.substring(0, earliestPos));
|
|
}
|
|
|
|
// Add formatted text
|
|
xml += this.createRunXml(match[1], matchedPattern.bold, matchedPattern.italic, matchedPattern.code);
|
|
|
|
remaining = remaining.substring(earliestPos + match[0].length);
|
|
} else {
|
|
// No more matches, add remaining text
|
|
xml += this.createRunXml(remaining);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return xml;
|
|
}
|
|
|
|
/**
|
|
* Create a run (text segment) XML
|
|
*/
|
|
createRunXml(text, bold = false, italic = false, code = false) {
|
|
if (!text) return '';
|
|
|
|
const escapedText = this.escapeXml(text);
|
|
let propsXml = '<w:rPr>';
|
|
|
|
if (bold) propsXml += '<w:b/>';
|
|
if (italic) propsXml += '<w:i/>';
|
|
if (code) {
|
|
propsXml += '<w:rFonts w:ascii="Consolas" w:hAnsi="Consolas"/>';
|
|
propsXml += '<w:sz w:val="20"/>';
|
|
}
|
|
|
|
propsXml += '</w:rPr>';
|
|
|
|
return `<w:r>${propsXml}<w:t xml:space="preserve">${escapedText}</w:t></w:r>`;
|
|
}
|
|
|
|
/**
|
|
* Escape XML special characters
|
|
*/
|
|
escapeXml(text) {
|
|
return text
|
|
.replace(/&/g, '&')
|
|
.replace(/</g, '<')
|
|
.replace(/>/g, '>')
|
|
.replace(/"/g, '"')
|
|
.replace(/'/g, ''');
|
|
}
|
|
}
|
|
|
|
module.exports = WordTemplateExporter;
|