officeparser 6.1.0 → 7.0.0

package/dist/parsers/CsvParser.d.ts

@@ -0,0 +1,9 @@
+import { FullOfficeParserConfig, OfficeParserAST } from '../types.js';
+/**
+ * Parses a CSV file and extracts a single sheet with rows and cells.
+ *
+ * @param buffer - The CSV file as a Buffer
+ * @param config - Parser configuration
+ * @returns A promise resolving to the parsed AST
+ */
+export declare const parseCsv: (buffer: Buffer, config: FullOfficeParserConfig) => Promise<OfficeParserAST>;

package/dist/parsers/CsvParser.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCsv = void 0;
+const astUtils_js_1 = require("../utils/astUtils.js");
+/**
+ * Parses a CSV file and extracts a single sheet with rows and cells.
+ *
+ * @param buffer - The CSV file as a Buffer
+ * @param config - Parser configuration
+ * @returns A promise resolving to the parsed AST
+ */
+const parseCsv = async (buffer, config) => {
+    const textStr = buffer.toString('utf-8');
+    const delimiter = config.csvDelimiter;
+    const records = [];
+    let currentRow = [];
+    let currentCell = '';
+    let inQuotes = false;
+    for (let i = 0; i < textStr.length; i++) {
+        const char = textStr[i];
+        const nextChar = textStr[i + 1];
+        if (inQuotes) {
+            if (char === '"') {
+                if (nextChar === '"') {
+                    currentCell += '"';
+                    i++; // Skip the escaped quote
+                }
+                else {
+                    inQuotes = false;
+                }
+            }
+            else {
+                currentCell += char;
+            }
+        }
+        else {
+            if (char === '"') {
+                inQuotes = true;
+            }
+            else if (textStr.substring(i, i + delimiter.length) === delimiter) {
+                currentRow.push(currentCell);
+                currentCell = '';
+                i += delimiter.length - 1; // Skip the rest of the delimiter
+            }
+            else if (char === '\n') {
+                currentRow.push(currentCell);
+                records.push(currentRow);
+                currentRow = [];
+                currentCell = '';
+            }
+            else if (char === '\r') {
+                // Ignore carriage return outside of quotes
+            }
+            else {
+                currentCell += char;
+            }
+        }
+    }
+    if (currentCell !== '' || currentRow.length > 0) {
+        currentRow.push(currentCell);
+        records.push(currentRow);
+    }
+    // Filter out trailing empty row if the file ended with a newline
+    if (records.length > 0 && records[records.length - 1].length === 1 && records[records.length - 1][0] === '') {
+        records.pop();
+    }
+    const rows = [];
+    records.forEach((record, rowIndex) => {
+        // Handle comment rows
+        if (record.length === 1 && record[0].startsWith('#')) {
+            rows.push({
+                type: 'comment',
+                text: record[0]
+            });
+            return;
+        }
+        const cells = [];
+        record.forEach((val, colIndex) => {
+            if (val && val.trim() !== '') {
+                const cellMeta = { row: rowIndex, col: colIndex };
+                cells.push({
+                    type: 'cell',
+                    text: val,
+                    metadata: cellMeta,
+                    children: [{ type: 'text', text: val }]
+                });
+            }
+        });
+        if (cells.length > 0) {
+            rows.push({
+                type: 'row',
+                children: cells
+            });
+        }
+    });
+    const sheetMeta = { sheetName: 'Sheet1' };
+    const sheetNode = {
+        type: 'sheet',
+        metadata: sheetMeta,
+        children: rows,
+        rawContent: config.includeRawContent ? textStr : undefined
+    };
+    const toTextSync = () => {
+        return records.map((record) => record.filter(cell => cell.trim() !== '').join(config.newlineDelimiter))
+            .join(config.newlineDelimiter)
+            .replace(/\n{3,}/g, '\n\n');
+    };
+    return (0, astUtils_js_1.createAST)('csv', { title: 'Sheet1' }, [sheetNode], [], config, toTextSync);
+};
+exports.parseCsv = parseCsv;

package/dist/parsers/ExcelParser.d.ts

@@ -21,7 +21,7 @@
  * @module ExcelParser
  * @see https://www.ecma-international.org/publications-and-standards/standards/ecma-376/
  */
-import { OfficeParserAST, OfficeParserConfig } from '../types.js';
+import { FullOfficeParserConfig, OfficeParserAST } from '../types.js';
 /**
  * Parses an Excel spreadsheet (.xlsx) and extracts sheets, rows, and cells.
  *
@@ -29,4 +29,4 @@ import { OfficeParserAST, OfficeParserConfig } from '../types.js';
  * @param config - Parser configuration
  * @returns A promise resolving to the parsed AST
  */
