Spaces:

ASDAD34
/

docextractor-pro

Running

App Files Files Community

ASDAD34 commited on Nov 29, 2025

Commit

e010252

verified ·

1 Parent(s): 262d37a

olmadı içerikleri çıkarmada zayıf daha iyi araçları ve kütüphaneleri kullan.

Browse files

Files changed (2) hide show

index.html +19 -4
script.js +476 -121

index.html CHANGED Viewed

@@ -8,11 +8,26 @@
     <script src="https://cdn.tailwindcss.com"></script>
     <script src="https://cdn.jsdelivr.net/npm/feather-icons/dist/feather.min.js"></script>
     <script src="https://unpkg.com/feather-icons"></script>
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/pdf.js/2.11.338/pdf.min.js"></script>
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/mammoth/1.4.0/mammoth.browser.min.js"></script>
     <script src="https://cdnjs.cloudflare.com/ajax/libs/xlsx/0.18.5/xlsx.full.min.js"></script>
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/tesseract.js/4.1.1/tesseract.min.js"></script>
-    <script src="script.js"></script>
 </head>
 <body class="bg-gray-50 min-h-screen">
     <custom-navbar></custom-navbar>

     <script src="https://cdn.tailwindcss.com"></script>
     <script src="https://cdn.jsdelivr.net/npm/feather-icons/dist/feather.min.js"></script>
     <script src="https://unpkg.com/feather-icons"></script>
+    <!-- Enhanced PDF Processing -->
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/pdf.js/3.11.174/pdf.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/pdf-lib/1.17.1/pdf-lib.min.js"></script>
+    <!-- Enhanced Document Processing -->
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/mammoth/1.6.0/mammoth.browser.min.js"></script>
     <script src="https://cdnjs.cloudflare.com/ajax/libs/xlsx/0.18.5/xlsx.full.min.js"></script>
+    <!-- Enhanced OCR with Multiple Languages -->
+    <script src="https://cdn.jsdelivr.net/npm/tesseract.js@4/dist/tesseract.min.js"></script>
+    <script src="https://unpkg.com/[email protected]/dist/ocr-space-api.min.js"></script>
+    <!-- Image Processing -->
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/cropperjs/1.6.1/cropper.min.js"></script>
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/cropperjs/1.6.1/cropper.min.css">
+    <!-- Additional Language Support -->
+    <script src="https://cdn.jsdelivr.net/npm/[email protected]/he.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/iconv-lite/0.6.3/iconv-lite.min.js"></script>
+<script src="script.js"></script>
 </head>
 <body class="bg-gray-50 min-h-screen">
     <custom-navbar></custom-navbar>

script.js CHANGED Viewed

