Release v1.8.1: Streamlined PDF Editor UI

Enhanced PDF Editor user experience with cleaner, more intuitive interface:

✨ UI Improvements:
- Streamlined PDF Editor dialog to show only selected function
- Removed cluttered "all functions at once" display
- Added smooth fade-in animation when showing function-specific sections
- Improved dialog sizing: max-width 600px, max-height 85vh
- Better visual separation with compact section spacing

🎨 Styling Enhancements:
- Added PDF editor-specific CSS classes for better organization
- Enhanced file list styling with better contrast
- Improved remove button styling with danger color
- Complete dark theme support for all PDF editor components
- Better scrolling behavior for long forms

🔧 Technical Improvements:
- Maintained existing show/hide logic (already working correctly)
- Enhanced CSS specificity with .pdf-editor-content and .pdf-editor-body classes
- Added @keyframes fadeIn animation for smooth transitions
- Improved overflow handling for better UX on smaller screens

🌙 Theme Support:
- Full dark mode styling for file lists and entries
- Proper color contrast for all interactive elements
- Consistent styling across all 22 themes

The PDF Editor now provides a clean, focused interface showing only the relevant
controls for each operation (merge, split, compress, rotate, delete, reorder,
watermark, encrypt, decrypt, permissions).

🤖 Generated with Claude Code

Co-Authored-By: Claude <noreply@anthropic.com>

.claude/settings.local.json

@@ -26,7 +26,17 @@
       "Bash(dir:*)",
       "Bash(git merge:*)",
       "Bash(timeout:*)",
-      "Bash(findstr:*)"
+      "Bash(findstr:*)",
+      "Bash(git stash:*)",
+      "Bash(npm start:*)",
+      "Bash(gh release delete-asset:*)",
+      "Bash(git rm:*)",
+      "Bash(gh release view:*)",
+      "Bash(npm run build:linux:*)",
+      "Bash(git reset:*)",
+      "Read(//i/Template_exporter/**)",
+      "Bash(copy \"I:\\Template_exporter\\md_to_docx_converter.py\" \"H:\\Development\\pan-converter\\word-template-exporter\"\" && copy \"I:Template_exporterrequirements.txt\" \"H:Developmentpan-converterword-template-exporter\"\")",
+      "Bash(copy \"I:\\Template_exporter\\word_template.docx\" \"H:\\Development\\pan-converter\\word-template-exporter\"\")"
     ],
     "deny": []
   }

.vs/ProjectSettings.json

@@ -0,0 +1,3 @@
+{
+  "CurrentProjectSetting": null
+}

.vs/VSWorkspaceState.json

@@ -0,0 +1,7 @@
+{
+  "ExpandedNodes": [
+    ""
+  ],
+  "SelectedNode": "\\package.json",
+  "PreviewInSolutionExplorer": false
+}

.vs/pan-converter/v17/DocumentLayout.backup.json