-export declare const parseExcel: (buffer: Buffer, config: OfficeParserConfig) => Promise<OfficeParserAST>;
+export declare const parseExcel: (buffer: Buffer, config: FullOfficeParserConfig) => Promise<OfficeParserAST>;

package/dist/parsers/ExcelParser.js

@@ -24,6 +24,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseExcel = void 0;
+const types_js_1 = require("../types.js");
+const astUtils_js_1 = require("../utils/astUtils.js");
 const chartUtils_js_1 = require("../utils/chartUtils.js");
 const errorUtils_js_1 = require("../utils/errorUtils.js");
 const imageUtils_js_1 = require("../utils/imageUtils.js");
@@ -305,13 +307,13 @@ const parseExcel = async (buffer, config) => {
             if (config.ocr) {
                 if (attachment.mimeType.startsWith('image/')) {
                     try {
-                        const ocrText = (await (0, ocrUtils_js_1.performOcr)(media.content, { language: config.ocrLanguage, ...config.ocrConfig })).trim();
+                        const ocrText = (await (0, ocrUtils_js_1.performOcr)(media.content, { ...config.ocrConfig })).trim();
                         if (ocrText) {
                             attachment.ocrText = ocrText;
                         }
                     }
                     catch (e) {
-                        (0, errorUtils_js_1.logWarning)(`OCR failed for ${attachment.name}:`, config, e);
+                        (0, errorUtils_js_1.logWarning)(types_js_1.OfficeWarningType.OCR_FAILED, config, attachment.name, e);
                     }
                 }
             }
@@ -330,7 +332,7 @@ const parseExcel = async (buffer, config) => {
                 attachment.chartData = chartData;
             }
             catch (e) {
-                (0, errorUtils_js_1.logWarning)(`Failed to extract chart data from ${chart.path}:`, config, e);
+                (0, errorUtils_js_1.logWarning)(types_js_1.OfficeWarningType.CHART_DATA_EXTRACTION_FAILED, config, chart.path, e);
             }
             attachments.push(attachment);
         }
@@ -410,104 +412,138 @@ const parseExcel = async (buffer, config) => {
                 rawContents.push(file.content.toString());
             }
             const rows = [];
