officeparser 7.1.0 → 7.2.0

package/dist/parsers/PowerPointParser.js

@@ -52,10 +52,17 @@ const parsePowerPoint = async (buffer, config) => {
     const chartFileRegex = /ppt\/charts\/chart\d+\.xml/;
     const corePropsFileRegex = /docProps\/core\.xml/;
     const customPropsFileRegex = /docProps\/custom\.xml/;
+    const appPropsFileRegex = /docProps\/app\.xml/;
+    const commentsFileRegex = /ppt\/comments\/comment\d+\.xml/;
+    const commentAuthorsRegex = /ppt\/commentAuthors\.xml/;
+    const slideMastersRegex = /ppt\/slideMasters\/slideMaster\d+\.xml/;
     const files = await (0, zipUtils_js_1.extractFiles)(buffer, x => !!x.match(config.ignoreNotes ? slidesRegex : allFilesRegex) ||
         !!x.match(corePropsFileRegex) ||
         !!x.match(customPropsFileRegex) ||
+        !!x.match(appPropsFileRegex) ||
         !!x.match(slideRelsRegex) ||
+        (!config.ignoreComments && (!!x.match(commentsFileRegex) || !!x.match(commentAuthorsRegex))) ||
+        (!config.ignoreSlideMasters && !!x.match(slideMastersRegex)) ||
         (!!config.extractAttachments && (!!x.match(mediaFileRegex) || !!x.match(chartFileRegex))));
     // Extract metadata
     const corePropsFile = files.find(f => f.path.match(corePropsFileRegex));
@@ -66,6 +73,12 @@ const parsePowerPoint = async (buffer, config) => {
         if (Object.keys(customProperties).length > 0)
             metadata.customProperties = customProperties;
     }
+    const appPropsFile = files.find(f => f.path.match(appPropsFileRegex));
+    if (appPropsFile) {
+        const appProperties = (0, xmlUtils_js_1.parseOOXMLAppProperties)(appPropsFile.content.toString());
+        if (Object.keys(appProperties).length > 0)
+            metadata.nativeProperties = appProperties;
+    }
     // Sort files
     files.sort((a, b) => {
         const aMatch = a.path.match(slideNumberRegex);
@@ -77,6 +90,23 @@ const parsePowerPoint = async (buffer, config) => {
     const content = [];
     const rawContents = [];
     const slideRelsMap = {};
+    const authorMap = {};
+    if (!config.ignoreComments) {
+        const authorsFile = files.find(f => f.path === 'ppt/commentAuthors.xml');
+        if (authorsFile) {
+            const authorsXml = (0, xmlUtils_js_1.parseXmlString)(authorsFile.content.toString());
+            const authorNodes = (0, xmlUtils_js_1.getElementsByTagName)(authorsXml, "p:cmAuthor");
+            for (const aNode of authorNodes) {
+                const id = aNode.getAttribute("id");
+                if (id !== null) {
+                    authorMap[id] = {
+                        author: aNode.getAttribute("name") || undefined,
+                        initials: aNode.getAttribute("initials") || undefined
+                    };
+                }
+            }
+        }
+    }
     let currentListId = 0;
     let runningListIndex = 0;
     let lastWasList = false;
@@ -159,11 +189,26 @@ const parsePowerPoint = async (buffer, config) => {
                         cellText += pNode.text;
                     }
                 }
+                let backgroundColor;
+                const tcPr = (0, xmlUtils_js_1.getFirstElementByTagName)(tcNode, "a:tcPr");
+                if (tcPr) {
+                    for (const child of Array.from(tcPr.childNodes)) {
+                        if ((0, xmlUtils_js_1.isElement)(child) && child.nodeName === "a:solidFill") {
+                            const srgbClr = (0, xmlUtils_js_1.getFirstElementByTagName)(child, "a:srgbClr");
+                            if (srgbClr) {
+                                const val = srgbClr.getAttribute("val");
+                                if (val)
+                                    backgroundColor = "#" + val;
+                            }
+                            break;
+                        }
+                    }
+                }
                 const cellNode = {
                     type: 'cell',
                     text: cellText,
                     children: cellChildren,
-                    metadata: { row: rIndex, col: cIndex }
+                    metadata: { row: rIndex, col: cIndex, ...(backgroundColor ? { backgroundColor } : {}) }
                 };
                 cells.push(cellNode);
             }
@@ -284,12 +329,23 @@ const parsePowerPoint = async (buffer, config) => {
             const paragraphs = (0, xmlUtils_js_1.getElementsByTagName)(txBody, "a:p");
             for (let i = 0; i < paragraphs.length; i++) {
                 const p = paragraphs[i];
-                const pNode = {
-                    type: isTitle ? 'heading' : 'paragraph',
-                    text: '',
-                    children: [],
-                    metadata: isTitle ? { level: 1 } : {}
-                };
+                let pNode;
+                if (isTitle) {
+                    pNode = {
+                        type: 'heading',
+                        text: '',
+                        children: [],
+                        metadata: { level: 1 }
+                    };
+                }
+                else {
+                    pNode = {
+                        type: 'paragraph',
+                        text: '',
+                        children: [],
+                        metadata: {}
+                    };
+                }
                 // Paragraph Alignment and List Detection
                 const pPr = (0, xmlUtils_js_1.getFirstElementByTagName)(p, "a:pPr");
                 let isList = false;
@@ -330,7 +386,6 @@ const parsePowerPoint = async (buffer, config) => {
                     }
                 }
                 if (isList) {
-                    pNode.type = 'list';
                     const ilvl = lvl;
                     // detect a new list when bullet type changes or previous was not a list
                     const newList = !lastWasList ||
@@ -378,13 +433,17 @@ const parsePowerPoint = async (buffer, config) => {
                     lastListType = listType;
                     lastListIndent = ilvl;
                     // metadata output
-                    pNode.metadata = {
-                        ...pNode.metadata,
-                        listType,
-                        indentation: ilvl,
-                        listId: currentListId.toString(),
-                        itemIndex: runningListIndex,
-                        alignment: pNode.metadata?.alignment || 'left',
+                    pNode = {
+                        type: 'list',
+                        text: pNode.text,
+                        children: pNode.children,
+                        metadata: {
+                            listType,
+                            indentation: ilvl,
+                            listId: currentListId.toString(),
+                            itemIndex: runningListIndex,
+                            alignment: pNode.metadata?.alignment || 'left',
+                        }
                     };
                 }
                 else {
@@ -392,7 +451,7 @@ const parsePowerPoint = async (buffer, config) => {
                     lastListType = null;
                     lastListIndent = 0;
                 }
-                if (isTitle) {
+                if (isTitle && pNode.type === 'heading') {
                     pNode.metadata = { ...pNode.metadata, level: 1 };
                 }
                 if (config.includeRawContent) {
@@ -502,7 +561,7 @@ const parsePowerPoint = async (buffer, config) => {
                                 text: '',
                                 children: [],
                                 metadata: {
-                                    indentation: lvl,
+                                    paragraphIndentation: { left: lvl },
                                     alignment: pNode.metadata?.alignment || 'left'
                                 }
                             };
@@ -638,6 +697,10 @@ const parsePowerPoint = async (buffer, config) => {
                         else if (typeAttr.includes("relationships/notesSlide")) {
                             simplifiedType = "notes";
                         }
+                        // Check comments
+                        else if (typeAttr.includes("relationships/comments")) {
+                            simplifiedType = "comments";
+                        }
                         // Now normalize the target only if it is a local file path.
                         // Hyperlinks are external and should not be normalized.
                         let normalizedTarget = targetRaw;
@@ -657,6 +720,8 @@ const parsePowerPoint = async (buffer, config) => {
             }
         }
     }
+    const slidesMap = {};
+    const slideMasters = [];
     // Now for processing all the other files - slides and notes.
     for (const file of files) {
         if (file.path.match(mediaFileRegex))
@@ -667,6 +732,8 @@ const parsePowerPoint = async (buffer, config) => {
             continue;
         if (file.path.match(corePropsFileRegex))
             continue;
+        if (file.path.includes("comment"))
+            continue;
         const xmlContentString = file.content.toString();
         const xml = (0, xmlUtils_js_1.parseXmlString)(xmlContentString, { locator: config.includeRawContent });
         if (config.includeRawContent) {
@@ -674,30 +741,91 @@ const parsePowerPoint = async (buffer, config) => {
         }
         const slideMatch = file.path.match(slideNumberRegex);
         const slideNumber = slideMatch ? parseInt(slideMatch[1]) : 0;
+        const masterMatch = file.path.match(/slideMaster(\d+)\.xml/);
+        const masterNumber = masterMatch ? parseInt(masterMatch[1]) : 0;
         const isNote = file.path.includes("notesSlide");
-        const slideNode = {
-            type: isNote ? 'note' : 'slide',
-            children: [],
-            metadata: {
-                slideNumber: slideNumber,
-                ...(isNote ? { noteId: `slide-note-${slideNumber}` } : {})
-            }
-        };
+        const isMaster = file.path.includes("slideMaster");
+        const nodeType = isNote ? 'note' : (isMaster ? 'slideMaster' : 'slide');
+        const nodeNumber = isMaster ? masterNumber : slideNumber;
+        let slideNode;
+        if (isNote) {
+            slideNode = {
+                type: 'note',
+                children: [],
+                metadata: {
+                    slideNumber: nodeNumber,
+                    noteId: `slide-note-${slideNumber}`
+                }
+            };
+        }
+        else {
+            slideNode = {
+                type: isMaster ? 'slideMaster' : 'slide',
+                children: [],
+                metadata: {
+                    slideNumber: nodeNumber
+                }
+            };
+        }
         if (config.includeRawContent) {
             slideNode.rawContent = (0, xmlUtils_js_1.getRawContent)(xml, xmlContentString, config);
         }
-        /**
-         * Extract slide contents in correct document order by scanning p:spTree children.
-         * This ensures p:pic, p:sp, p:graphicFrame appear in AST in the exact sequence.
-         */
         const spTree = (0, xmlUtils_js_1.getFirstElementByTagName)(xml, "p:spTree");
         if (spTree) {
-            slideNode.children?.push(...traverseSpTree(spTree, slideNumber, xmlContentString));
+            slideNode.children?.push(...traverseSpTree(spTree, nodeNumber, xmlContentString));
         }
         if (slideNode.children && slideNode.children.length > 0) {
-            content.push(slideNode);
+            if (isMaster) {
+                slideMasters.push(slideNode);
+            }
+            else if (isNote) {
+                if (!slidesMap[slideNumber])
+                    slidesMap[slideNumber] = { type: 'slide', children: [], metadata: { slideNumber } };
+                if (!slidesMap[slideNumber].notes)
+                    slidesMap[slideNumber].notes = [];
+                slidesMap[slideNumber].notes.push(slideNode);
+            }
+            else {
+                if (!slidesMap[slideNumber]) {
+                    slidesMap[slideNumber] = slideNode;
+                }
+                else {
+                    slidesMap[slideNumber].children = slideNode.children;
+                    slidesMap[slideNumber].rawContent = slideNode.rawContent;
+                }
+                // Process comments
+                if (!config.ignoreComments && slideRelsMap[slideNumber]) {
+                    const commentRels = Object.values(slideRelsMap[slideNumber]).filter(r => r.type === "comments");
+                    for (const rel of commentRels) {
+                        const cFile = files.find(f => f.path.endsWith(rel.target));
+                        if (cFile) {
+                            const cXml = (0, xmlUtils_js_1.parseXmlString)(cFile.content.toString());
+                            const commentNodes = (0, xmlUtils_js_1.getElementsByTagName)(cXml, "p:cm");
+                            for (const cNode of commentNodes) {
+                                const authorId = cNode.getAttribute("authorId");
+                                const authorData = authorId !== null ? authorMap[authorId] : undefined;
+                                const text = (0, xmlUtils_js_1.getElementsByTagName)(cNode, "a:t").map(t => t.textContent || '').join('');
+                                if (text) {
+                                    if (!slidesMap[slideNumber].comments)
+                                        slidesMap[slideNumber].comments = [];
+                                    slidesMap[slideNumber].comments.push({
+                                        type: 'comment',
+                                        text,
+                                        children: [{ type: 'text', text, formatting: {} }],
+                                        metadata: authorData && authorData.author ? { author: authorData.author } : undefined
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
         }
     }
+    const sortedSlideNumbers = Object.keys(slidesMap).map(Number).sort((a, b) => a - b);
+    for (const num of sortedSlideNumbers) {
+        content.push(slidesMap[num]);
+    }
     const attachments = [];
     const mediaFiles = files.filter(f => f.path.match(/ppt\/media\/.*/));
     const chartFiles = files.filter(f => f.path.match(/ppt\/charts\/chart\d+\.xml/));
@@ -762,14 +890,7 @@ const parsePowerPoint = async (buffer, config) => {
         };
         assignAttachmentData(content);
     }
-    // Finally, if the notes are required to be at the end of the document, move them there.
-    if (!config.ignoreNotes && config.putNotesAtLast) {
-        content.sort((a, b) => {
-            const aIsNote = a.type === 'note' ? 1 : 0;
-            const bIsNote = b.type === 'note' ? 1 : 0;
-            return aIsNote - bIsNote;
-        });
-    }
+    // putNotesAtLast is deprecated. Notes are now structurally attached to their respective slides.
     const toTextSync = () => content.map(c => {
         // Recursive text extraction
         const getText = (node) => {
@@ -783,6 +904,9 @@ const parsePowerPoint = async (buffer, config) => {
         };
         return getText(c);
     }).filter(t => t != '').join(config.newlineDelimiter);
-    return (0, astUtils_js_1.createAST)('pptx', metadata, content, attachments, config, toTextSync);
+    const auxiliaryContent = slideMasters.length > 0 ? {
+        slideMasters
+    } : undefined;
+    return (0, astUtils_js_1.createAST)('pptx', metadata, content, attachments, config, auxiliaryContent, toTextSync);
 };
 exports.parsePowerPoint = parsePowerPoint;

package/dist/parsers/RtfParser.js

@@ -1107,11 +1107,14 @@ const parseRtf = async (buffer, config) => {
             }
             // Handle footnote: switch target to notes
             const previousTarget = currentTarget;
+            let savedParagraphTextChunks;
+            let savedParagraphChildren;
+            let savedParagraphRawChunks;
             if (isFootnote) {
                 if (config.ignoreNotes) {
                     return; // Skip footnote content entirely
                 }
-                flushParagraph();
+                flushRun();
                 currentFootnoteId++;
                 // Determine note type based on \fet value
                 let noteType = 'footnote';
@@ -1135,8 +1138,25 @@ const parseRtf = async (buffer, config) => {
                         noteType: noteType
                     }
                 };
-                notes.push(noteNode);
+                if (currentParagraphChildren.length > 0) {
+                    const precedingNode = currentParagraphChildren[currentParagraphChildren.length - 1];
+                    if (!precedingNode.notes)
+                        precedingNode.notes = [];
+                    precedingNode.notes.push(noteNode);
+                }
+                else {
+                    const emptyTextNode = { type: 'text', text: '' };
+                    emptyTextNode.notes = [noteNode];
+                    currentParagraphChildren.push(emptyTextNode);
+                }
                 currentTarget = noteNode.children;
+                // Save current paragraph state so we don't mix footnote paragraphs with main text
+                savedParagraphTextChunks = [...currentParagraphTextChunks];
+                savedParagraphChildren = [...currentParagraphChildren];
+                savedParagraphRawChunks = [...currentParagraphRawChunks];
+                currentParagraphTextChunks = [];
+                currentParagraphChildren = [];
+                currentParagraphRawChunks = [];
             }
             // Create a new formatting context for the group
             const groupFormatting = { ...formatting };
@@ -1195,6 +1215,10 @@ const parseRtf = async (buffer, config) => {
             if (isFootnote) {
                 flushParagraph();
                 currentTarget = previousTarget;
+                // Restore the saved paragraph state
+                currentParagraphTextChunks = savedParagraphTextChunks;
+                currentParagraphChildren = savedParagraphChildren;
+                currentParagraphRawChunks = savedParagraphRawChunks;
             }
             // Clear link URL after processing the field group
             if (isHyperlinkField) {
@@ -1639,18 +1663,6 @@ const parseRtf = async (buffer, config) => {
         flushTable();
     }
     flushParagraph();
-    // Notes handling:
-    // - If putNotesAtLast is false, notes should be added inline during traversal
-    //   (currently they go to 'notes' array, then we append them here - this is wrong)
-    // - If putNotesAtLast is true, notes are appended at the very end (see below)
-    // 
-    // For now, when putNotesAtLast is false, we append notes immediately after content
-    // This isn't truly "inline" but it's better than at the end
-    // TODO: Implement true inline placement during traversal
-    if (!config.putNotesAtLast && notes.length > 0) {
-        content.push(...notes);
-        notes.length = 0; // Clear so they don't get appended again
-    }
     // Perform OCR if enabled
     if (config.ocr && config.extractAttachments) {
         for (const attachment of attachments) {
@@ -1712,20 +1724,12 @@ const parseRtf = async (buffer, config) => {
     populateNoteText(content);
     populateNoteText(notes);
     const toTextSync = () => {
-        let text = content.map(c => c.text).join(config.newlineDelimiter);
-        if (config.putNotesAtLast && notes.length > 0) {
-            text += config.newlineDelimiter + notes.map(c => c.text).join(config.newlineDelimiter);
-        }
-        return text;
+        return content.map(c => c.text).join(config.newlineDelimiter);
     };
     const result = (0, astUtils_js_1.createAST)('rtf', {
     // RTF Limitation: No style map available (RTF uses inline styles)
     }, content, attachments, // PNG and JPEG images extracted from \\pict groups
-    config, toTextSync);
-    // If putNotesAtLast is true, append notes to the end of the content array
-    if (config.putNotesAtLast && notes.length > 0) {
-        content.push(...notes);
-    }
+    config, undefined, toTextSync);
     return result;
 };
 exports.parseRtf = parseRtf;