${enhancedMarkdown}`;
} catch (error) {
if (error.message.includes('WebGPU')) {
alert('WebGPU not supported. Please use Chrome 113+ or Edge 113+.');
} else {
console.error('Conversion failed:', error.message);
}
}
```
### Response
#### Success Response (200)
- **enhancedMarkdown** (string) - The converted and AI-enhanced Markdown content.
```
--------------------------------
### Handle Extract2MD Errors
Source: https://github.com/hashangit/extract2md/blob/main/MIGRATION.md
Illustrates robust error handling for the new Extract2MD API. It shows how to catch specific error types like ConfigurationError, OCRError, and WebLLMError, allowing for targeted user feedback and debugging. General errors are also caught for comprehensive error management.
```javascript
try {
const result = await Extract2MDConverter.quickConvertOnly(pdfFile, config);
} catch (error) {
if (error.name === 'ConfigurationError') {
console.error('Configuration issue:', error.message);
} else if (error.name === 'OCRError') {
console.error('OCR processing failed:', error.message);
} else if (error.name === 'WebLLMError') {
console.error('LLM processing failed:', error.message);
} else {
console.error('General error:', error.message);
}
}
```
--------------------------------
### Node.js Server Deployment Configuration
Source: https://github.com/hashangit/extract2md/blob/main/DEPLOYMENT.md
Demonstrates server-side usage of Extract2MD, focusing on configuration validation. Note that full functionality might be limited due to browser dependencies.
```javascript
// Server-side usage (configuration validation only)
import { ConfigValidator } from 'extract2md/src/utils/ConfigValidator.js';
const validator = new ConfigValidator();
const isValid = validator.validate(config);
```
--------------------------------
### Migrate from Legacy API
Source: https://github.com/hashangit/extract2md/blob/main/README.md
Compares the usage of the legacy `LegacyExtract2MDConverter` API with the recommended new API for PDF conversion tasks like quick conversion, high-accuracy conversion, and LLM rewriting.
```javascript
import { LegacyExtract2MDConverter } from 'extract2md';
// Old way
const converter = new LegacyExtract2MDConverter(options);
const quick = await converter.quickConvert(pdfFile);
const ocr = await converter.highAccuracyConvert(pdfFile);
const enhanced = await converter.llmRewrite(text);
// New way (recommended)
const quick = await Extract2MDConverter.quickConvertOnly(pdfFile, config);
const ocr = await Extract2MDConverter.highAccuracyConvertOnly(pdfFile, config);
const enhanced = await Extract2MDConverter.quickConvertWithLLM(pdfFile, config);
```
--------------------------------
### Lazy Loading Module with JavaScript
Source: https://github.com/hashangit/extract2md/blob/main/DEPLOYMENT.md
Demonstrates how to implement lazy loading for the Extract2MDConverter module, ensuring it's only loaded when explicitly needed. This improves initial load times by deferring the import of the module.
```javascript
const { Extract2MDConverter } = await import('extract2md');
```
--------------------------------
### Comprehensive PDF to Markdown Conversion with LLM Merging (JavaScript)
Source: https://context7.com/hashangit/extract2md/llms.txt
Combines PDF.js and Tesseract.js extraction in parallel, then uses an LLM to intelligently merge and enhance the results for the highest quality output. This method requires specifying paths for Tesseract.js workers and language data. It takes a PDF file and a configuration object, returning the comprehensive Markdown.
```javascript
import { Extract2MDConverter } from 'extract2md';
const pdfFile = document.getElementById('pdfInput').files[0];
const config = {
pdfJsWorkerSrc: '/pdf.worker.min.mjs',
tesseract: {
workerPath: '/tesseract-worker.min.js',
corePath: '/tesseract-core.wasm.js',
langPath: '/lang-data/',
language: 'eng'
},
webllm: {
model: 'Qwen3-0.6B-q4f16_1-MLC',
options: {
temperature: 0.7,
maxTokens: 4096
}
},
systemPrompts: {
combinedExtraction: 'Create comprehensive documentation by merging both sources. Preserve all technical details and code examples.'
},
processing: {
splitPascalCase: false,
pdfRenderScale: 2.5,
postProcessRules: [
{ find: /\bAPI\b/g, replace: 'API' }
]
},
progressCallback: (progress) => {
const statusEl = document.getElementById('status');
statusEl.textContent = `${progress.stage}: ${progress.message}`;
if (progress.stage === 'scenario_5_complete') {
statusEl.textContent = 'Conversion completed successfully!';
}
}
};
try {
const comprehensiveMarkdown = await Extract2MDConverter.combinedConvertWithLLM(pdfFile, config);
document.getElementById('output').innerHTML = marked.parse(comprehensiveMarkdown);
} catch (error) {
console.error('Combined conversion failed:', error);
}
```
--------------------------------
### Update Conversion Progress Display (JavaScript)
Source: https://github.com/hashangit/extract2md/blob/main/examples/demo.html
A function to visually update the user on the PDF conversion progress. It displays messages, page numbers, loading percentages, and token usage, making the conversion process transparent. Errors encountered during conversion are also displayed.
```javascript
function updateProgress(progress) {
const progressDiv = document.getElementById('progressDiv');
const messageEl = document.getElementById('progressMessage');
const detailsEl = document.getElementById('progressDetails');
progressDiv.classList.add('active');
messageEl.textContent = progress.message;
let details = [];
if (progress.currentPage && progress.totalPages) {
const pageProgress = Math.round((progress.currentPage / progress.totalPages) * 100);
details.push(`Page Progress: ${pageProgress}% (${progress.currentPage}/${progress.totalPages})`);
}
if (progress.progress !== undefined) {
const loadProgress = Math.round(progress.progress * 100);
details.push(`Loading: ${loadProgress}%`);
}
if (progress.usage) {
details.push(`Tokens: ${progress.usage.total_tokens || 'N/A'}`);
}
detailsEl.textContent = details.join(' | ');
if (progress.error) {
showError('Conversion Error: ' + (progress.error.message || progress.error));
}
}
```
--------------------------------
### Copy Text to Clipboard (JavaScript)
Source: https://github.com/hashangit/extract2md/blob/main/examples/demo.html
This function copies the content of 'lastResult' to the user's clipboard using the Navigator Clipboard API. It provides visual feedback to the user by changing the button text to 'Copied!' for 2 seconds. It requires 'lastResult' to be defined and accessible.
```javascript
function copyToClipboard() {
if (lastResult) {
navigator.clipboard.writeText(lastResult).then(() => {
const btn = document.querySelector('.copy-btn');
const originalText = btn.textContent;
btn.textContent = 'Copied!';
setTimeout(() => btn.textContent = originalText, 2000);
});
}
}
```
--------------------------------
### Use Extract2MD via CDN in HTML
Source: https://github.com/hashangit/extract2md/blob/main/DEPLOYMENT.md
Includes the Extract2MD UMD bundle from a CDN in an HTML file, making it available as a global variable for direct use in the browser. Demonstrates a basic conversion function.
```html
```
--------------------------------
### High-Accuracy OCR PDF to Markdown Conversion with Tesseract.js
Source: https://context7.com/hashangit/extract2md/llms.txt
Performs OCR-based PDF conversion using Tesseract.js, ideal for scanned documents or images. This method renders pages to canvas and applies OCR, offering higher accuracy at the cost of speed. Configuration includes Tesseract worker paths, language data, and rendering scale for improved accuracy. Progress is reported during OCR processing.
```javascript
import { Extract2MDConverter } from 'extract2md';
const pdfFile = document.getElementById('pdfInput').files[0];
const config = {
tesseract: {
workerPath: '/tesseract-worker.min.js',
corePath: '/tesseract-core.wasm.js',
langPath: '/lang-data/',
language: 'eng', // Use 'eng+fra' for multiple languages
options: {}
},
processing: {
pdfRenderScale: 2.5 // Higher scale = better OCR accuracy
},
progressCallback: (progress) => {
if (progress.stage === 'ocr_page_process') {
const percent = Math.round((progress.currentPage / progress.totalPages) * 100);
document.getElementById('status').textContent = `OCR Processing: ${percent}%`;
}
}
};
try {
const markdown = await Extract2MDConverter.highAccuracyConvertOnly(pdfFile, config);
console.log('OCR conversion complete:', markdown.length, 'characters');
} catch (error) {
if (error.message.includes('Tesseract worker')) {
console.error('OCR worker failed to initialize. Check worker paths.');
} else {
console.error('OCR conversion failed:', error.message);
}
}
```
--------------------------------
### Basic Markdown Extraction with Extract2MD
Source: https://context7.com/hashangit/extract2md/llms.txt
Demonstrates basic markdown extraction from raw output using the Extract2MD parser. It cleans and formats the content, removing specific elements like thinking blocks.
```javascript
const { Extract2MDConverter } = require('extract2md');
const parser = new Extract2MDConverter();
const rawOutput = "# Document Title\n\nThis is the cleaned content with proper formatting.\n\n- Item 1\n- Item 2\n`;
const cleanedOutput = parser.parse(rawOutput);
console.log(cleanedOutput);
// Output: "# Document Title\n\nThis is the cleaned content with proper formatting.\n\n- Item 1\n- Item 2"
```
```javascript
// Remove thinking blocks specifically
const noThinking = parser.removeThinkingBlocks(rawOutput);
// Validate markdown output
const validation = parser.validateMarkdown(cleanedOutput);
console.log('Is valid:', validation.isValid);
console.log('Issues:', validation.issues);
// Apply custom cleanup rules
const customRules = [
{ find: /\bfoo\b/g, replace: 'bar' },
{ find: /\s+$/gm, replace: '' }
];
const customCleaned = parser.applyCustomRules(cleanedOutput, customRules);
// Extract just the markdown content from verbose LLM responses
const verboseResponse = "Here's the rewritten text:\n\n# Actual Content\nThe document content...";
const pureMarkdown = parser.extractMarkdownContent(verboseResponse);
```
--------------------------------
### Configuring CDN for Worker Paths in JavaScript
Source: https://github.com/hashangit/extract2md/blob/main/DEPLOYMENT.md
Shows how to configure Extract2MD to use a Content Delivery Network (CDN) for its static assets, specifically worker files like PDF and Tesseract. This can improve loading performance by serving assets from geographically closer servers.
```javascript
window.EXTRACT2MD_CONFIG = {
workerPaths: {
pdf: 'https://cdn.example.com/pdf.worker.min.mjs',
tesseract: 'https://cdn.example.com/tesseract-worker.min.js'
}
};
```
--------------------------------
### Extract2MDConverter.highAccuracyConvertWithLLM
Source: https://context7.com/hashangit/extract2md/llms.txt
Combines Tesseract.js OCR extraction with WebLLM AI enhancement, ideal for scanned documents requiring accurate text recognition and AI-driven formatting improvements.
```APIDOC
## Extract2MDConverter.highAccuracyConvertWithLLM
### Description
Combines Tesseract.js OCR extraction with WebLLM AI enhancement. Ideal for scanned documents that need both accurate text recognition and improved formatting through AI processing.
### Method
`Extract2MDConverter.highAccuracyConvertWithLLM(pdfFile, config)`
### Parameters
#### Path Parameters
None
#### Query Parameters
None
#### Request Body
- **pdfFile** (File) - The PDF file to convert.
- **config** (Object) - Configuration object for the conversion process.
- **tesseract** (Object) - Tesseract.js configuration.
- **language** (string) - Language for OCR (e.g., 'eng').
- **options** (Object) - Tesseract.js options.
- **webllm** (Object) - WebLLM configuration.
- **model** (string) - The LLM model to use (e.g., 'Qwen3-0.6B-q4f16_1-MLC').
- **options** (Object) - LLM generation options (e.g., `temperature`, `maxTokens`).
- **processing** (Object) - Processing options.
- **pdfRenderScale** (number) - Scale factor for rendering PDF pages for OCR (higher for better accuracy on scanned docs).
- **progressCallback** (Function) - Callback function to track conversion progress and errors.
### Request Example
```javascript
import { Extract2MDConverter } from 'extract2md';
const pdfFile = document.getElementById('pdfInput').files[0];
const config = {
tesseract: {
language: 'eng',
options: {}
},
webllm: {
model: 'Qwen3-0.6B-q4f16_1-MLC',
options: {
temperature: 0.7,
maxTokens: 4096
}
},
processing: {
pdfRenderScale: 3.0 // Higher for better OCR on scanned docs
},
progressCallback: (progress) => {
document.getElementById('status').textContent = progress.message;
if (progress.error) {
console.error('Processing error:', progress.error);
}
}
};
const result = await Extract2MDConverter.highAccuracyConvertWithLLM(pdfFile, config);
console.log('High accuracy + LLM result:', result);
```
### Response
#### Success Response (200)
- **result** (Object) - An object containing the conversion results. The exact structure may vary, but typically includes the processed Markdown content.
```
--------------------------------
### Import Extract2MD using ES6 Modules
Source: https://github.com/hashangit/extract2md/blob/main/DEPLOYMENT.md
Imports the Extract2MD converter using ES6 module syntax. This method is suitable for modern bundlers and supports tree shaking for optimized builds.
```javascript
import { Extract2MDConverter } from 'extract2md';
// Use ES6 modules with tree shaking support
```
--------------------------------
### Quick PDF to Markdown Conversion with WebLLM Enhancement (JavaScript)
Source: https://context7.com/hashangit/extract2md/llms.txt
Converts PDF to Markdown using PDF.js extraction and enhances the output with a local LLM for improved clarity and formatting. Requires WebGPU support in the browser. The function takes a PDF file and a configuration object, returning the enhanced Markdown string.
```javascript
import { Extract2MDConverter } from 'extract2md';
const pdfFile = document.getElementById('pdfInput').files[0];
const config = {
webllm: {
model: 'Qwen3-0.6B-q4f16_1-MLC',
options: {
temperature: 0.7,
maxTokens: 4096
}
},
systemPrompts: {
singleExtraction: 'Focus on preserving code examples and technical terms exactly.'
},
progressCallback: (progress) => {
switch (progress.stage) {
case 'webllm_load_progress':
console.log(`Loading LLM: ${Math.round(progress.progress * 100)}%`);
break;
case 'webllm_generate_start':
console.log('AI enhancement in progress...');
break;
case 'scenario_3_complete':
console.log('Conversion with LLM enhancement completed!');
break;
}
}
};
try {
const enhancedMarkdown = await Extract2MDConverter.quickConvertWithLLM(pdfFile, config);
document.getElementById('output').innerHTML = `${enhancedMarkdown}`;
} catch (error) {
if (error.message.includes('WebGPU')) {
alert('WebGPU not supported. Please use Chrome 113+ or Edge 113+.');
} else {
console.error('Conversion failed:', error.message);
}
}
```
--------------------------------
### React Integration for PDF to Markdown Conversion
Source: https://github.com/hashangit/extract2md/blob/main/DEPLOYMENT.md
Provides a React component that allows users to upload a PDF file and convert it to Markdown using Extract2MDConverter. It includes state management for loading status and the conversion result, along with basic error handling.
```jsx
import React, { useState } from 'react';
import { Extract2MDConverter } from 'extract2md';
function PDFConverter() {
const [result, setResult] = useState('');
const [loading, setLoading] = useState(false);
const handleConvert = async (file) => {
setLoading(true);
try {
const markdown = await Extract2MDConverter.quickConvertOnly(file, {
tesseract: { language: 'eng', oem: 1, psm: 6 }
});
setResult(markdown);
} catch (error) {
console.error('Conversion failed:', error);
} finally {
setLoading(false);
}
};
return (
Converting...
} {result &&{result}}