-            const rowRegex = /<row.*?>[\s\S]*?<\/row>/g;
-            const rowMatches = file.content.toString().match(rowRegex);
-            if (rowMatches) {
-                for (const rowXml of rowMatches) {
-                    const cells = [];
-                    const cRegex = /<c.*?>[\s\S]*?<\/c>/g;
-                    const cMatches = rowXml.match(cRegex);
-                    const rMatch = rowXml.match(/r="(\d+)"/);
-                    const rowIndex = rMatch ? parseInt(rMatch[1]) - 1 : 0;
-                    if (cMatches) {
-                        for (const cXml of cMatches) {
-                            // Extract cell value
-                            const typeMatch = cXml.match(/t="([a-z]+)"/);
-                            const type = typeMatch ? typeMatch[1] : 'n'; // n = number (default)
-                            const vMatch = cXml.match(/<v>(.*?)<\/v>/);
-                            const tMatch = cXml.match(/<t>(.*?)<\/t>/);
-                            let text = '';
-                            let cellNodes = [];
-                            if (type === 's' && vMatch) {
-                                const idx = parseInt(vMatch[1]);
-                                const content = sharedStrings[idx];
-                                if (Array.isArray(content)) {
-                                    // Rich text runs
-                                    // Deep copy runs to avoid reference issues if reused
-                                    cellNodes = JSON.parse(JSON.stringify(content));
-                                    text = cellNodes.map(n => n.text).join('');
-                                }
-                                else {
-                                    text = content || '';
-                                }
-                            }
-                            else if (type === 'inlineStr' && tMatch) {
-                                text = tMatch[1];
-                            }
-                            else if (vMatch) {
-                                text = vMatch[1];
-                            }
-                            // Parse cell coordinate
-                            const coordMatch = cXml.match(/r="([A-Z]+)(\d+)"/);
-                            const colStr = coordMatch ? coordMatch[1] : '';
-                            const colIndex = colStr.charCodeAt(0) - 'A'.charCodeAt(0);
-                            if (text || cellNodes.length > 0) {
-                                // Extract cell style index
-                                const styleMatch = cXml.match(/s="(\d+)"/);
-                                const styleIdx = styleMatch ? parseInt(styleMatch[1]) : undefined;
-                                const cellFormatting = (styleIdx !== undefined && cellFormatMap[styleIdx]) ? cellFormatMap[styleIdx] : {};
-                                if (cellNodes.length > 0) {
-                                    // If we have specific runs, merge cell styles into them if run style is missing
-                                    // But usually run style overrides cell style (except maybe background)
-                                    for (const node of cellNodes) {
-                                        if (!node.formatting)
-                                            node.formatting = {};
-                                        // Cell background always applies
-                                        if (cellFormatting.backgroundColor)
-                                            node.formatting.backgroundColor = cellFormatting.backgroundColor;
-                                        // Cell alignment always applies
-                                        if (cellFormatting.alignment)
-                                            node.formatting.alignment = cellFormatting.alignment;
-                                        // Font defaults from cell style if not in run
-                                        if (!node.formatting.font && cellFormatting.font)
-                                            node.formatting.font = cellFormatting.font;
-                                        if (!node.formatting.size && cellFormatting.size)
-                                            node.formatting.size = cellFormatting.size;
-                                    }
-                                }
-                                else {
-                                    // Simple text node
-                                    cellNodes.push({
-                                        type: 'text',
-                                        text: text,
-                                        formatting: cellFormatting
-                                    });
-                                }
-                                const cellNode = {
-                                    type: 'cell',
-                                    text: text,
-                                    children: cellNodes,
-                                    metadata: { row: rowIndex, col: colIndex }
-                                };
-                                if (config.includeRawContent) {
-                                    cellNode.rawContent = cXml;
-                                }
-                                cells.push(cellNode);
-                            }
+            const sheetXml = file.content.toString();
+            // regex to match <row> elements, capturing:
+            // 1. attributes (e.g., r="1")
+            // 2. whether it's self-closing (/>)
+            // 3. inner content (for non-self-closing rows)
+            const rowRegex = /<row\b([^>]*?)(?:(\/>)|(>([\s\S]*?)<\/row>))/g;
+            // matchAll provides an iterator over all matches, which is much more efficient than 
+            // iterating over a massive sparse row range declared in spreadsheet dimensions.
+            const rowMatches = sheetXml.matchAll(rowRegex);
+            /** Helper to convert Excel column string (A, B, AA, etc.) to 0-based index */
+            const colToNumber = (col) => {
+                let num = 0;
+                for (let i = 0; i < col.length; i++) {
+                    num = num * 26 + (col.charCodeAt(i) - 'A'.charCodeAt(0) + 1);
+                }
+                return num - 1;
+            };
+            let lastRowIndex = -1;
+            for (const rowMatch of rowMatches) {
+                const rowXml = rowMatch[0];
+                const rowAttrs = rowMatch[1];
+                const isSelfClosing = !!rowMatch[2];
+                const rowContent = rowMatch[4] || "";
+                if (!isSelfClosing && !rowContent.includes('<c'))
+                    continue;
+                const cells = [];
+                // regex to match <c> (cell) elements within a row, capturing:
+                // 1. cell attributes (e.g., r="A1", t="s")
+                // 2. whether it's self-closing (/>)
+                // 3. inner content (e.g., <v> value)
+                const cRegex = /<c\b([^>]*?)(?:(\/>)|(>([\s\S]*?)<\/c>))/g;
+                const cMatches = rowContent.matchAll(cRegex);
+                const rMatch = rowAttrs.match(/r="(\d+)"/);
+                const rowIndex = rMatch ? parseInt(rMatch[1]) - 1 : lastRowIndex + 1;
+                lastRowIndex = rowIndex;
+                let lastColIndex = -1;
+                for (const cMatch of cMatches) {
+                    const cXml = cMatch[0];
+                    const cAttrs = cMatch[1];
+                    const cContent = cMatch[4] || "";
+                    // Extract cell value
+                    const typeMatch = cAttrs.match(/t="([a-zA-Z]+)"/);
+                    const type = typeMatch ? typeMatch[1] : 'n'; // n = number (default)
+                    const vMatch = cContent.match(/<v>([\s\S]*?)<\/v>/);
+                    const tMatch = cContent.match(/<t>([\s\S]*?)<\/t>/);
+                    let text = '';
+                    let cellNodes = [];
+                    if (type === 's' && vMatch) {
+                        const idx = parseInt(vMatch[1]);
+                        const content = sharedStrings[idx];
+                        if (Array.isArray(content)) {
+                            // Rich text runs
+                            // Deep copy runs to avoid reference issues if reused
+                            cellNodes = JSON.parse(JSON.stringify(content));
+                            text = cellNodes.map(n => n.text).join('');
+                        }
+                        else {
+                            text = content || '';
                         }
                     }
-                    if (cells.length > 0) {
-                        const rowNode = {
-                            type: 'row',
-                            children: cells,
-                            metadata: undefined
+                    else if (type === 'inlineStr' && tMatch) {
+                        text = tMatch[1].trim();
+                    }
+                    else if (vMatch) {
+                        text = vMatch[1].trim();
+                    }
+                    // Parse cell coordinate
+                    const coordMatch = cAttrs.match(/r="([A-Z]+)(\d+)"/);
+                    let colIndex;
+                    if (coordMatch) {
+                        colIndex = colToNumber(coordMatch[1]);
+                        // If row index is missing in cell coord (unlikely but possible), use rowIndex
+                    }
+                    else {
+                        colIndex = lastColIndex + 1;
+                    }
+                    lastColIndex = colIndex;
+                    if (text || cellNodes.length > 0) {
+                        // Extract cell style index
+                        const styleMatch = cAttrs.match(/s="(\d+)"/);
+                        const styleIdx = styleMatch ? parseInt(styleMatch[1]) : undefined;
+                        const cellFormatting = (styleIdx !== undefined && cellFormatMap[styleIdx]) ? cellFormatMap[styleIdx] : {};
+                        if (cellNodes.length > 0) {
+                            // If we have specific runs, merge cell styles into them if run style is missing
+                            // But usually run style overrides cell style (except maybe background)
+                            for (const node of cellNodes) {
+                                if (!node.formatting)
+                                    node.formatting = {};
+                                // Cell background always applies
+                                if (cellFormatting.backgroundColor)
+                                    node.formatting.backgroundColor = cellFormatting.backgroundColor;
+                                // Cell alignment always applies
+                                if (cellFormatting.alignment)
+                                    node.formatting.alignment = cellFormatting.alignment;
+                                // Font defaults from cell style if not in run
+                                if (!node.formatting.font && cellFormatting.font)
+                                    node.formatting.font = cellFormatting.font;
+                                if (!node.formatting.size && cellFormatting.size)
+                                    node.formatting.size = cellFormatting.size;
+                            }
+                        }
+                        else {
+                            // Simple text node
+                            cellNodes.push({
+                                type: 'text',
+                                text: text,
+                                formatting: cellFormatting
+                            });
+                        }
+                        const cellNode = {
+                            type: 'cell',
+                            text: text,
+                            children: cellNodes,
+                            metadata: { row: rowIndex, col: colIndex }
                         };
                         if (config.includeRawContent) {
-                            rowNode.rawContent = rowXml;
+                            cellNode.rawContent = cXml;
                         }
-                        rows.push(rowNode);
+                        cells.push(cellNode);
                     }
                 }
+                if (cells.length > 0) {
+                    const rowNode = {
+                        type: 'row',
+                        children: cells,
+                        metadata: undefined
+                    };
+                    if (config.includeRawContent) {
+                        rowNode.rawContent = rowXml;
+                    }
+                    rows.push(rowNode);
+                }
             }
             // Handle Drawings in Sheet (images and charts)
             if (config.extractAttachments) {
@@ -617,7 +653,7 @@ const parseExcel = async (buffer, config) => {
                     if (node.type === 'chart') {
                         // Link chart data text to chart node
                         if (attachment.chartData) {
-                            node.text = attachment.chartData.rawTexts.join(config.newlineDelimiter || '\n');
+                            node.text = attachment.chartData.rawTexts.join(config.newlineDelimiter);
                         }
                     }
                 }
@@ -628,24 +664,19 @@ const parseExcel = async (buffer, config) => {
         }
     };
     assignAttachmentData(content);
-    return {
-        type: 'xlsx',
-        metadata: metadata,
-        content: content,
-        attachments: attachments,
-        toText: () => content.map(c => {
-            // Recursive text extraction
-            const getText = (node) => {
-                let t = '';
-                if (node.children) {
-                    t += node.children.map(getText).filter(t => t != '').join(!node.children[0]?.children ? '' : config.newlineDelimiter ?? '\n');
-                }
-                else
-                    t += node.text || '';
-                return t;
-            };
-            return getText(c);
-        }).filter(t => t != '').join(config.newlineDelimiter ?? '\n')
-    };
+    const toTextSync = () => content.map(c => {
+        // Recursive text extraction
+        const getText = (node) => {
+            let t = '';
+            if (node.children) {
+                t += node.children.map(getText).filter(t => t != '').join(!node.children[0]?.children ? '' : config.newlineDelimiter);
+            }
+            else
+                t += node.text || '';
+            return t;
+        };
+        return getText(c);
+    }).filter(t => t != '').join(config.newlineDelimiter);
+    return (0, astUtils_js_1.createAST)('xlsx', metadata, content, attachments, config, toTextSync);
 };
 exports.parseExcel = parseExcel;

package/dist/parsers/HtmlParser.d.ts

@@ -0,0 +1,2 @@
+import { FullOfficeParserConfig, OfficeParserAST } from '../types.js';
+export declare const parseHtml: (buffer: Buffer, config: FullOfficeParserConfig) => Promise<OfficeParserAST>;