@@ -0,0 +1,41 @@
+{
+  "Version": 1,
+  "WorkspaceRootPath": "H:\\Development\\pan-converter\\",
+  "Documents": [
+    {
+      "AbsoluteMoniker": "D:0:0:{A2FE74E1-B743-11D0-AE1A-00A0C90FFFC3}|\u003CMiscFiles\u003E|H:\\Development\\pan-converter\\package.json||{90A6B3A7-C1A3-4009-A288-E2FF89E96FA0}",
+      "RelativeMoniker": "D:0:0:{A2FE74E1-B743-11D0-AE1A-00A0C90FFFC3}|\u003CMiscFiles\u003E|solutionrelative:package.json||{90A6B3A7-C1A3-4009-A288-E2FF89E96FA0}"
+    }
+  ],
+  "DocumentGroupContainers": [
+    {
+      "Orientation": 0,
+      "VerticalTabListWidth": 256,
+      "DocumentGroups": [
+        {
+          "DockedWidth": 200,
+          "SelectedChildIndex": 0,
+          "Children": [
+            {
+              "$type": "Document",
+              "DocumentIndex": 0,
+              "Title": "package.json",
+              "DocumentMoniker": "H:\\Development\\pan-converter\\package.json",
+              "RelativeDocumentMoniker": "package.json",
+              "ToolTip": "H:\\Development\\pan-converter\\package.json",
+              "RelativeToolTip": "package.json",
+              "ViewState": "AgIAAAAAAAAAAAAAAAAAAAsAAAAqAAAAAAAAAA==",
+              "Icon": "ae27a6b0-e345-4288-96df-5eaf394ee369.001642|",
+              "WhenOpened": "2025-10-11T13:44:30.357Z",
+              "EditorCaption": ""
+            },
+            {
+              "$type": "Bookmark",
+              "Name": "ST:0:0:{cce594b6-0c39-4442-ba28-10c64ac7e89f}"
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

.vs/pan-converter/v17/DocumentLayout.json

@@ -0,0 +1,41 @@
+{
+  "Version": 1,
+  "WorkspaceRootPath": "H:\\Development\\pan-converter\\",
+  "Documents": [
+    {
+      "AbsoluteMoniker": "D:0:0:{A2FE74E1-B743-11D0-AE1A-00A0C90FFFC3}|\u003CMiscFiles\u003E|H:\\Development\\pan-converter\\package.json||{90A6B3A7-C1A3-4009-A288-E2FF89E96FA0}",
+      "RelativeMoniker": "D:0:0:{A2FE74E1-B743-11D0-AE1A-00A0C90FFFC3}|\u003CMiscFiles\u003E|solutionrelative:package.json||{90A6B3A7-C1A3-4009-A288-E2FF89E96FA0}"
+    }
+  ],
+  "DocumentGroupContainers": [
+    {
+      "Orientation": 0,
+      "VerticalTabListWidth": 256,
+      "DocumentGroups": [
+        {
+          "DockedWidth": 200,
+          "SelectedChildIndex": 0,
+          "Children": [
+            {
+              "$type": "Document",
+              "DocumentIndex": 0,
+              "Title": "package.json",
+              "DocumentMoniker": "H:\\Development\\pan-converter\\package.json",
+              "RelativeDocumentMoniker": "package.json",
+              "ToolTip": "H:\\Development\\pan-converter\\package.json",
+              "RelativeToolTip": "package.json",
+              "ViewState": "AgIAAAAAAAAAAAAAAAAAAAsAAAAqAAAAAAAAAA==",
+              "Icon": "ae27a6b0-e345-4288-96df-5eaf394ee369.001642|",
+              "WhenOpened": "2025-10-11T13:44:30.357Z",
+              "EditorCaption": ""
+            },
+            {
+              "$type": "Bookmark",
+              "Name": "ST:0:0:{cce594b6-0c39-4442-ba28-10c64ac7e89f}"
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

CLAUDE.md

@@ -4,7 +4,7 @@
 
 **PanConverter** is a cross-platform Markdown editor and converter powered by Pandoc, built with Electron. It provides professional-grade editing capabilities with comprehensive export options.
 
-**Current Version**: v1.7.7
+**Current Version**: v1.7.9
 **Author**: Amit Haridas (amit.wh@gmail.com)
 **License**: MIT
 **Repository**: https://github.com/amitwh/pan-converter
@@ -113,7 +113,234 @@ gh release create v1.2.1 --title "Title" --notes "Release notes" \
 
 ## Feature Implementation Guide
 
-### v1.7.7 Print & Enhanced PDF Support (Latest)
+### v1.7.9 Enhanced Word Export with Template Support (Latest)
+
+#### 📝 Template-Based Word Document Generation
+**Added Enhanced DOCX Export** (`src/wordTemplateExporter.js`, `src/main.js:540-596`, `src/main.js:242`)
+- **New Export Option**: "DOCX (Enhanced)" in File → Export menu with keyboard shortcut `Ctrl+Shift+W`
+- **Template Support**: Use custom Word templates to preserve branding, styles, and formatting
+- **Template Selection**: File → "Select Word Template..." menu option to choose custom templates
+- **Persistent Template**: Selected template is saved and reused across sessions
+- **Word XML Manipulation**: Direct manipulation of Word document XML using PizZip
+- **Template Page Preservation**: Preserves first 2 pages (cover + TOC) when using templates
+- **Smart Content Insertion**: Inserts markdown content after 2nd section break
+
+**Full Markdown Support:**
+- Headings (H1-H6) with markdown numbering stripped (e.g., "1.1 Title" → "Title")
+- Text formatting (bold, italic, bold+italic, strikethrough)
+- Inline code with Consolas font and gray background
+- Code blocks with monospace font and light gray background
+- Ordered and unordered lists (uses template numbering, strips markdown numbering)
+- Blockquotes with indentation
+- **Tables with orange header styling**:
+  - Orange header row (#F58220) with white bold text
+  - White data rows (no alternating colors)
+  - Orange borders (#F58220) on all cells
+  - Proper column alignment and spacing
+- Horizontal rules
+- Links
+- **ASCII Art and Flowcharts**:
+  - Detects box-drawing characters (┌, ─, │, └, etc.)
+  - Detects flowchart patterns with square brackets
+  - Preserves monospace alignment with Consolas font
+  - Each line rendered separately to prevent wrapping
+  - No-wrap paragraph properties for exact spacing
+  - **Red-colored arrows** (↓, →, ←, ↑) for enhanced visibility
+  - Gray background (#F5F5F5) for distinction from regular text
+
+**ASCII Art Detection Patterns:**
+- Unicode box-drawing characters: ┌┐└┘├┤┬┴┼─│═║╔╗╚╝╠╣╦╩╬
+- Arrow characters: ↓→←↑▼►◄▲
+- ASCII box patterns: +-----+, |-----|, [Text in brackets]
+- Flowchart steps: START, [Step Description], END
+
+**ASCII Art Rendering Features:**
+```javascript
+// Each line gets its own paragraph with no-wrap
+xml += `<w:p>
+    <w:pPr>
+        <w:wordWrap w:val="0"/>          // Disable wrapping
+        <w:keepLines/>                    // Keep lines together
+        <w:line="240" w:lineRule="exact"/>  // Exact line height
+    </w:pPr>
+    // Arrows colored red (#FF0000)
+    // Text in Consolas 16pt with gray background
+</w:p>`;
+```
+
+**Template Selection Workflow:**
+1. User clicks File → "Select Word Template..."
+2. Dialog opens to browse for .docx files
+3. Selected template path stored in global variable and persisted
+4. Template automatically loaded on app startup
+5. Enhanced export uses selected template (or defaults to `word_template.docx`)
+
+**Technical Implementation:**
+```javascript
+// Template selection function
+async function selectWordTemplate() {
+    const result = await dialog.showOpenDialog(mainWindow, {
+        title: 'Select Word Template',
+        filters: [{ name: 'Word Document', extensions: ['docx'] }],
+        properties: ['openFile']
+    });
+
+    if (!result.canceled && result.filePaths.length > 0) {
+        wordTemplatePath = result.filePaths[0];
+        store.set('wordTemplatePath', wordTemplatePath);
+    }
+}
+
+// Word Template Exporter with template support
+class WordTemplateExporter {
+    constructor(templatePath) {
+        this.templatePath = templatePath || path.join(__dirname, '../word_template.docx');
+    }
+
+    async convert(markdownContent, outputPath) {
+        // Load template as ZIP
+        const templateBuffer = fs.readFileSync(this.templatePath);
+        const zip = new PizZip(templateBuffer);
+
+        // Extract and modify document.xml
+        const documentXml = zip.file('word/document.xml').asText();
+        const newContentXml = this.markdownToWordXml(markdownContent);
+        const modifiedXml = this.insertContentAfterPage2(documentXml, newContentXml);
+
+        // Save modified document
+        zip.file('word/document.xml', modifiedXml);
+        const newDocBuffer = zip.generate({ type: 'nodebuffer' });
+        fs.writeFileSync(outputPath, newDocBuffer);
+    }
+}
+```
+
+**Menu Integration:**
+- Export: File → Export → "DOCX (Enhanced)" (`Ctrl+Shift+W`)
+- Template Selection: File → "Select Word Template..."
+- Template path saved to: `userData/settings.json`
+
+**Dependencies Added:**
+```json
+{
+  "docx": "^9.5.1",
+  "pizzip": "^3.2.0",
+  "docx4js": "^3.3.0"
+}
+```
+
+**Key Improvements in v1.7.9:**
+1. ✅ Template-based export preserving corporate branding
+2. ✅ Persistent template selection across sessions
+3. ✅ Tables with professional orange header styling and white data rows
+4. ✅ ASCII art and flowcharts with perfect alignment and no wrapping
+5. ✅ Red-colored arrows in flowcharts for enhanced readability
+6. ✅ Markdown numbering stripped from headings and lists
+7. ✅ Template's automatic numbering system used instead
+
+### v1.7.8 Critical Bug Fixes
+
+#### 🐛 File Association Fix for Packaged Apps
+**Fixed Command-Line Argument Parsing** (`src/main.js:1598-1627`, `src/main.js:70-90`)
+- **Root Cause**: `process.argv.slice(2)` works in development but fails in packaged apps
+- **Solution**: Detect if app is packaged using `app.isPackaged` and use correct slice index
+  - Development: `process.argv.slice(2)` - ['electron', 'app.js', 'file.md']
+  - Packaged: `process.argv.slice(1)` - ['PanConverter.exe', 'file.md']
+- **Path Resolution**: Added proper path resolution for both absolute and relative paths
+- **Comprehensive Logging**: Added detailed console logs to debug file loading issues
+- **Second Instance Handler**: Also fixed second-instance handler to use same logic
+
+**Technical Implementation:**
+```javascript
+// Detect packaged vs development mode
+const startIndex = app.isPackaged ? 1 : 2;
+const fileArgs = process.argv.slice(startIndex);
+
+// Resolve paths properly
+for (const arg of fileArgs) {
+  if ((arg.endsWith('.md') || arg.endsWith('.markdown'))) {
+    const resolvedPath = path.isAbsolute(arg) ? arg : path.resolve(process.cwd(), arg);
+    if (fs.existsSync(resolvedPath)) {
+      app.pendingFile = resolvedPath;
+      break;
+    }
+  }
+}
+```
+
+**Fixed Issues:**
+- ✅ Files now open correctly on first double-click in packaged app
+- ✅ Command-line arguments properly parsed in both dev and production
+- ✅ Relative and absolute paths handled correctly
+- ✅ Comprehensive logging for debugging file association issues
+
+#### 🖨️ Print Preview Fix
+**Fixed Print Output to Show Preview Content** (`src/renderer.js:1178-1204`, `src/styles.css:2828-3014`)
+- **Root Cause**: Manual DOM manipulation conflicted with CSS `@media print` rules
+- **Solution**: Simplified handler to rely on CSS `@media print` for hiding UI elements
+- **CSS Enhancements**:
+  - Added selectors for dynamic preview panes `[id^="preview-pane-"]` and `[id^="editor-pane-"]`
+  - Added `.tab-content` to ensure full-width rendering
+  - Added body class-based styling for no-styles mode
+- **Removed Manual Hiding**: Eliminated manual `display: none` manipulation in favor of CSS
+
+**Technical Implementation:**
+```javascript
+// Simplified print handler - let CSS do the work
+function handlePrintPreview(withStyles) {
+  const activeTabId = tabManager ? tabManager.activeTabId : 1;
+  const previewContent = document.getElementById(`preview-${activeTabId}`);
+
+  if (!previewContent || !previewContent.innerHTML.trim()) {
+    alert('Nothing to print...');
+    return;
+  }
+
+  // Add body classes for CSS styling
+  if (!withStyles) {
+    document.body.classList.add('printing-no-styles');
+  }
+  document.body.classList.add('printing');
+
+  setTimeout(() => {
+    ipcRenderer.send('do-print', { withStyles });
+    setTimeout(() => {
+      document.body.classList.remove('printing', 'printing-no-styles');
+    }, 1000);
+  }, 100);
+}
+```
+
+**CSS Updates:**
+```css
+@media print {
+  /* Hide all UI elements */
+  #toolbar, #tab-bar, .editor-pane, [id^="editor-pane-"] {
+    display: none !important;
+  }
+
+  /* Show preview in full width */
+  [id^="preview-"], [id^="preview-pane-"], .tab-content {
+    display: block !important;
+    width: 100% !important;
+    padding: 20px !important;
+  }
+}
+```
+
+**Fixed Issues:**
+- ✅ Print now correctly renders preview content, not toolbar
+- ✅ Both print modes work (with styles and without styles)
+- ✅ Clean, professional print output with proper formatting
+- ✅ Proper page breaks, typography, and layout optimization
+
+#### 🔧 Development Cleanup
+**Removed Debugging Code** (`src/main.js:120-123`)
+- Removed auto-opening of DevTools
+- Clean production-ready build
+- Debugging logs remain for troubleshooting but DevTools disabled by default
+
+### v1.7.7 Print & Enhanced PDF Support
 
 #### 🖨️ Native Print Functionality
 **Added Print Submenu to File Menu** (`src/main.js:202-215`, `src/renderer.js:1152-1188`, `src/styles.css:2828-2994`)
@@ -782,5 +1009,14 @@ if (!gotTheLock) {
 
 ---
 
-**Last Updated**: October 24, 2025
-**Claude Assistant**: Development completed for v1.7.7 with enhanced print menu featuring two print options: "Print Preview" (Ctrl+P, black text, ink-saving) and "Print Preview (With Styles)" (full colors). Implemented comprehensive print handler that hides editor UI and shows only the rendered preview. Added extensive CSS print stylesheet with smart page breaks, optimized formatting for all markdown elements, and professional typography. Added PDFKit and html2pdf libraries for native PDF support without Pandoc dependency. Previous releases include v1.7.6 table header styling cleanup and v1.7.5 critical file association fix.
+**Last Updated**: October 27, 2025
+**Claude Assistant**: Development completed for v1.7.9 with Template-Based Word Export:
+- **Template Support**: Word XML manipulation using PizZip to preserve template branding and styles
+- **Template Selection**: File menu option to choose custom Word templates, persisted across sessions
+- **Table Styling**: Orange headers (#F58220) with white bold text, white data rows, orange borders
+- **ASCII Art & Flowcharts**: Perfect monospace alignment with no-wrap properties, each line as separate paragraph
+- **Red Arrows**: Flowchart arrows (↓→←↑) rendered in red color for enhanced visibility
+- **Markdown Numbering Strip**: Removes markdown numbering from headings and lists to use template numbering
+- **Template Page Preservation**: Keeps first 2 pages (cover + TOC) intact, inserts content after 2nd section break
+
+Previous releases: v1.7.8 (file association & print preview fixes), v1.7.7 (print menu with two options), v1.7.6 (table header cleanup), v1.7.5 (single-instance lock).

PUSH_INSTRUCTIONS.md

@@ -1,95 +1,12 @@
-# Push Instructions for Pan Converter
+# Test Double-Click File Opening
 
-## Prerequisites
-1. Create a new repository on GitHub: https://github.com/new
-   - Repository name: `pan-converter`
-   - Keep it empty (no README, .gitignore, or license)
-   - Make it public or private as desired
+This is a test file to verify double-click functionality.
 
-2. Set up authentication:
-   - **Option A - SSH Key** (Recommended):
-     ```bash
-     # Check if you have SSH key
-     ls -la ~/.ssh/id_rsa.pub
+## Features to Test
+- File should load automatically
+- Content should display in editor
+- Tab should show filename
+- Preview should render markdown
 
-     # If not, generate one:
-     ssh-keygen -t rsa -b 4096 -C "your_email@example.com"
-     
-     # Add to GitHub: Settings > SSH and GPG keys > New SSH key
-     cat ~/.ssh/id_rsa.pub
-     ```
-   
-   - **Option B - Personal Access Token**:
-     - Go to GitHub Settings > Developer settings > Personal access tokens
-     - Generate new token with 'repo' scope
-     - Save the token securely
-
-## Push Commands
-
-### Using SSH (Recommended)
-```bash
-# Set SSH remote
-git remote set-url origin git@github.com:amitwh/pan-converter.git
-
-# Push all branches
-git push -u origin master
-git push origin linux
-git push origin macos
-git push origin windows
-```
-
-### Using HTTPS with Token
-```bash
-# Set HTTPS remote
-git remote set-url origin https://github.com/amitwh/pan-converter.git
-
-# Push all branches (you'll be prompted for username and token)
-git push -u origin master
-git push origin linux
-git push origin macos
-git push origin windows
-
-# When prompted:
-# Username: amitwh
-# Password: [paste your Personal Access Token]
-```
-
-### Using GitHub CLI (if installed)
-```bash
-# Login to GitHub CLI
-gh auth login
-
-# Create repo and push
-gh repo create pan-converter --public --source=. --remote=origin --push
-```
-
-## Automated Script
-```bash
-# Run the provided script
-./push-to-github.sh
-```
-
-## Verify Success
-After pushing, verify at: https://github.com/amitwh/pan-converter
-
-You should see:
-- 4 branches (master, linux, macos, windows)
-- All project files
-- Complete commit history
-
-## Troubleshooting
-
-### Authentication Failed
-- For SSH: Ensure your SSH key is added to GitHub
-- For HTTPS: Use Personal Access Token, not password
-- Check token has 'repo' scope
-
-### Repository Not Found
-- Ensure repository exists on GitHub
-- Check spelling: `pan-converter`
-- Verify you're logged into the correct GitHub account
-
-### Permission Denied
-- Check repository ownership
-- Ensure you have write access
-- Verify authentication method is correct
+**This text should be bold**
+*This text should be italic*

README.md

@@ -138,6 +138,8 @@ npm run dist:all
 
 ## Version History
 
+- **v1.8.0** - Added enhanced Word export with template support to batch converter
+- **v1.7.9** - Enhanced Word Export with Template Support: Template-based DOCX generation with custom templates, table styling, ASCII art support, and red-colored flowchart arrows
 - **v1.5.6** - (Your release notes here)
 - **v1.5.5** - Refactored PDF export, simplified Pandoc pathing, and removed XLSX dependency.
 - **v1.3.1** - Bug fixes: Fixed file associations for double-clicking .md files, corrected 50/50 layout alignment for editor/preview panes

package.json

@@ -1,6 +1,6 @@
 {
   "name": "pan-converter",
-  "version": "1.7.6",
+  "version": "1.8.1",
   "description": "Cross-platform Markdown editor and converter using Pandoc",
   "main": "src/main.js",
   "scripts": {
@@ -31,13 +31,17 @@
   },
   "dependencies": {
     "codemirror": "^6.0.2",
+    "core-util-is": "^1.0.3",
+    "docx": "^9.5.1",
+    "docx4js": "^3.3.0",
     "dompurify": "^3.2.6",
     "electron-store": "^10.1.0",
-    "html2pdf.js": "^0.10.1",
     "highlight.js": "^11.11.1",
+    "html2pdf.js": "^0.10.1",
     "marked": "^16.2.1",
     "pdf-lib": "^1.17.1",
     "pdfkit": "^0.14.0",
+    "pizzip": "^3.2.0",
     "tslib": "^2.8.1",
     "xlsx": "^0.18.5"
   },

src/index.html

@@ -516,6 +516,7 @@
                             <option value="html">HTML</option>
                             <option value="pdf">PDF</option>
                             <option value="docx">DOCX</option>
+                            <option value="docx-enhanced">DOCX (Enhanced)</option>
                             <option value="latex">LaTeX</option>
                             <option value="rtf">RTF</option>
                             <option value="odt">ODT</option>
@@ -555,12 +556,12 @@
 
         <!-- PDF Editor Dialog -->
         <div id="pdf-editor-dialog" class="export-dialog hidden">
-            <div class="export-dialog-content">
+            <div class="export-dialog-content pdf-editor-content">
                 <div class="export-dialog-header">
                     <h3 id="pdf-editor-title">PDF Editor</h3>
                     <button id="pdf-editor-dialog-close" title="Close">×</button>
                 </div>
-                <div class="export-dialog-body">
+                <div class="export-dialog-body pdf-editor-body">
                     <!-- Merge PDFs Section -->
                     <div id="pdf-merge-section" class="pdf-operation-section hidden">
                         <div class="export-section">

src/main.js

@@ -3,6 +3,7 @@ const path = require('path');
 const fs = require('fs');
 const { exec } = require('child_process');
 const { PDFDocument, rgb, degrees, StandardFonts } = require('pdf-lib');
+const WordTemplateExporter = require('./wordTemplateExporter');
 
 // Get the system Pandoc path
 function getPandocPath() {
@@ -47,6 +48,7 @@ const store = {
 let mainWindow;
 let currentFile = null; // This will now represent the active tab's file
 let pandocAvailable = null; // Cache pandoc availability check
+let wordTemplatePath = null; // Path to selected Word template
 let rendererReady = false; // Track if renderer is ready to receive file data
 
 // Handle single instance lock for Windows file association
@@ -68,19 +70,26 @@ if (!gotTheLock) {
     }
 
     // Check if a file was passed to the second instance
-    // commandLine is an array like: ['electron.exe', 'app.asar', 'file.md']
-    const fileArgs = commandLine.slice(2);
+    // commandLine is an array like: ['PanConverter.exe', 'file.md']
+    console.log('[MAIN] Second instance commandLine:', JSON.stringify(commandLine));
+    const startIndex = app.isPackaged ? 1 : 2;
+    const fileArgs = commandLine.slice(startIndex);
+    console.log('[MAIN] Second instance file args:', fileArgs);
     for (const arg of fileArgs) {
-      if ((arg.endsWith('.md') || arg.endsWith('.markdown')) && fs.existsSync(arg)) {
+      if ((arg.endsWith('.md') || arg.endsWith('.markdown'))) {
+        const resolvedPath = path.isAbsolute(arg) ? arg : path.resolve(workingDirectory, arg);
+        console.log('[MAIN] Second instance resolved path:', resolvedPath);
+        if (fs.existsSync(resolvedPath)) {
           // Open the file in the existing instance
           if (rendererReady) {
-          openFileFromPath(arg);
+            openFileFromPath(resolvedPath);
           } else {
-          app.pendingFile = arg;
+            app.pendingFile = resolvedPath;
           }
           break;
         }
       }
+    }
   });
 }
 
@@ -230,6 +239,7 @@ function createMenu() {
             { label: 'HTML', click: () => exportFile('html') },
             { label: 'PDF', click: () => exportFile('pdf') },
             { label: 'DOCX', click: () => exportFile('docx') },
+            { label: 'DOCX (Enhanced)', click: () => exportWordWithTemplate(), accelerator: 'Ctrl+Shift+W' },
             { label: 'LaTeX', click: () => exportFile('latex') },
             { label: 'RTF', click: () => exportFile('rtf') },
             { label: 'ODT', click: () => exportFile('odt') },
@@ -242,6 +252,11 @@ function createMenu() {
           ]
         },
         { type: 'separator' },
+        {
+          label: 'Select Word Template...',
+          click: selectWordTemplate
+        },
+        { type: 'separator' },
         {
           label: 'Quit',
           accelerator: process.platform === 'darwin' ? 'Cmd+Q' : 'Ctrl+Q',
@@ -460,7 +475,7 @@ function createMenu() {
               type: 'info',
               title: 'About PanConverter',
               message: 'PanConverter',
-              detail: 'A cross-platform Markdown editor and converter using Pandoc.\n\nVersion: 1.7.4\nAuthor: Amit Haridas\nEmail: amit.wh@gmail.com\nLicense: MIT\n\nFeatures:\n• Modern glassmorphism UI with gradient backgrounds\n• Comprehensive PDF Editor (merge, split, compress, rotate, watermark, encrypt)\n• Universal File Converter (LibreOffice, ImageMagick, FFmpeg, Pandoc)\n• Windows Explorer context menu integration\n• Tabbed interface for multiple files\n• Advanced markdown editing with live preview\n• Real-time preview updates while typing\n• Full toolbar markdown editing functions\n• Enhanced PDF export with built-in Electron fallback\n• File association support for .md files\n• Command-line interface for batch conversion\n• Advanced export options with templates and metadata\n• Batch file conversion with progress tracking\n• Improved preview typography and spacing\n• Adjustable font sizes via menu (Ctrl+Shift+Plus/Minus)\n• Complete theme support including Monokai fixes\n• Find & replace with match highlighting\n• Line numbers and auto-indentation\n• Export to multiple formats via Pandoc\n• PowerPoint & presentation export\n• Export tables to Excel/ODS spreadsheets\n• Document import & conversion\n• Table creation helper\n• 22 beautiful themes (including Dracula, Nord, Tokyo Night, Gruvbox, Ayu, Concrete, and more)\n• Undo/redo functionality\n• Live word count and statistics',
+              detail: 'A cross-platform Markdown editor and converter using Pandoc.\n\nVersion: 1.8.1\nAuthor: Amit Haridas\nEmail: amit.wh@gmail.com\nLicense: MIT\n\nFeatures:\n• Modern glassmorphism UI with gradient backgrounds\n• Streamlined PDF Editor UI (merge, split, compress, rotate, watermark, encrypt)\n• Universal File Converter (LibreOffice, ImageMagick, FFmpeg, Pandoc)\n• Windows Explorer context menu integration\n• Tabbed interface for multiple files\n• Advanced markdown editing with live preview\n• Real-time preview updates while typing\n• Full toolbar markdown editing functions\n• Enhanced PDF export with built-in Electron fallback\n• Enhanced Word export with template support (single file & batch)\n• File association support for .md files\n• Command-line interface for batch conversion\n• Advanced export options with templates and metadata\n• Batch file conversion with progress tracking\n• Improved preview typography and spacing\n• Adjustable font sizes via menu (Ctrl+Shift+Plus/Minus)\n• Complete theme support including Monokai fixes\n• Find & replace with match highlighting\n• Line numbers and auto-indentation\n• Export to multiple formats via Pandoc\n• PowerPoint & presentation export\n• Export tables to Excel/ODS spreadsheets\n• Document import & conversion\n• Table creation helper\n• 22 beautiful themes (including Dracula, Nord, Tokyo Night, Gruvbox, Ayu, Concrete, and more)\n• Undo/redo functionality\n• Live word count and statistics',
               buttons: ['OK']
             });
           }
@@ -526,6 +541,65 @@ function showBatchConversionDialog() {
   mainWindow.webContents.send('show-batch-dialog');
 }
 
+// Select Word Template
+async function selectWordTemplate() {
+  const result = await dialog.showOpenDialog(mainWindow, {
+    title: 'Select Word Template',
+    filters: [{ name: 'Word Document', extensions: ['docx'] }],
+    properties: ['openFile']
+  });
+
+  if (!result.canceled && result.filePaths.length > 0) {
+    wordTemplatePath = result.filePaths[0];
+    store.set('wordTemplatePath', wordTemplatePath);
+
+    dialog.showMessageBox(mainWindow, {
+      type: 'info',
+      title: 'Template Selected',
+      message: 'Word template has been updated',
+      detail: `Template: ${path.basename(wordTemplatePath)}`
+    });
+  }
+}
+
+// Enhanced Word Export with Template Support
+async function exportWordWithTemplate() {
+  if (!currentFile) {
+    dialog.showErrorBox('Error', 'Please save the file first');
+    return;
+  }
+
+  try {
+    // Get markdown content
+    const content = fs.readFileSync(currentFile, 'utf-8');
+
+    // Show dialog for output file
+    const result = await dialog.showSaveDialog(mainWindow, {
+      title: 'Export to Word (Enhanced)',
+      defaultPath: currentFile.replace(/\.md$/, '.docx'),
+      filters: [{ name: 'Word Document', extensions: ['docx'] }]
+    });
+
+    if (result.canceled) return;
+
+    // Create exporter instance with selected template (if any)
+    const exporter = new WordTemplateExporter(wordTemplatePath);
+
+    // Convert markdown to DOCX
+    await exporter.convert(content, result.filePath);
+
+    dialog.showMessageBox(mainWindow, {
+      type: 'info',
+      title: 'Export Successful',
+      message: 'Document exported successfully!',
+      detail: `Saved to: ${result.filePath}`
+    });
+
+  } catch (error) {
+    dialog.showErrorBox('Export Error', `Failed to export document: ${error.message}`);
+  }
+}
+
 // Universal File Converter integration
 function showUniversalConverterDialog() {
   mainWindow.webContents.send('show-universal-converter-dialog');
@@ -784,20 +858,17 @@ function performExportWithOptions(format, options) {
 
 function tryPdfFallback(inputFile, outputFile, engines, index, options, lastError) {
   if (index >= engines.length) {
-    dialog.showErrorBox('PDF Export Error',
-      `Failed to export PDF with all available engines. Please ensure you have one of the following installed:\n` +
-      `• XeLaTeX (recommended): sudo apt-get install texlive-xetex\n` +
-      `• PDFLaTeX: sudo apt-get install texlive-latex-base\n` +
-      `• LuaLaTeX: sudo apt-get install texlive-luatex\n\n` +
-      `Last error: ${lastError.message}`
-    );
+    // All Pandoc PDF engines failed, fallback to Electron's built-in PDF export
+    console.log('All Pandoc PDF engines failed, falling back to Electron PDF export');
+    exportToPDFElectron(outputFile);
     return;
   }
 
   const engine = engines[index];
-  let pandocCmd = `${getPandocPath()} "${inputFile}" --pdf-engine=${engine} -V geometry:${geometry} -o "${outputFile}"`;
+  let pandocCmd = `${getPandocPath()} "${inputFile}" --pdf-engine=${engine} -o "${outputFile}"`;
 
-  if (options.geometry) pandocCmd += ` -V geometry:"${options.geometry}"`;
+  // Add geometry if specified
+  if (options.geometry) pandocCmd = pandocCmd.replace(` -o `, ` -V geometry:"${options.geometry}" -o `);
 
   // Add all other options
   if (options.template && options.template !== 'default') {
@@ -1157,7 +1228,7 @@ ipcMain.on('save-current-file', (event, content) => {
 });
 
 ipcMain.on('get-theme', (event) => {
-  const theme = store.get('theme', 'light');
+  const theme = store.get('theme', 'github');
   event.reply('theme-changed', theme);
 });
 
@@ -1166,44 +1237,36 @@ ipcMain.on('set-current-file', (event, filePath) => {
   currentFile = filePath;
 });
 
-// Handle print preview
-ipcMain.on('print-preview', (event) => {
+// Handle actual printing when renderer is ready
+ipcMain.on('do-print', (event, { withStyles }) => {
   if (mainWindow) {
-    // Prepare for printing preview only (black text, no colors)
-    mainWindow.webContents.send('prepare-print-preview', false);
-    // Give renderer time to prepare, then print
-    setTimeout(() => {
+    // Renderer has already hidden UI, waited 300ms, and prepared the page
+    // Print immediately - DOM is fully rendered
     mainWindow.webContents.print({
       silent: false,
-        printBackground: false,
+      printBackground: withStyles,
       color: true,
       margin: { marginType: 'default' }
     });
-    }, 100);
-  }
-});
-
-// Handle print preview with styles
-ipcMain.on('print-preview-styled', (event) => {
-  if (mainWindow) {
-    // Prepare for printing preview with colors
-    mainWindow.webContents.send('prepare-print-preview', true);
-    // Give renderer time to prepare, then print
-    setTimeout(() => {
-      mainWindow.webContents.print({
-        silent: false,
-        printBackground: true,
-        color: true,
-        margin: { marginType: 'default' }
-      });
-    }, 100);
   }
 });
 
 // Handle renderer ready for file association
 ipcMain.on('renderer-ready', (event) => {
+  console.log('[MAIN] renderer-ready received, rendererReady was:', rendererReady);
+  if (mainWindow) {
+    mainWindow.webContents.executeJavaScript(`console.log('[MAIN->RENDERER] renderer-ready received, rendererReady was: ${rendererReady}')`);
+  }
   rendererReady = true;
+  console.log('[MAIN] app.pendingFile:', app.pendingFile);
+  if (mainWindow) {
+    mainWindow.webContents.executeJavaScript(`console.log('[MAIN->RENDERER] app.pendingFile: ${app.pendingFile}')`);
+  }
   if (app.pendingFile) {
+    console.log('[MAIN] Opening pending file:', app.pendingFile);
+    if (mainWindow) {
+      mainWindow.webContents.executeJavaScript(`console.log('[MAIN->RENDERER] Opening pending file: ${app.pendingFile}')`);
+    }
     openFileFromPath(app.pendingFile);
     app.pendingFile = null;
   }
@@ -1369,7 +1432,7 @@ function performBatchConversion(inputFolder, outputFolder, format, options) {
   const totalCount = markdownFiles.length;
 
   // Process each file
-  const processNextFile = (index) => {
+  const processNextFile = async (index) => {
     if (index >= markdownFiles.length) {
       // All files processed
       dialog.showMessageBox(mainWindow, {
@@ -1384,7 +1447,8 @@ function performBatchConversion(inputFolder, outputFolder, format, options) {
     const inputFile = markdownFiles[index];
     const relativePath = path.relative(inputFolder, inputFile);
     const baseName = path.basename(relativePath, path.extname(relativePath));
-    const outputFile = path.join(outputFolder, relativePath.replace(/\.(md|markdown)$/i, `.${format}`));
+    const outputExtension = format === 'docx-enhanced' ? 'docx' : format;
+    const outputFile = path.join(outputFolder, relativePath.replace(/\.(md|markdown)$/i, `.${outputExtension}`));
 
     // Create subdirectories in output folder if needed
     const outputDir = path.dirname(outputFile);
@@ -1392,7 +1456,41 @@ function performBatchConversion(inputFolder, outputFolder, format, options) {
       fs.mkdirSync(outputDir, { recursive: true });
     }
 
-    // Build pandoc command
+    // Handle DOCX Enhanced format with WordTemplateExporter
+    if (format === 'docx-enhanced') {
+      try {
+        const content = fs.readFileSync(inputFile, 'utf-8');
+        const exporter = new WordTemplateExporter(wordTemplatePath);
+        await exporter.convert(content, outputFile);
+
+        completedCount++;
+
+        // Update progress
+        mainWindow.webContents.send('batch-progress', {
+          completed: index + 1,
+          total: totalCount,
+          currentFile: path.basename(inputFile),
+          success: true
+        });
+
+        // Process next file
+        processNextFile(index + 1);
+      } catch (error) {
+        // Update progress with error
+        mainWindow.webContents.send('batch-progress', {
+          completed: index + 1,
+          total: totalCount,
+          currentFile: path.basename(inputFile),
+          success: false
+        });
+
+        // Process next file even if this one failed
+        processNextFile(index + 1);
+      }
+      return;
+    }
+
+    // Build pandoc command for other formats
     let pandocCmd = `${getPandocPath()} "${inputFile}" -o "${outputFile}"`;
 
     // Add template if specified
@@ -1594,6 +1692,9 @@ function buildPandocCommand(content, format, outputPath) {
 }
 
 app.whenReady().then(() => {
+  // Load saved Word template path
+  wordTemplatePath = store.get('wordTemplatePath', null);
+
   // Check for command line conversion requests
   const args = process.argv.slice(2);
   if (args.length >= 2 && (args[0] === '--convert' || args[0] === '--convert-to')) {
@@ -1604,15 +1705,35 @@ app.whenReady().then(() => {
   createWindow();
   
   // Handle file association on app startup
-  // Process all command line arguments except the first two (node and script path)
-  const fileArgs = process.argv.slice(2);
+  // In packaged apps, process.argv structure is different:
+  // Development: ['electron', 'app.js', 'file.md'] - need slice(2)
+  // Packaged: ['PanConverter.exe', 'file.md'] - need slice(1)
+  // We'll check all arguments after the executable
+  console.log('[MAIN] Full command line args:', JSON.stringify(process.argv));
+  console.log('[MAIN] App is packaged:', app.isPackaged);
+
+  // Start from index 1 (skip executable) and check each argument
+  const startIndex = app.isPackaged ? 1 : 2;
+  const fileArgs = process.argv.slice(startIndex);
+  console.log('[MAIN] File args to process (starting from index', startIndex + '):', fileArgs);
+
   for (const arg of fileArgs) {
-    if ((arg.endsWith('.md') || arg.endsWith('.markdown')) && fs.existsSync(arg)) {
+    console.log('[MAIN] Checking arg:', arg);
+    if ((arg.endsWith('.md') || arg.endsWith('.markdown'))) {
+      // Try to resolve the path (might be relative)
+      const resolvedPath = path.isAbsolute(arg) ? arg : path.resolve(process.cwd(), arg);
+      console.log('[MAIN] Resolved path:', resolvedPath);
+      if (fs.existsSync(resolvedPath)) {
         // Store the file to open after window is ready
-      app.pendingFile = arg;
+        console.log('[MAIN] Setting pendingFile to:', resolvedPath);
+        app.pendingFile = resolvedPath;
         break;
+      } else {
+        console.log('[MAIN] File does not exist:', resolvedPath);
       }
     }
+  }
+  console.log('[MAIN] Final app.pendingFile:', app.pendingFile);
 });
 
 app.on('window-all-closed', () => {
@@ -1664,15 +1785,23 @@ app.on('open-file', (event, filePath) => {
 
 // Handle file opening from command line or file association
 function openFileFromPath(filePath) {
+  console.log('[MAIN] openFileFromPath called with:', filePath);
+  console.log('[MAIN] rendererReady:', rendererReady, 'mainWindow exists:', !!mainWindow);
   if (fs.existsSync(filePath)) {
     currentFile = filePath;
     const content = fs.readFileSync(filePath, 'utf-8');
+    console.log('[MAIN] File read successfully, content length:', content.length);
     if (mainWindow && mainWindow.webContents && rendererReady) {
+      // Send file immediately - renderer-ready means UI is initialized
+      console.log('[MAIN] Sending file-opened to renderer');
       mainWindow.webContents.send('file-opened', { path: filePath, content });
     } else {
       // Store file to open after renderer is ready
+      console.log('[MAIN] Storing as pending file');
       app.pendingFile = filePath;
     }
+  } else {
+    console.error('[MAIN] File does not exist:', filePath);
   }
 }
 

src/renderer.js

@@ -964,10 +964,13 @@ class TabManager {
             tab.originalContent = content;
             tab.isDirty = false;
 
-            // Update the editor immediately
+            // Update the editor and preview
             const editor = document.getElementById(`editor-${this.activeTabId}`);
             if (editor) {
                 editor.value = content;
+                // Update preview after editor is updated
+                this.updatePreview(this.activeTabId);
+                this.updateWordCount();
             }
         } else {
             // Create new tab for the file
@@ -990,9 +993,6 @@ class TabManager {
                 }
             }, 50);
         }
-
-        this.updatePreview(this.activeTabId);
-        this.updateWordCount();
         this.startAutoSave();
         this.addToRecentFiles(filePath);
         this.updateTabBar();
@@ -1042,8 +1042,12 @@ document.addEventListener('DOMContentLoaded', () => {
     // Request current theme
     ipcRenderer.send('get-theme');
 
-    // Signal that renderer is ready for file operations
+    // Also send renderer-ready immediately as backup
+    // This ensures we don't get stuck waiting for theme-changed
+    setTimeout(() => {
+        console.log('Backup renderer-ready timeout triggered');
         ipcRenderer.send('renderer-ready');
+    }, 100);
 
     // Set up auto-save interval
     setInterval(() => {
@@ -1062,8 +1066,11 @@ ipcRenderer.on('file-new', () => {
 });
 
 ipcRenderer.on('file-opened', (event, data) => {
+    console.log('[RENDERER] file-opened received:', data.path, 'content length:', data.content.length);
     if (tabManager) {
         tabManager.openFile(data.path, data.content);
+    } else {
+        console.error('[RENDERER] tabManager not initialized!');
     }
 });
 
@@ -1101,7 +1108,15 @@ ipcRenderer.on('toggle-find', () => {
 });
 
 ipcRenderer.on('theme-changed', (event, theme) => {
+    console.log('[RENDERER] Theme changed to:', theme);
     document.body.className = `theme-${theme}`;
+
+    // After theme is applied, wait for next frame then signal renderer is ready
+    // This ensures complete UI initialization before files are opened
+    requestAnimationFrame(() => {
+        console.log('[RENDERER] Sending renderer-ready from theme-changed');
+        ipcRenderer.send('renderer-ready');
+    });
 });
 
 // Undo/Redo handlers
@@ -1149,43 +1164,116 @@ ipcRenderer.on('adjust-font-size', (event, action) => {
     updateFontSizes(currentFontSize);
 });
 
-// Print preview handler - prepare for printing
-ipcRenderer.on('prepare-print-preview', (event, withStyles) => {
-    const previewContent = document.getElementById('preview');
+// Print preview request handlers - handle printing directly
+ipcRenderer.on('print-preview', () => {
+    console.log('[RENDERER] print-preview received');
+    handlePrintPreview(false);
+});
+
+ipcRenderer.on('print-preview-styled', () => {
+    console.log('[RENDERER] print-preview-styled received');
+    handlePrintPreview(true);
+});
+
+function handlePrintPreview(withStyles) {
+    const activeTabId = tabManager ? tabManager.activeTabId : 1;
+    const previewContent = document.getElementById(`preview-${activeTabId}`);
 
     if (!previewContent || !previewContent.innerHTML.trim()) {
         alert('Nothing to print. Please create or open a document and ensure the preview is visible.');
         return;
     }
 
-    // Hide editor and other UI elements for print
-    document.getElementById('editor-container').style.display = 'none';
-    document.getElementById('toolbar').style.display = 'none';
-    document.getElementById('tab-bar').style.display = 'none';
-    document.getElementById('status-bar').style.display = 'none';
+    // Store original display values for restoration
+    const elementsToHide = [];
 
-    // Show preview in full width
-    const preview = document.getElementById('preview');
-    if (preview) {
-        preview.classList.add('print-mode');
-        if (!withStyles) {
-            preview.classList.add('print-no-styles');
-        }
+    // Hide toolbar
+    const toolbar = document.querySelector('.toolbar');
+    if (toolbar) {
+        elementsToHide.push({ elem: toolbar, display: toolbar.style.display });
+        toolbar.style.display = 'none';
     }
 
-    // Re-show everything after print
+    // Hide tab bar
+    const tabBar = document.querySelector('.tab-bar');
+    if (tabBar) {
+        elementsToHide.push({ elem: tabBar, display: tabBar.style.display });
+        tabBar.style.display = 'none';
+    }
+
+    // Hide status bar
+    const statusBar = document.querySelector('.status-bar');
+    if (statusBar) {
+        elementsToHide.push({ elem: statusBar, display: statusBar.style.display });
+        statusBar.style.display = 'none';
+    }
+
+    // Hide editor pane
+    const editorPane = document.getElementById(`editor-pane-${activeTabId}`);
+    if (editorPane) {
+        elementsToHide.push({ elem: editorPane, display: editorPane.style.display });
+        editorPane.style.display = 'none';
+    }
+
+    // Hide all dialogs
+    const dialogs = document.querySelectorAll('.dialog, .modal-overlay');
+    dialogs.forEach(dialog => {
+        elementsToHide.push({ elem: dialog, display: dialog.style.display });
+        dialog.style.display = 'none';
+    });
+
+    // Make preview pane full width
+    const previewPane = document.getElementById(`preview-pane-${activeTabId}`);
+    let originalPreviewStyles = {};
+    if (previewPane) {
+        originalPreviewStyles = {
+            position: previewPane.style.position,
+            top: previewPane.style.top,
+            left: previewPane.style.left,
+            width: previewPane.style.width,
+            height: previewPane.style.height,
+            margin: previewPane.style.margin,
+            padding: previewPane.style.padding
+        };
+        previewPane.style.position = 'absolute';
+        previewPane.style.top = '0';
+        previewPane.style.left = '0';
+        previewPane.style.width = '100%';
+        previewPane.style.height = 'auto';
+        previewPane.style.margin = '0';
+        previewPane.style.padding = '20px';
+    }
+
+    // Apply no-styles if needed
+    if (!withStyles && previewContent) {
+        previewContent.style.color = '#000';
+        previewContent.style.background = '#fff';
+    }
+
+    // Wait for DOM updates then print
     setTimeout(() => {
-        document.getElementById('editor-container').style.display = '';
-        document.getElementById('toolbar').style.display = '';
-        document.getElementById('tab-bar').style.display = '';
-        document.getElementById('status-bar').style.display = '';
+        ipcRenderer.send('do-print', { withStyles });
 
-        const preview = document.getElementById('preview');
-        if (preview) {
-            preview.classList.remove('print-mode', 'print-no-styles');
+        // Restore everything after print dialog opens
+        setTimeout(() => {
+            // Restore hidden elements
+            elementsToHide.forEach(({ elem, display }) => {
+                elem.style.display = display;
+            });
+
+            // Restore preview pane styles
+            if (previewPane) {
+                Object.assign(previewPane.style, originalPreviewStyles);
+            }
+
+            // Restore preview content styles
+            if (!withStyles && previewContent) {
+                previewContent.style.color = '';
+                previewContent.style.background = '';
             }
         }, 500);
-});
+    }, 200);
+}
 
 // Export Dialog functionality
 let currentExportFormat = null;

src/styles.css

@@ -1098,6 +1098,117 @@ body.theme-dark #add-metadata-field {
     color: #f0f0f0;
 }
 
+/* PDF Editor Specific Styles */
+.pdf-editor-content {
+    max-width: 600px !important;
+    max-height: 85vh;
+    overflow-y: auto;
+}
+
+.pdf-editor-body {
+    min-height: 200px;
+    max-height: calc(85vh - 150px);
+    overflow-y: auto;
+}
+
+.pdf-operation-section {
+    animation: fadeIn 0.3s ease-in;
+}
+
+@keyframes fadeIn {
+    from {
+        opacity: 0;
+        transform: translateY(-10px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.pdf-operation-section.hidden {
+    display: none !important;
+}
+
+/* Make PDF Editor sections more compact */
+.pdf-operation-section .export-section {
+    margin-bottom: 18px;
+}
+
+.pdf-operation-section .export-section:last-child {
+    margin-bottom: 0;
+}
+
+/* File list styling for merge operation */
+.file-list {
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 10px;
+    margin-bottom: 10px;
+    min-height: 100px;
+    max-height: 200px;
+    overflow-y: auto;
+    background: #fafafa;
+}
+
+.file-entry {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 8px;
+    margin-bottom: 6px;
+    background: white;
+    border: 1px solid #e0e0e0;
+    border-radius: 4px;
+}
+
+.file-entry:last-child {
+    margin-bottom: 0;
+}
+
+.file-name {
+    flex: 1;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    margin-right: 10px;
+    font-size: 13px;
+}
+
+.remove-file {
+    padding: 4px 10px;
+    background: #dc3545;
+    color: white;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 12px;
+}
+
+.remove-file:hover {
+    background: #c82333;
+}
+
+/* Theme support for PDF Editor */
+body.theme-dark .file-list {
+    background: #1a1a1a;
+    border-color: #555;
+}
+
+body.theme-dark .file-entry {
+    background: #2d2d2d;
+    border-color: #444;
+    color: #f0f0f0;
+}
+
+body.theme-dark .pdf-editor-content {
+    background: #2d2d2d;
+}
+
+body.theme-dark .pdf-editor-body {
+    background: #2d2d2d;
+}
+
 body.theme-dark .form-row button:hover,
 body.theme-dark #add-metadata-field:hover {
     background: #333;
@@ -2833,14 +2944,19 @@ body.theme-concrete-warm .status-bar {
     #editor-container,
     .editor-container,
     #status-bar,
-    .status-bar {
+    .status-bar,
+    .editor-pane,
+    [id^="editor-pane-"] {
         display: none !important;
     }
 
     /* Show preview in full width */
     #preview,
     .preview,
-    .preview-content {
+    .preview-content,
+    [id^="preview-"],
+    [id^="preview-pane-"],
+    .tab-content {
         display: block !important;
         width: 100% !important;
         max-width: 100% !important;
@@ -2848,10 +2964,12 @@ body.theme-concrete-warm .status-bar {
         margin: 0 !important;
         padding: 20px !important;
         overflow: visible !important;
+        position: static !important;
     }
 
     /* Optimize preview content for printing */
-    .preview-content {
+    .preview-content,
+    [id^="preview-"] {
         line-height: 1.6;
         font-size: 12pt;
         color: #000 !important;
@@ -2956,13 +3074,33 @@ body.theme-concrete-warm .status-bar {
     display: block !important;
     width: 100% !important;
     max-width: 100% !important;
+    position: fixed !important;
+    top: 0 !important;
+    left: 0 !important;
+    z-index: 9999 !important;
+    background: white !important;
+    padding: 20px !important;
 }
 
+/* Ensure preview panes are visible in print mode */
+#preview-pane-1, #preview-pane-2, #preview-pane-3, #preview-pane-4, #preview-pane-5 {
+    display: block !important;
+}
+
+/* No-styles printing mode */
+body.printing-no-styles .preview-content,
+body.printing-no-styles [id^="preview-"],
 .print-no-styles .preview-content {
     color: #000 !important;
     background: white !important;
 }
 
+body.printing-no-styles .preview-content h1,
+body.printing-no-styles .preview-content h2,
+body.printing-no-styles .preview-content h3,
+body.printing-no-styles .preview-content h4,
+body.printing-no-styles .preview-content h5,
+body.printing-no-styles .preview-content h6,
 .print-no-styles .preview-content h1,
 .print-no-styles .preview-content h2,
 .print-no-styles .preview-content h3,
@@ -2973,11 +3111,13 @@ body.theme-concrete-warm .status-bar {
     border-color: #999 !important;
 }
 
+body.printing-no-styles .preview-content code,
 .print-no-styles .preview-content code {
     background: #f5f5f5 !important;
     color: #000 !important;
 }
 
+body.printing-no-styles .preview-content pre,
 .print-no-styles .preview-content pre {
     background: #f5f5f5 !important;
     color: #000 !important;

src/wordTemplateExporter.js

@@ -0,0 +1,618 @@
+/**
+ * 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, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&apos;');
+    }
+}
+
+module.exports = WordTemplateExporter;

test-double-click.md

@@ -0,0 +1,12 @@
+# Test Double-Click File Opening
+
+This is a test file to verify double-click functionality.
+
+## Features to Test
+- File should load automatically
+- Content should display in editor
+- Tab should show filename
+- Preview should render markdown
+
+**This text should be bold**
+*This text should be italic*

test-file-open.md

@@ -0,0 +1,14 @@
+# Test File Opening
+
+This is a test file to verify that double-click file opening works correctly.
+
+## Features
+- **Bold text**
+- *Italic text*
+- `Code`
+
+```javascript
+console.log("Hello World");
+```
+
+This should appear when you double-click to open the file!