officeparser 6.1.0 → 6.1.1

package/dist/parsers/ExcelParser.js

@@ -422,10 +422,10 @@ const parseExcel = async (buffer, config) => {
                     if (cMatches) {
                         for (const cXml of cMatches) {
                             // Extract cell value
-                            const typeMatch = cXml.match(/t="([a-z]+)"/);
+                            const typeMatch = cXml.match(/t="([a-zA-Z]+)"/);
                             const type = typeMatch ? typeMatch[1] : 'n'; // n = number (default)
-                            const vMatch = cXml.match(/<v>(.*?)<\/v>/);
-                            const tMatch = cXml.match(/<t>(.*?)<\/t>/);
+                            const vMatch = cXml.match(/<v>([\s\S]*?)<\/v>/);
+                            const tMatch = cXml.match(/<t>([\s\S]*?)<\/t>/);
                             let text = '';
                             let cellNodes = [];
                             if (type === 's' && vMatch) {
@@ -442,10 +442,10 @@ const parseExcel = async (buffer, config) => {
                                 }
                             }
                             else if (type === 'inlineStr' && tMatch) {
-                                text = tMatch[1];
+                                text = tMatch[1].trim();
                             }
                             else if (vMatch) {
-                                text = vMatch[1];
+                                text = vMatch[1].trim();
                             }
                             // Parse cell coordinate
                             const coordMatch = cXml.match(/r="([A-Z]+)(\d+)"/);

package/dist/parsers/OpenOfficeParser.js

@@ -70,6 +70,11 @@ const parseOpenOffice = async (buffer, config) => {
     const styleMap = {};
     const paragraphStyleMap = {};
     const listCounters = {}; // Track item index per listId/level
+    let currentListId = null;
+    let lastListType = null;
+    let lastListStyle = null;
+    let listIdCounter = 0;
+    let lastWasList = false;
     // Helper to parse styles
     const parseStyles = (xmlString) => {
         const xml = (0, xmlUtils_js_1.parseXmlString)(xmlString);
@@ -221,7 +226,7 @@ const parseOpenOffice = async (buffer, config) => {
                         type: 'text',
                         text: '\n',
                         formatting: parentFormatting,
-                        metadata: linkMetadata ? { ...linkMetadata } : undefined
+                        metadata: { ...(linkMetadata || {}), isLineBreak: true }
                     });
                 }
                 else if (tagName === 'text:span') {
@@ -391,6 +396,31 @@ const parseOpenOffice = async (buffer, config) => {
         }
         return { text: content.text, children: content.children, alignment, style: paraStyle || undefined };
     };
+    /**
+     * Splits paragraph content into multiple segments based on line breaks.
+     * Used to handle soft line breaks within list items.
+     *
+     * @param pContent - The content of a single paragraph
+     * @returns Array of content segments
+     */
+    const splitParagraphByBreaks = (pContent) => {
+        const segments = [];
+        let currentText = "";
+        let currentChildren = [];
+        for (const child of pContent.children) {
+            if (child.type === "text" && child.metadata?.isLineBreak) {
+                segments.push({ text: currentText, children: currentChildren });
+                currentText = "";
+                currentChildren = [];
+            }
+            else {
+                currentText += child.text || "";
+                currentChildren.push(child);
+            }
+        }
+        segments.push({ text: currentText, children: currentChildren });
+        return segments;
+    };
     /**
      * Helper to parse a table node and extract its structure.
      * Properly creates table → row → cell hierarchy with metadata.
@@ -640,6 +670,7 @@ const parseOpenOffice = async (buffer, config) => {
                     pNode.rawContent = (0, xmlUtils_js_1.getRawContent)(node, sourceXml, config);
                 }
                 targetArray.push(pNode);
+                lastWasList = false;
             }
             else if (node.tagName === "text:h") {
                 const level = parseInt(node.getAttribute("text:outline-level") || "1");
@@ -658,6 +689,7 @@ const parseOpenOffice = async (buffer, config) => {
                     hNode.rawContent = (0, xmlUtils_js_1.getRawContent)(node, sourceXml, config);
                 }
                 targetArray.push(hNode);
+                lastWasList = false;
             }
             else if (node.tagName === "table:table") {
                 // Parse table with proper structure
@@ -666,16 +698,15 @@ const parseOpenOffice = async (buffer, config) => {
                     tableNode.rawContent = (0, xmlUtils_js_1.getRawContent)(node, sourceXml, config);
                 }
                 targetArray.push(tableNode);
+                lastWasList = false;
             }
             else if (node.tagName === "text:list") {
                 // Parse list structure with proper listId tracking
                 const listItems = (0, xmlUtils_js_1.getDirectChildren)(node, "text:list-item");
-                // Get list style name to use as listId (or generate one)
-                const listStyleName = node.getAttribute("text:style-name") || node.getAttribute("xml:id");
-                const listId = listStyleName || `list-${targetArray.length}`;
                 // Determine list type by checking the list style definition
                 let listType = 'unordered';
                 let isVisible = false;
+                const listStyleName = node.getAttribute("text:style-name") || node.getAttribute("xml:id");
                 let styleNameToCheck = listStyleName;
                 // If no style name, check parent list for inherited style
                 if (!styleNameToCheck) {
@@ -741,6 +772,7 @@ const parseOpenOffice = async (buffer, config) => {
                 // If the list is not visible, it's likely a layout list used by Impress.
                 // We should traverse its items and treat their content as regular nodes.
                 if (!isVisible) {
+                    lastWasList = false;
                     for (let i = 0; i < listItems.length; i++) {
                         const item = listItems[i];
                         if (item.childNodes) {
@@ -754,6 +786,24 @@ const parseOpenOffice = async (buffer, config) => {
                     }
                     return;
                 }
+                // List Continuity Logic:
+                // If this list follows another list of the same type and style, or we are in ODP and it's sequential,
+                // we should reuse the previous listId to maintain numbering.
+                const isODP = fileType === 'odp';
+                const sameStyle = styleNameToCheck && styleNameToCheck === lastListStyle;
+                const sameType = listType === lastListType;
+                let listId;
+                if (lastWasList && (sameStyle || (isODP && sameType))) {
+                    listId = currentListId;
+                }
+                else {
+                    // New list
+                    listId = styleNameToCheck || `list-${++listIdCounter}`;
+                    currentListId = listId;
+                    lastListType = listType;
+                    lastListStyle = styleNameToCheck;
+                }
+                lastWasList = true;
                 // Calculate indentation level by counting parent text:list elements
                 let indentation = 0;
                 let parent = node.parentNode;
@@ -774,59 +824,57 @@ const parseOpenOffice = async (buffer, config) => {
                 // Process each list item
                 for (let i = 0; i < listItems.length; i++) {
                     const item = listItems[i];
-                    // Increment item index for this list/level
-                    listCounters[listId][indentKey]++;
-                    const itemIndex = listCounters[listId][indentKey];
-                    // Reset deeper levels when we encounter an item at this level
-                    for (let k = indentation + 1; k < 10; k++) {
-                        if (listCounters[listId][k.toString()] !== undefined) {
-                            listCounters[listId][k.toString()] = -1;
-                        }
-                    }
+                    let hasIndexedThisItem = false;
                     // Iterate over direct children of list item (paragraphs, headings, nested lists)
                     if (item.childNodes) {
                         for (let j = 0; j < item.childNodes.length; j++) {
                             const child = item.childNodes[j];
                             if ((0, xmlUtils_js_1.isElement)(child)) { // Element
                                 const element = child;
-                                if (element.tagName === "text:p") {
-                                    const pContent = parseParagraphContent(element, paragraphStyleMap, styleMap, config, sourceXml);
-                                    const listNode = {
-                                        type: 'list',
-                                        text: pContent.text,
-                                        children: pContent.children,
-                                        metadata: {
-                                            listType,
-                                            indentation,
-                                            itemIndex,
-                                            listId,
-                                            alignment: pContent.alignment || 'left',
-                                            style: pContent.style
+                                if (element.tagName === "text:p" || element.tagName === "text:h") {
+                                    if (!hasIndexedThisItem) {
+                                        listCounters[listId][indentKey]++;
+                                        hasIndexedThisItem = true;
+                                        for (let k = indentation + 1; k < 10; k++) {
+                                            if (listCounters[listId][k.toString()] !== undefined) {
+                                                listCounters[listId][k.toString()] = -1;
+                                            }
                                         }
-                                    };
-                                    if (config.includeRawContent)
-                                        listNode.rawContent = (0, xmlUtils_js_1.getRawContent)(element, sourceXml, config);
-                                    targetArray.push(listNode);
-                                }
-                                else if (element.tagName === "text:h") {
-                                    const level = parseInt(element.getAttribute("text:outline-level") || "1");
-                                    const hContent = parseParagraphContent(element, paragraphStyleMap, styleMap, config, sourceXml);
-                                    const listNode = {
-                                        type: 'list',
-                                        text: hContent.text,
-                                        children: hContent.children,
-                                        metadata: {
-                                            listType,
-                                            indentation,
-                                            itemIndex,
-                                            listId,
-                                            ...(hContent.alignment ? { alignment: hContent.alignment } : {}),
-                                            style: hContent.style
+                                    }
+                                    const itemIndex = listCounters[listId][indentKey];
+                                    const pContent = parseParagraphContent(element, paragraphStyleMap, styleMap, config, sourceXml);
+                                    const segments = splitParagraphByBreaks(pContent);
+                                    for (let k = 0; k < segments.length; k++) {
+                                        const segment = segments[k];
+                                        if (!segment.text.trim() && segment.children.length === 0)
+                                            continue;
+                                        const isFirst = k === 0;
+                                        const nodeType = isFirst ? 'list' : 'paragraph';
+                                        const node = {
+                                            type: nodeType,
+                                            text: segment.text,
+                                            children: segment.children,
+                                            metadata: isFirst ? {
+                                                listType,
+                                                indentation,
+                                                itemIndex,
+                                                listId,
+                                                alignment: pContent.alignment || 'left',
+                                                style: pContent.style
+                                            } : {
+                                                alignment: pContent.alignment || 'left',
+                                                style: pContent.style
+                                            }
+                                        };
+                                        // Special case for headings in lists
+                                        if (isFirst && element.tagName === "text:h") {
+                                            const level = parseInt(element.getAttribute("text:outline-level") || "1");
+                                            node.metadata.level = level;
                                         }
-                                    };
-                                    if (config.includeRawContent)
-                                        listNode.rawContent = (0, xmlUtils_js_1.getRawContent)(element, sourceXml, config);
-                                    targetArray.push(listNode);
+                                        if (config.includeRawContent)
+                                            node.rawContent = (0, xmlUtils_js_1.getRawContent)(element, sourceXml, config);
+                                        targetArray.push(node);
+                                    }
                                 }
                                 else if (element.tagName === "text:list") {
                                     // Recursive call for nested list

package/dist/parsers/PowerPointParser.js

@@ -392,117 +392,129 @@ const parsePowerPoint = async (buffer, config) => {
                 if (config.includeRawContent) {
                     pNode.rawContent = (0, xmlUtils_js_1.getRawContent)(p, xmlContentString, config);
                 }
-                const runs = (0, xmlUtils_js_1.getElementsByTagName)(p, "a:r");
-                for (let j = 0; j < runs.length; j++) {
-                    const r = runs[j];
-                    const t = (0, xmlUtils_js_1.getFirstElementByTagName)(r, "a:t");
-                    if (t && t.childNodes[0]) {
-                        const textContent = t.childNodes[0].nodeValue || '';
-                        pNode.text += textContent;
-                        const rPr = (0, xmlUtils_js_1.getFirstElementByTagName)(r, "a:rPr");
-                        const formatting = {};
-                        if (rPr) {
-                            if (rPr.getAttribute("b") === "1")
-                                formatting.bold = true;
-                            if (rPr.getAttribute("i") === "1")
-                                formatting.italic = true;
-                            if (rPr.getAttribute("u") === "sng")
-                                formatting.underline = true;
-                            if (rPr.getAttribute("strike") === "sngStrike")
-                                formatting.strikethrough = true;
-                            const sz = rPr.getAttribute("sz");
-                            if (sz)
-                                formatting.size = (parseInt(sz) / 100).toString() + 'pt';
-                            // Color extraction
-                            const solidFill = (0, xmlUtils_js_1.getFirstElementByTagName)(rPr, "a:solidFill");
-                            if (solidFill) {
-                                const srgbClr = (0, xmlUtils_js_1.getFirstElementByTagName)(solidFill, "a:srgbClr");
-                                if (srgbClr) {
-                                    const val = srgbClr.getAttribute("val");
-                                    if (val)
-                                        formatting.color = '#' + val;
+                // Process all children of <a:p> in order (runs, breaks, fields)
+                const children = Array.from(p.childNodes);
+                let activeNode = pNode;
+                nodes.push(activeNode);
+                for (const childNode of children) {
+                    if (!(0, xmlUtils_js_1.isElement)(childNode))
+                        continue;
+                    const element = childNode;
+                    const tag = element.tagName;
+                    if (tag === "a:r" || tag === "a:fld") {
+                        const t = (0, xmlUtils_js_1.getFirstElementByTagName)(element, "a:t");
+                        if (t && t.childNodes[0]) {
+                            const textContent = t.childNodes[0].nodeValue || "";
+                            activeNode.text += textContent;
+                            const rPr = (0, xmlUtils_js_1.getFirstElementByTagName)(element, "a:rPr");
+                            const formatting = {};
+                            if (rPr) {
+                                if (rPr.getAttribute("b") === "1")
+                                    formatting.bold = true;
+                                if (rPr.getAttribute("i") === "1")
+                                    formatting.italic = true;
+                                if (rPr.getAttribute("u") === "sng")
+                                    formatting.underline = true;
+                                if (rPr.getAttribute("strike") === "sngStrike")
+                                    formatting.strikethrough = true;
+                                const sz = rPr.getAttribute("sz");
+                                if (sz)
+                                    formatting.size = (parseInt(sz) / 100).toString() + "pt";
+                                // Color extraction
+                                const solidFill = (0, xmlUtils_js_1.getFirstElementByTagName)(rPr, "a:solidFill");
+                                if (solidFill) {
+                                    const srgbClr = (0, xmlUtils_js_1.getFirstElementByTagName)(solidFill, "a:srgbClr");
+                                    if (srgbClr) {
+                                        const val = srgbClr.getAttribute("val");
+                                        if (val)
+                                            formatting.color = "#" + val;
+                                    }
                                 }
-                            }
-                            // Highlight extraction
-                            const highlight = (0, xmlUtils_js_1.getFirstElementByTagName)(rPr, "a:highlight");
-                            if (highlight) {
-                                const srgbClr = (0, xmlUtils_js_1.getFirstElementByTagName)(highlight, "a:srgbClr");
-                                if (srgbClr) {
-                                    const val = srgbClr.getAttribute("val");
-                                    if (val)
-                                        formatting.backgroundColor = '#' + val;
+                                // Highlight extraction
+                                const highlight = (0, xmlUtils_js_1.getFirstElementByTagName)(rPr, "a:highlight");
+                                if (highlight) {
+                                    const srgbClr = (0, xmlUtils_js_1.getFirstElementByTagName)(highlight, "a:srgbClr");
+                                    if (srgbClr) {
+                                        const val = srgbClr.getAttribute("val");
+                                        if (val)
+                                            formatting.backgroundColor = "#" + val;
+                                    }
+                                }
+                                // Font family
+                                const latin = (0, xmlUtils_js_1.getFirstElementByTagName)(rPr, "a:latin");
+                                if (latin) {
+                                    const typeface = latin.getAttribute("typeface");
+                                    if (typeface)
+                                        formatting.font = typeface;
+                                }
+                                // Subscript/Superscript
+                                const baseline = rPr.getAttribute("baseline");
+                                if (baseline) {
+                                    const baselineVal = parseInt(baseline);
+                                    if (baselineVal < 0)
+                                        formatting.subscript = true;
+                                    if (baselineVal > 0)
+                                        formatting.superscript = true;
                                 }
                             }
-                            // Font family
-                            const latin = (0, xmlUtils_js_1.getFirstElementByTagName)(rPr, "a:latin");
-                            if (latin) {
-                                const typeface = latin.getAttribute("typeface");
-                                if (typeface)
-                                    formatting.font = typeface;
-                            }
-                            // Subscript/Superscript
-                            const baseline = rPr.getAttribute("baseline");
-                            if (baseline) {
-                                const baselineVal = parseInt(baseline);
-                                if (baselineVal < 0)
-                                    formatting.subscript = true;
-                                if (baselineVal > 0)
-                                    formatting.superscript = true;
+                            const textNode = {
+                                type: 'text',
+                                text: textContent,
+                                formatting: formatting
+                            };
+                            // Check for Hyperlinks
+                            const hlinkClick = (0, xmlUtils_js_1.getFirstElementByTagName)(element, "a:hlinkClick");
+                            if (hlinkClick) {
+                                const rId = hlinkClick.getAttribute("r:id");
+                                const action = hlinkClick.getAttribute("action");
+                                let link;
+                                let linkType;
+                                if (rId && slideRelsMap[slideNumber] && slideRelsMap[slideNumber][rId] && slideRelsMap[slideNumber][rId].type === "hyperlink") {
+                                    link = slideRelsMap[slideNumber][rId].target;
+                                    linkType = "external";
+                                }
+                                else if (rId && slideRelsMap[slideNumber] && slideRelsMap[slideNumber][rId] && slideRelsMap[slideNumber][rId].type === "slide") {
+                                    link = slideRelsMap[slideNumber][rId].target;
+                                    linkType = "internal";
+                                }
+                                else if (action) {
+                                    link = action;
+                                    linkType = "internal";
+                                }
+                                if (link) {
+                                    textNode.metadata = { link, linkType };
+                                }
                             }
+                            activeNode.children?.push(textNode);
                         }
-                        const textNode = {
-                            type: 'text',
-                            text: textContent,
-                            formatting: formatting
-                        };
-                        // Check for Hyperlinks
-                        const hlinkClick = (0, xmlUtils_js_1.getFirstElementByTagName)(r, "a:hlinkClick");
-                        // Check if this run has a hyperlink click action
-                        if (hlinkClick) {
-                            // Relationship ID for the link
-                            const rId = hlinkClick.getAttribute("r:id");
-                            // Optional action attribute, often for internal jumps
-                            const action = hlinkClick.getAttribute("action");
-                            // Result placeholders
-                            let link;
-                            let linkType;
-                            // Case 1: Relationship exists in slideRelsMap and is a real hyperlink (external URL)
-                            if (rId
-                                && slideRelsMap[slideNumber]
-                                && slideRelsMap[slideNumber][rId]
-                                && slideRelsMap[slideNumber][rId].type === "hyperlink") {
-                                // External URL
-                                link = slideRelsMap[slideNumber][rId].target;
-                                linkType = "external";
-                            }
-                            // Case 2: Relationship exists and is an internal slide reference
-                            else if (rId
-                                && slideRelsMap[slideNumber]
-                                && slideRelsMap[slideNumber][rId]
-                                && slideRelsMap[slideNumber][rId].type === "slide") {
-                                // Example target: ppt/slides/slide3.xml
-                                link = slideRelsMap[slideNumber][rId].target;
-                                linkType = "internal";
-                            }
-                            // Case 3: action attribute like ppaction://hlinksldjump
-                            else if (action) {
-                                link = action;
-                                linkType = "internal";
-                            }
-                            // Assign metadata only if a link was actually discovered
-                            if (link) {
-                                textNode.metadata = { link, linkType };
+                    }
+                    else if (tag === "a:br") {
+                        if (isList) {
+                            // Split the list item on soft break into a paragraph node
+                            activeNode = {
+                                type: 'paragraph',
+                                text: '',
+                                children: [],
+                                metadata: {
+                                    indentation: lvl,
+                                    alignment: pNode.metadata?.alignment || 'left'
+                                }
+                            };
+                            if (config.includeRawContent) {
+                                activeNode.rawContent = (0, xmlUtils_js_1.getRawContent)(p, xmlContentString, config);
                             }
+                            nodes.push(activeNode);
+                        }
+                        else {
+                            // In a normal paragraph, just add a newline
+                            activeNode.text += "\n";
+                            activeNode.children?.push({ type: 'text', text: "\n" });
                         }
-                        pNode.children?.push(textNode);
                     }
                 }
-                if (pNode.text) {
-                    nodes.push(pNode);
-                }
             }
         }
-        return nodes;
+        return nodes.filter(n => n.text?.trim() || (n.children && n.children.length > 0));
     };
     /**
      * Recursively traverses a PowerPoint shape tree (p:spTree),

package/dist/parsers/RtfParser.d.ts

@@ -130,6 +130,12 @@ export declare class SimpleRtfParser {
     private index;
     /** The RTF content as a Buffer */
     private buffer;
+    /** Current code page for character decoding (default is Windows-1252) */
+    private codePage;
+    /** Cached TextDecoders for different code pages */
+    private decoders;
+    /** Buffer for consecutive text bytes to handle multi-byte encodings and UTF-8 detection */
+    private pendingBytes;
     /** Total length of the buffer */
     private length;
     /**
@@ -140,6 +146,20 @@ export declare class SimpleRtfParser {
     parse(): RtfGroup;
     private parseControl;
     private parseText;
+    /**
+     * Flushes the pending bytes buffer as a text node to the current group.
+     * @param group The group to append the text node to
+     */
+    private flushPendingText;
+    /**
+     * Decodes a byte array using a "UTF-8 first" strategy.
+     * If the bytes form valid UTF-8 and contain non-ASCII characters, UTF-8 is preferred.
+     * Otherwise, falls back to the specified code page.
+     * @param bytes The bytes to decode
+     * @param codePage The RTF code page ID
+     * @returns The decoded string
+     */
+    private decodeBytes;
 }
 /**
  * Parses an RTF file and returns the AST.