@@ -11,11 +11,12 @@ document.addEventListener('DOMContentLoaded', function() {
     let files = [];
     let processedResults = [];
-    // Set PDF.js worker path
-    pdfjsLib.GlobalWorkerOptions.workerSrc = 'https://cdnjs.cloudflare.com/ajax/libs/pdf.js/2.11.338/pdf.worker.min.js';
-    // Handle file selection
     uploadBtn.addEventListener('click', () => fileInput.click());
     fileInput.addEventListener('change', handleFileSelection);
@@ -182,73 +183,100 @@ return {
         };
     }
     async function extractTextFromPDF(file) {
-        return new Promise((resolve, reject) => {
             const reader = new FileReader();
             reader.onload = async function(event) {
                 try {
                     const typedArray = new Uint8Array(event.target.result);
                     const loadingTask = pdfjsLib.getDocument({
                         data: typedArray,
-                        cMapUrl: 'https://cdn.jsdelivr.net/npm/pdfjs-dist@2.11.338/cmaps/',
                         cMapPacked: true,
-                        standardFontDataUrl: 'https://cdn.jsdelivr.net/npm/pdfjs-dist@2.11.338/standard_fonts/'
                     });
                     const pdf = await loadingTask.promise;
                     let fullText = '';
                     for (let i = 1; i <= pdf.numPages; i++) {
                         const page = await pdf.getPage(i);
                         const textContent = await page.getTextContent({
                             normalizeWhitespace: false,
-                            disableCombineTextItems: false
                         });
-                        const pageText = textContent.items
-                            .map(item => item.str)
-                            .join(' ');
-                        if (pageText.trim()) {
-                            fullText += pageText + '\n\n';
-                        }
-                    }
-                    // Try to fix common Turkish character encoding issues
-                    fullText = fullText
-                        .replace(/\u00C3\u00A7/g, 'ç') // ç
-                        .replace(/\u00C3\u0087/g, 'Ç') // Ç
-                        .replace(/\u00C3\u011F/g, 'ğ') // ğ
-                        .replace(/\u00C4\u0178/g, 'Ğ') // Ğ
-                        .replace(/\u00C3\u00BC/g, 'ü') // ü
-                        .replace(/\u00C3\u009C/g, 'Ü') // Ü
-                        .replace(/\u00C3\u015F/g, 'ş') // ş
-                        .replace(/\u00C5\u0178/g, 'Ş') // Ş
-                        .replace(/\u00C3\u0131/g, 'ı') // ı
-                        .replace(/\u00C4\u0131/g, 'İ') // İ
-                        .replace(/\u00C3\u00B6/g, 'ö') // ö
-                        .replace(/\u00C3\u0096/g, 'Ö'); // Ö
-                    if (!fullText.trim()) {
-                        console.warn('PDF text extraction returned empty content. Attempting OCR processing...');
-                        try {
-                            // Convert PDF to image for OCR processing
-                            const images = await convertPDFToImages(typedArray);
-                            let ocrText = '';
-                            for (const image of images) {
-                                const text = await extractTextFromImage(image);
-                                ocrText += text + '\n\n';
                             }
-                            fullText = ocrText || 'OCR processing attempted but no text was found.';
-                        } catch (ocrError) {
-                            console.error('OCR processing failed:', ocrError);
-                            fullText = 'Warning: No extractable text found. OCR processing also failed: ' + ocrError.message;
                         }
                     }
                     resolve(fullText);
-} catch (error) {
                     console.error('PDF extraction error:', error);
                     reject(new Error('Failed to extract text from PDF: ' + error.message));
                 }
@@ -258,122 +286,449 @@ return {
             reader.readAsArrayBuffer(file);
         });
     }
-async function extractTextFromWord(file) {
-        return new Promise((resolve, reject) => {
-            const reader = new FileReader();
-            reader.onload = function(event) {
-                mammoth.extractRawText({ arrayBuffer: event.target.result })
-                    .then(function(result) {
-                        resolve(result.value);
-                    })
-                    .catch(reject);
-            };
-            reader.onerror = reject;
-            reader.readAsArrayBuffer(file);
         });
     }
-    async function extractTextFromExcel(file) {
-        return new Promise((resolve, reject) => {
-            const reader = new FileReader();
-            reader.onload = function(event) {
-                try {
-                    const data = new Uint8Array(event.target.result);
-                    const workbook = XLSX.read(data, { type: 'array' });
-                    const result = {};
-                    workbook.SheetNames.forEach(sheetName => {
-                        const worksheet = workbook.Sheets[sheetName];
-                        result[sheetName] = XLSX.utils.sheet_to_json(worksheet, { header: 1 });
-                    });
-                    resolve(result);
-                } catch (error) {
-                    reject(error);
                 }
             };
-            reader.onerror = reject;
-            reader.readAsArrayBuffer(file);
-        });
     }
-async function convertPDFToImages(pdfData) {
-    return new Promise(async (resolve) => {
         const loadingTask = pdfjsLib.getDocument({
             data: pdfData,
-            cMapUrl: 'https://cdn.jsdelivr.net/npm/pdfjs-dist@2.11.338/cmaps/',
             cMapPacked: true,
-            standardFontDataUrl: 'https://cdn.jsdelivr.net/npm/pdfjs-dist@2.11.338/standard_fonts/'
         });
         const pdf = await loadingTask.promise;
         const images = [];
-        for (let i = 1; i <= Math.min(pdf.numPages, 5); i++) { // Limit to 5 pages
             const page = await pdf.getPage(i);
-            const viewport = page.getViewport({ scale: 1.5 });
             const canvas = document.createElement('canvas');
             const context = canvas.getContext('2d');
             canvas.height = viewport.height;
             canvas.width = viewport.width;
             await page.render({
                 canvasContext: context,
-                viewport: viewport
             }).promise;
             images.push(canvas);
         }
-        resolve(images);
-    });
-}
-async function extractTextFromImage(file) {
-    return new Promise((resolve, reject) => {
-        // Apply learned corrections before OCR if any exist
-        let trainedWords = {};
-        if (window.ocrLearningDict) {
-            for (const [word, data] of Object.entries(window.ocrLearningDict)) {
-                if (data.confirmedCorrect && data.confirmedCorrect !== word) {
-                    trainedWords[word] = data.confirmedCorrect;
                 }
-            }
-        }
-const imageElement = file instanceof HTMLCanvasElement ?
-                            file :
-                            file;
-                        Tesseract.recognize(
-                            imageElement,
-'tur+eng', // Turkish + English languages
-                {
-                    logger: m => console.log(m),
-                    preserve_interword_spaces: true,
-                    tessedit_pageseg_mode: 6, // Assume a single uniform block of text
-                    tessedit_char_whitelist: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,!?-(){}[]/\\\'" ğüşıöçĞÜŞİÖÇ', // Added Turkish chars
                     user_defined_words: Object.keys(trainedWords).join(' '),
-                    user_words: Object.values(trainedWords).join(' '),
-tessedit_create_hocr: 1, // Include formatting info
-                    load_system_dawg: 1,
-                    load_freq_dawg: 1,
                     user_words_suffix: 'tur',
-                    user_patterns_suffix: 'tur'
-}
-            ).then(({ data: { text, hocr } }) => {
-                if (outputFormat.value === 'formatted') {
-                    // Process formatted output similar to Adobe/Abbyy
-                    const formatted = processFormattedOCR(hocr);
-                    resolve(formatted);
                 } else {
-                    resolve(text);
                 }
-            }).catch(reject);
         });
-    function processFormattedOCR(hocr) {
         // Apply learned corrections
         if (window.ocrLearningDict) {
             for (const [word, data] of Object.entries(window.ocrLearningDict)) {

     let files = [];
     let processedResults = [];
+    // Set enhanced PDF.js worker path with additional configurations
+    pdfjsLib.GlobalWorkerOptions.workerSrc = 'https://cdnjs.cloudflare.com/ajax/libs/pdf.js/3.11.174/pdf.worker.min.js';
+    // Configure PDF.js for better text extraction
+    pdfjsLib.GlobalWorkerOptions.isEvalSupported = false;
+// Handle file selection
     uploadBtn.addEventListener('click', () => fileInput.click());
     fileInput.addEventListener('change', handleFileSelection);
         };
     }
     async function extractTextFromPDF(file) {
+        return new Promise(async (resolve, reject) => {
             const reader = new FileReader();
             reader.onload = async function(event) {
                 try {
                     const typedArray = new Uint8Array(event.target.result);
+                    // Enhanced PDF loading with multiple extraction strategies
                     const loadingTask = pdfjsLib.getDocument({
                         data: typedArray,
+                        cMapUrl: 'https://cdn.jsdelivr.net/npm/pdfjs-dist@3.11.174/cmaps/',
                         cMapPacked: true,
+                        standardFontDataUrl: 'https://cdn.jsdelivr.net/npm/pdfjs-dist@3.11.174/standard_fonts/',
+                        useSystemFonts: true,
+                        useWorkerFetch: true,
+                        isEvalSupported: false,
+                        disableAutoFetch: false,
+                        disableStream: false
                     });
                     const pdf = await loadingTask.promise;
                     let fullText = '';
+                    let metadata = await pdf.getMetadata();
+                    // Strategy 1: Enhanced text extraction with structural analysis
                     for (let i = 1; i <= pdf.numPages; i++) {
                         const page = await pdf.getPage(i);
+                        // Get viewport for better text positioning
+                        const viewport = page.getViewport({ scale: 2.0 });
+                        // Enhanced text content extraction
                         const textContent = await page.getTextContent({
                             normalizeWhitespace: false,
+                            disableCombineTextItems: false,
+                            includeMarkedContent: true
                         });
+                        // Process text items with better grouping
+                        const textItems = textContent.items;
+                        let pageText = '';
+                        let lastY = null;
+                        let lastX = null;
+                        for (let j = 0; j < textItems.length; j++) {
+                            const item = textItems[j];
+                            const tx = pdfjsLib.Util.transform(
+                                viewport.transform,
+                                item.transform
+                            );
+                            const x = tx[4];
+                            const y = tx[5];
+                            // Add line breaks based on Y position
+                            if (lastY !== null && Math.abs(y - lastY) > item.height * 0.8) {
+                                pageText += '\n';
                             }
+                            // Add spaces based on X position
+                            if (lastX !== null && x - lastX > item.width * 0.3) {
+                                pageText += ' ';
+                            }
+                            pageText += item.str;
+                            lastY = y;
+                            lastX = x + item.width;
+                        }
+                        // Clean up and format the text
+                        pageText = pageText
+                            .replace(/\s+/g, ' ')
+                            .replace(/\n\s*\n/g, '\n\n')
+                            .trim();
+                        if (pageText) {
+                            fullText += pageText + '\n\n';
                         }
                     }
+                    // Strategy 2: Enhanced Turkish character decoding
+                    fullText = decodeTurkishText(fullText);
+                    // Strategy 3: If still poor quality, try OCR with preprocessing
+                    if (!fullText.trim() || fullText.trim().length < 50) {
+                        console.warn('Primary text extraction failed, attempting enhanced OCR...');
+                        fullText = await enhancedOCRFallback(typedArray);
+                    }
+                    // Strategy 4: Apply text quality improvements
+                    fullText = improveTextQuality(fullText);
                     resolve(fullText);
+                } catch (error) {
                     console.error('PDF extraction error:', error);
                     reject(new Error('Failed to extract text from PDF: ' + error.message));
                 }
             reader.readAsArrayBuffer(file);
         });
     }
+    // Enhanced Turkish text decoding
+    function decodeTurkishText(text) {
+        // Multiple encoding fixes for Turkish characters
+        const fixes = [
+            // UTF-8 double encoding
+            [/\u00C3\u00A7/g, 'ç'], [/\u00C3\u0087/g, 'Ç'],
+            [/\u00C3\u011F/g, 'ğ'], [/\u00C4\u0178/g, 'Ğ'],
+            [/\u00C3\u00BC/g, 'ü'], [/\u00C3\u009C/g, 'Ü'],
+            [/\u00C3\u015F/g, 'ş'], [/\u00C5\u0178/g, 'Ş'],
+            [/\u00C3\u0131/g, 'ı'], [/\u00C4\u0131/g, 'İ'],
+            [/\u00C3\u00B6/g, 'ö'], [/\u00C3\u0096/g, 'Ö'],
+            // ISO-8859-9 to UTF-8
+            [/[\u00C4\u00E4]/g, 'ä'], [/[\u00C5\u00E5]/g, 'å'],
+            [/[\u00C6\u00E6]/g, 'æ'], [/[\u00C7\u00E7]/g, 'ç'],
+            [/[\u00D0\u00F0]/g, 'ð'], [/[\u011E\u011F]/g, 'ğ'],
+            [/[\u0130\u0131]/g, 'ı'], [/[\u015E\u015F]/g, 'ş'],
+            [/[\u00D6\u00F6]/g, 'ö'], [/[\u00DC\u00FC]/g, 'ü'],
+            [/[\u00DE\u00FE]/g, 'þ'],
+            // Common OCR errors
+            [/c/g, 'ç', { context: 'turkish' }], [/C/g, 'Ç', { context: 'turkish' }],
+            [/g/g, 'ğ', { context: 'turkish' }], [/G/g, 'Ğ', { context: 'turkish' }],
+            [/i/g, 'ı', { context: 'turkish' }], [/I/g, 'İ', { context: 'turkish' }],
+            [/o/g, 'ö', { context: 'turkish' }], [/O/g, 'Ö', { context: 'turkish' }],
+            [/s/g, 'ş', { context: 'turkish' }], [/S/g, 'Ş', { context: 'turkish' }],
+            [/u/g, 'ü', { context: 'turkish' }], [/U/g, 'Ü', { context: 'turkish' }]
+        ];
+        let decodedText = text;
+        fixes.forEach(fix => {
+            if (Array.isArray(fix) && fix.length === 2) {
+                decodedText = decodedText.replace(fix[0], fix[1]);
+            }
         });
+        // Apply HTML entity decoding if needed
+        try {
+            decodedText = he.decode(decodedText);
+        } catch (e) {
+            console.warn('HTML decoding failed:', e);
+        }
+        return decodedText;
     }
+    // Enhanced OCR fallback with multiple engines
+    async function enhancedOCRFallback(pdfData) {
+        const images = await convertPDFToImagesEnhanced(pdfData);
+        let ocrResults = [];
+        for (const image of images) {
+            // Try multiple OCR approaches
+            const results = await Promise.allSettled([
+                // Tesseract with Turkish and English
+                extractTextWithTesseract(image, 'tur+eng'),
+                // Tesseract with additional preprocessing
+                extractTextWithTesseract(image, 'tur+eng', { preprocess: true }),
+                // Fallback to English only if Turkish fails
+                extractTextWithTesseract(image, 'eng')
+            ]);
+            // Find the best result
+            let bestResult = '';
+            let maxLength = 0;
+            results.forEach(result => {
+                if (result.status === 'fulfilled' && result.value.length > maxLength) {
+                    bestResult = result.value;
+                    maxLength = result.value.length;
                 }
+            });
+            if (bestResult) {
+                ocrResults.push(bestResult);
+            }
+        }
+        return ocrResults.join('\n\n') || 'OCR processing completed but no text was extracted.';
+    }
+    // Enhanced Tesseract extraction
+    async function extractTextWithTesseract(image, languages = 'tur+eng', options = {}) {
+        try {
+            const config = {
+                logger: m => console.log(`Tesseract: ${m.status} - ${Math.round(m.progress * 100)}%`),
+                preserve_interword_spaces: '1',
+                tessedit_pageseg_mode: '6',
+                tessedit_char_whitelist: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,!?-(){}[]/\\\'" ğüşıöçĞÜŞİÖÇ@#$%^&*+=<>:;_ ',
+                load_system_dawg: '1',
+                load_freq_dawg: '1'
             };
+            if (options.preprocess) {
+                // Apply image preprocessing
+                image = await preprocessImage(image);
+            }
+            const result = await Tesseract.recognize(image, languages, config);
+            return result.data.text;
+        } catch (error) {
+            console.error('Tesseract OCR error:', error);
+            throw error;
+        }
+    }
+    // Image preprocessing for better OCR
+    async function preprocessImage(canvas) {
+        const ctx = canvas.getContext('2d');
+        const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+        const data = imageData.data;
+        // Convert to grayscale
+        for (let i = 0; i < data.length; i += 4) {
+            const gray = data[i] * 0.299 + data[i + 1] * 0.587 + data[i + 2] * 0.114;
+            data[i] = gray;
+            data[i + 1] = gray;
+            data[i + 2] = gray;
+        }
+        // Apply adaptive thresholding
+        const threshold = 128;
+        for (let i = 0; i < data.length; i += 4) {
+            const value = data[i] > threshold ? 255 : 0;
+            data[i] = value;
+            data[i + 1] = value;
+            data[i + 2] = value;
+        }
+        ctx.putImageData(imageData, 0, 0);
+        return canvas;
     }
+    // Enhanced PDF to image conversion
+    async function convertPDFToImagesEnhanced(pdfData) {
         const loadingTask = pdfjsLib.getDocument({
             data: pdfData,
+            cMapUrl: 'https://cdn.jsdelivr.net/npm/pdfjs-dist@3.11.174/cmaps/',
             cMapPacked: true,
+            standardFontDataUrl: 'https://cdn.jsdelivr.net/npm/pdfjs-dist@3.11.174/standard_fonts/'
         });
         const pdf = await loadingTask.promise;
         const images = [];
+        // Process all pages with higher resolution
+        for (let i = 1; i <= Math.min(pdf.numPages, 10); i++) {
             const page = await pdf.getPage(i);
+            const viewport = page.getViewport({ scale: 3.0 });
             const canvas = document.createElement('canvas');
             const context = canvas.getContext('2d');
             canvas.height = viewport.height;
             canvas.width = viewport.width;
+            // Render with better quality
             await page.render({
                 canvasContext: context,
+                viewport: viewport,
+                renderInteractiveForms: true,
+                intent: 'print'
             }).promise;
             images.push(canvas);
         }
+        return images;
+    }
+    // Text quality improvement
+    function improveTextQuality(text) {
+        return text
+            // Fix common OCR errors in Turkish
+            .replace(/\bi\b/g, 'ı') // Turkish dotless i
+            .replace(/\bI\b/g, 'İ') // Turkish capital I with dot
+            .replace(/c([aeiou])/gi, 'ç$1') // c followed by vowel -> ç
+            .replace(/C([AEIOU])/g, 'Ç$1')
+            .replace(/g([aeiou])/gi, 'ğ$1') // g followed by vowel -> ğ
+            .replace(/G([AEIOU])/g, 'Ğ$1')
+            .replace(/s([aeiou])/gi, 'ş$1') // s followed by vowel -> ş
+            .replace(/S([AEIOU])/g, 'Ş$1')
+            .replace(/o([aeiou])/gi, 'ö$1') // o followed by vowel -> ö
+            .replace(/O([AEIOU])/g, 'Ö$1')
+            .replace(/u([aeiou])/gi, 'ü$1') // u followed by vowel -> ü
+            .replace(/U([AEIOU])/g, 'Ü$1')
+            // Clean up spacing
+            .replace(/\s+/g, ' ')
+            .replace(/\n\s*\n/g, '\n\n')
+            // Fix common character confusion
+            .replace(/0/g, 'O', { condition: context => /[A-Z]/.test(context.after) })
+            .replace(/1/g, 'I', { condition: context => /[A-Z]/.test(context.after) })
+            .replace(/5/g, 'S', { condition: context => /[A-Z]/.test(context.after) })
+            .trim();
+    }
+    async function extractTextFromWord(file) {
+        return new Promise(async (resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = async function(event) {
+                try {
+                    // Enhanced Word document extraction
+                    const result = await mammoth.extractRawText({
+                        arrayBuffer: event.target.result,
+                        options: {
+                            includeDefaultStyleMap: true,
+                            styleMap: [
+                                "p[style-name='Heading 1'] => h1:fresh",
+                                "p[style-name='Heading 2'] => h2:fresh",
+                                "p[style-name='Heading 3'] => h3:fresh",
+                                "p[style-name='Title'] => h1.title:fresh",
+                                "r[style-name='Strong'] => strong",
+                                "r[style-name='Emphasis'] => em"
+                            ]
+                        }
+                    });
+                    let text = result.value;
+                    // Apply Turkish character decoding
+                    text = decodeTurkishText(text);
+                    // Apply text quality improvements
+                    text = improveTextQuality(text);
+                    // Try alternative extraction if result is poor
+                    if (text.trim().length < 50) {
+                        console.warn('Primary Word extraction failed, trying alternative...');
+                        const altResult = await mammoth.convertToMarkdown({
+                            arrayBuffer: event.target.result
+                        });
+                        if (altResult.value && altResult.value.trim().length > text.trim().length) {
+                            text = altResult.value;
+                            text = decodeTurkishText(text);
+                            text = improveTextQuality(text);
+                        }
+                    }
+                    resolve(text);
+                } catch (error) {
+                    reject(error);
                 }
+            };
+            reader.onerror = reject;
+            reader.readAsArrayBuffer(file);
+        });
+    }
+    async function extractTextFromExcel(file) {
+        return new Promise(async (resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = async function(event) {
+                try {
+                    const data = new Uint8Array(event.target.result);
+                    // Enhanced Excel reading with Turkish support
+                    const workbook = XLSX.read(data, {
+                        type: 'array',
+                        codepage: 1254, // Turkish codepage
+                        cellStyles: true,
+                        cellHTML: false
+                    });
+                    const result = {};
+                    workbook.SheetNames.forEach(sheetName => {
+                        const worksheet = workbook.Sheets[sheetName];
+                        // Try multiple extraction methods
+                        const jsonData = XLSX.utils.sheet_to_json(worksheet, {
+                            header: 1,
+                            raw: false,
+                            dateNF: 'dd/mm/yyyy',
+                            defval: ''
+                        });
+                        const csvData = XLSX.utils.sheet_to_csv(worksheet, {
+                            FS: '\t',
+                            RS: '\n',
+                            dateNF: 'dd/mm/yyyy'
+                        });
+                        // Process data with Turkish character support
+                        const processedData = jsonData.map(row =>
+                            row.map(cell => {
+                                if (typeof cell === 'string') {
+                                    return decodeTurkishText(improveTextQuality(cell));
+                                }
+                                return cell;
+                            })
+                        );
+                        result[sheetName] = {
+                            data: processedData,
+                            csv: decodeTurkishText(csvData),
+                            range: worksheet['!ref'] || '',
+                            rowCount: jsonData.length,
+                            colCount: jsonData[0] ? jsonData[0].length : 0
+                        };
+                    });
+                    resolve(result);
+                } catch (error) {
+                    reject(error);
+                }
+            };
+            reader.onerror = reject;
+            reader.readAsArrayBuffer(file);
+        });
+    }
+    async function convertPDFToImages(pdfData) {
+        return await convertPDFToImagesEnhanced(pdfData);
+    }
+async function extractTextFromImage(file) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                // Apply learned corrections before OCR
+                let trainedWords = {};
+                if (window.ocrLearningDict) {
+                    for (const [word, data] of Object.entries(window.ocrLearningDict)) {
+                        if (data.confirmedCorrect && data.confirmedCorrect !== word) {
+                            trainedWords[word] = data.confirmedCorrect;
+                        }
+                    }
+                }
+                const imageElement = file instanceof HTMLCanvasElement ? file : file;
+                // Enhanced OCR configuration
+                const config = {
+                    logger: m => {
+                        if (m.status === 'recognizing text') {
+                            console.log(`OCR Progress: ${Math.round(m.progress * 100)}%`);
+                        }
+                    },
+                    preserve_interword_spaces: '1',
+                    tessedit_pageseg_mode: '6', // Assume uniform text block
+                    tessedit_char_whitelist: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,!?-(){}[]/\\\'" @#$%^&*+=<>:;_ ğüşıöçĞÜŞİÖÇ',
                     user_defined_words: Object.keys(trainedWords).join(' '),
+                    tessedit_create_hocr: '1',
+                    load_system_dawg: '1',
+                    load_freq_dawg: '1',
                     user_words_suffix: 'tur',
+                    user_patterns_suffix: 'tur',
+                    tessedit_ocr_engine_mode: '1', // LSTM OCR engine
+                    tessedit_do_ocr: '1',
+                    tessedit_load_image: '1'
+                };
+                // Try multiple OCR approaches
+                const results = await Promise.allSettled([
+                    // Primary: Turkish + English with enhanced preprocessing
+                    performOCRWithPreprocessing(imageElement, 'tur+eng', config),
+                    // Secondary: Different page segmentation
+                    Tesseract.recognize(imageElement, 'tur+eng', {
+                        ...config,
+                        tessedit_pageseg_mode: '1' // Automatic page segmentation
+                    }),
+                    // Tertiary: Only English if Turkish fails
+                    Tesseract.recognize(imageElement, 'eng', config)
+                ]);
+                // Find and return the best result
+                let bestResult = { text: '', confidence: 0 };
+                results.forEach(result => {
+                    if (result.status === 'fulfilled') {
+                        const text = result.value.text;
+                        const confidence = calculateConfidence(text);
+                        if (text.trim().length > bestResult.text.length ||
+                            (text.trim().length === bestResult.text.length && confidence > bestResult.confidence)) {
+                            bestResult = { text, confidence };
+                        }
+                    }
+                });
+                if (bestResult.text) {
+                    // Apply text quality improvements
+                    bestResult.text = decodeTurkishText(bestResult.text);
+                    bestResult.text = improveTextQuality(bestResult.text);
+                    if (outputFormat.value === 'formatted') {
+                        // Create formatted output
+                        const formatted = createFormattedText(bestResult.text);
+                        resolve(formatted);
+                    } else {
+                        resolve(bestResult.text);
+                    }
                 } else {
+                    resolve('No text could be extracted from the image.');
                 }
+            } catch (error) {
+                console.error('Enhanced image OCR error:', error);
+                reject(error);
+            }
         });
+        // OCR with image preprocessing
+        async function performOCRWithPreprocessing(image, languages, config) {
+            let processedImage = image;
+            if (image instanceof HTMLCanvasElement) {
+                // Apply preprocessing to canvas
+                processedImage = await preprocessImage(image);
+            }
+            return await Tesseract.recognize(processedImage, languages, config);
+        }
+        // Calculate text confidence score
+        function calculateConfidence(text) {
+            if (!text || text.trim().length === 0) return 0;
+            // Score based on Turkish word detection
+            const turkishWords = text.match(/[ğüşıöçĞÜŞİÖÇ]+/g) || [];
+            const wordCount = text.split(/\s+/).length;
+            const turkishRatio = turkishWords.length / wordCount;
+            // Score based on sentence structure
+            const sentences = text.split(/[.!?]+/).filter(s => s.trim().length > 0);
+            const avgSentenceLength = sentences.reduce((sum, s) => sum + s.split(/\s+/).length, 0) / sentences.length;
+            // Combined confidence score
+            return (turkishRatio * 0.5) + (Math.min(avgSentenceLength / 10, 1) * 0.5);
+        }
+        // Create formatted text output
+        function createFormattedText(text) {
+            return text
+                .replace(/([.!?])\s+/g, '$1\n\n') // Better paragraph breaks
+                .replace(/\n{3,}/g, '\n\n') // Remove excessive line breaks
+                .replace(/([A-ZÇĞİÖŞÜ][a-zçğıöşü]+)\s+/g, '$1 ') // Preserve Turkish words
+                .trim();
+        }
+function processFormattedOCR(hocr) {
         // Apply learned corrections
         if (window.ocrLearningDict) {
             for (const [word, data] of Object.entries(window.ocrLearningDict)) {