@depup/mammoth 1.12.0-depup.54

package/lib/docx/comments-reader.js

@@ -0,0 +1,31 @@
+var documents = require("../documents");
+var Result = require("../results").Result;
+
+function createCommentsReader(bodyReader) {
+    function readCommentsXml(element) {
+        return Result.combine(element.getElementsByTagName("w:comment")
+            .map(readCommentElement));
+    }
+
+    function readCommentElement(element) {
+        var id = element.attributes["w:id"];
+
+        function readOptionalAttribute(name) {
+            return (element.attributes[name] || "").trim() || null;
+        }
+
+        return bodyReader.readXmlElements(element.children)
+            .map(function(body) {
+                return documents.comment({
+                    commentId: id,
+                    body: body,
+                    authorName: readOptionalAttribute("w:author"),
+                    authorInitials: readOptionalAttribute("w:initials")
+                });
+            });
+    }
+    
+    return readCommentsXml;
+}
+
+exports.createCommentsReader = createCommentsReader;

package/lib/docx/content-types-reader.js

@@ -0,0 +1,58 @@
+exports.readContentTypesFromXml = readContentTypesFromXml;
+
+var fallbackContentTypes = {
+    "png": "png",
+    "gif": "gif",
+    "jpeg": "jpeg",
+    "jpg": "jpeg",
+    "tif": "tiff",
+    "tiff": "tiff",
+    "bmp": "bmp"
+};
+
+exports.defaultContentTypes = contentTypes({}, {});
+
+
+function readContentTypesFromXml(element) {
+    var extensionDefaults = {};
+    var overrides = {};
+    
+    element.children.forEach(function(child) {
+        if (child.name === "content-types:Default") {
+            extensionDefaults[child.attributes.Extension] = child.attributes.ContentType;
+        }
+        if (child.name === "content-types:Override") {
+            var name = child.attributes.PartName;
+            if (name.charAt(0) === "/") {
+                name = name.substring(1);
+            }
+            overrides[name] = child.attributes.ContentType;
+        }
+    });
+    return contentTypes(overrides, extensionDefaults);
+}
+
+function contentTypes(overrides, extensionDefaults) {
+    return {
+        findContentType: function(path) {
+            var overrideContentType = overrides[path];
+            if (overrideContentType) {
+                return overrideContentType;
+            } else {
+                var pathParts = path.split(".");
+                var extension = pathParts[pathParts.length - 1];
+                if (extensionDefaults.hasOwnProperty(extension)) {
+                    return extensionDefaults[extension];
+                } else {
+                    var fallback = fallbackContentTypes[extension.toLowerCase()];
+                    if (fallback) {
+                        return "image/" + fallback;
+                    } else {
+                        return null;
+                    }
+                }
+            }
+        }
+    };
+    
+}

package/lib/docx/document-xml-reader.js

@@ -0,0 +1,30 @@
+exports.DocumentXmlReader = DocumentXmlReader;
+
+var documents = require("../documents");
+var Result = require("../results").Result;
+
+
+function DocumentXmlReader(options) {
+    var bodyReader = options.bodyReader;
+
+    function convertXmlToDocument(element) {
+        var body = element.first("w:body");
+
+        if (body == null) {
+            throw new Error("Could not find the body element: are you sure this is a docx file?");
+        }
+
+        var result = bodyReader.readXmlElements(body.children)
+            .map(function(children) {
+                return new documents.Document(children, {
+                    notes: options.notes,
+                    comments: options.comments
+                });
+            });
+        return new Result(result.value, result.messages);
+    }
+
+    return {
+        convertXmlToDocument: convertXmlToDocument
+    };
+}

package/lib/docx/docx-reader.js

@@ -0,0 +1,226 @@
+exports.read = read;
+exports._findPartPaths = findPartPaths;
+
+var promises = require("../promises");
+var documents = require("../documents");
+var Result = require("../results").Result;
+var zipfile = require("../zipfile");
+
+var readXmlFromZipFile = require("./office-xml-reader").readXmlFromZipFile;
+var createBodyReader = require("./body-reader").createBodyReader;
+var DocumentXmlReader = require("./document-xml-reader").DocumentXmlReader;
+var relationshipsReader = require("./relationships-reader");
+var contentTypesReader = require("./content-types-reader");
+var numberingXml = require("./numbering-xml");
+var stylesReader = require("./styles-reader");
+var notesReader = require("./notes-reader");
+var commentsReader = require("./comments-reader");
+var Files = require("./files").Files;
+
+
+function read(docxFile, input, options) {
+    input = input || {};
+    options = options || {};
+
+    var files = new Files({
+        externalFileAccess: options.externalFileAccess,
+        relativeToFile: input.path
+    });
+
+    return promises.props({
+        contentTypes: readContentTypesFromZipFile(docxFile),
+        partPaths: findPartPaths(docxFile),
+        docxFile: docxFile,
+        files: files
+    }).also(function(result) {
+        return {
+            styles: readStylesFromZipFile(docxFile, result.partPaths.styles)
+        };
+    }).also(function(result) {
+        return {
+            numbering: readNumberingFromZipFile(docxFile, result.partPaths.numbering, result.styles)
+        };
+    }).also(function(result) {
+        return {
+            footnotes: readXmlFileWithBody(result.partPaths.footnotes, result, function(bodyReader, xml) {
+                if (xml) {
+                    return notesReader.createFootnotesReader(bodyReader)(xml);
+                } else {
+                    return new Result([]);
+                }
+            }),
+            endnotes: readXmlFileWithBody(result.partPaths.endnotes, result, function(bodyReader, xml) {
+                if (xml) {
+                    return notesReader.createEndnotesReader(bodyReader)(xml);
+                } else {
+                    return new Result([]);
+                }
+            }),
+            comments: readXmlFileWithBody(result.partPaths.comments, result, function(bodyReader, xml) {
+                if (xml) {
+                    return commentsReader.createCommentsReader(bodyReader)(xml);
+                } else {
+                    return new Result([]);
+                }
+            })
+        };
+    }).also(function(result) {
+        return {
+            notes: result.footnotes.flatMap(function(footnotes) {
+                return result.endnotes.map(function(endnotes) {
+                    return new documents.Notes(footnotes.concat(endnotes));
+                });
+            })
+        };
+    }).then(function(result) {
+        return readXmlFileWithBody(result.partPaths.mainDocument, result, function(bodyReader, xml) {
+            return result.notes.flatMap(function(notes) {
+                return result.comments.flatMap(function(comments) {
+                    var reader = new DocumentXmlReader({
+                        bodyReader: bodyReader,
+                        notes: notes,
+                        comments: comments
+                    });
+                    return reader.convertXmlToDocument(xml);
+                });
+            });
+        });
+    });
+}
+
+function findPartPaths(docxFile) {
+    return readPackageRelationships(docxFile).then(function(packageRelationships) {
+        var mainDocumentPath = findPartPath({
+            docxFile: docxFile,
+            relationships: packageRelationships,
+            relationshipType: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+            basePath: "",
+            fallbackPath: "word/document.xml"
+        });
+
+        if (!docxFile.exists(mainDocumentPath)) {
+            throw new Error("Could not find main document part. Are you sure this is a valid .docx file?");
+        }
+
+        return xmlFileReader({
+            filename: relationshipsFilename(mainDocumentPath),
+            readElement: relationshipsReader.readRelationships,
+            defaultValue: relationshipsReader.defaultValue
+        })(docxFile).then(function(documentRelationships) {
+            function findPartRelatedToMainDocument(name) {
+                return findPartPath({
+                    docxFile: docxFile,
+                    relationships: documentRelationships,
+                    relationshipType: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/" + name,
+                    basePath: zipfile.splitPath(mainDocumentPath).dirname,
+                    fallbackPath: "word/" + name + ".xml"
+                });
+            }
+
+            return {
+                mainDocument: mainDocumentPath,
+                comments: findPartRelatedToMainDocument("comments"),
+                endnotes: findPartRelatedToMainDocument("endnotes"),
+                footnotes: findPartRelatedToMainDocument("footnotes"),
+                numbering: findPartRelatedToMainDocument("numbering"),
+                styles: findPartRelatedToMainDocument("styles")
+            };
+        });
+    });
+}
+
+function findPartPath(options) {
+    var docxFile = options.docxFile;
+    var relationships = options.relationships;
+    var relationshipType = options.relationshipType;
+    var basePath = options.basePath;
+    var fallbackPath = options.fallbackPath;
+
+    var targets = relationships.findTargetsByType(relationshipType);
+    var normalisedTargets = targets.map(function(target) {
+        return stripPrefix(zipfile.joinPath(basePath, target), "/");
+    });
+    var validTargets = normalisedTargets.filter(function(target) {
+        return docxFile.exists(target);
+    });
+    if (validTargets.length === 0) {
+        return fallbackPath;
+    } else {
+        return validTargets[0];
+    }
+}
+
+function stripPrefix(value, prefix) {
+    if (value.substring(0, prefix.length) === prefix) {
+        return value.substring(prefix.length);
+    } else {
+        return value;
+    }
+}
+
+function xmlFileReader(options) {
+    return function(zipFile) {
+        return readXmlFromZipFile(zipFile, options.filename)
+            .then(function(element) {
+                return element ? options.readElement(element) : options.defaultValue;
+            });
+    };
+}
+
+function readXmlFileWithBody(filename, options, func) {
+    var readRelationshipsFromZipFile = xmlFileReader({
+        filename: relationshipsFilename(filename),
+        readElement: relationshipsReader.readRelationships,
+        defaultValue: relationshipsReader.defaultValue
+    });
+
+    return readRelationshipsFromZipFile(options.docxFile).then(function(relationships) {
+        var bodyReader = new createBodyReader({
+            relationships: relationships,
+            contentTypes: options.contentTypes,
+            docxFile: options.docxFile,
+            numbering: options.numbering,
+            styles: options.styles,
+            files: options.files
+        });
+        return readXmlFromZipFile(options.docxFile, filename)
+            .then(function(xml) {
+                return func(bodyReader, xml);
+            });
+    });
+}
+
+function relationshipsFilename(filename) {
+    var split = zipfile.splitPath(filename);
+    return zipfile.joinPath(split.dirname, "_rels", split.basename + ".rels");
+}
+
+var readContentTypesFromZipFile = xmlFileReader({
+    filename: "[Content_Types].xml",
+    readElement: contentTypesReader.readContentTypesFromXml,
+    defaultValue: contentTypesReader.defaultContentTypes
+});
+
+function readNumberingFromZipFile(zipFile, path, styles) {
+    return xmlFileReader({
+        filename: path,
+        readElement: function(element) {
+            return numberingXml.readNumberingXml(element, {styles: styles});
+        },
+        defaultValue: numberingXml.defaultNumbering
+    })(zipFile);
+}
+
+function readStylesFromZipFile(zipFile, path) {
+    return xmlFileReader({
+        filename: path,
+        readElement: stylesReader.readStylesXml,
+        defaultValue: stylesReader.defaultStyles
+    })(zipFile);
+}
+
+var readPackageRelationships = xmlFileReader({
+    filename: "_rels/.rels",
+    readElement: relationshipsReader.readRelationships,
+    defaultValue: relationshipsReader.defaultValue
+});

package/lib/docx/files.js

@@ -0,0 +1,80 @@
+var fs = require("fs");
+var url = require("url");
+var os = require("os");
+var dirname = require("path").dirname;
+var resolvePath = require("path").resolve;
+var isAbsolutePath = require('path-is-absolute');
+
+var promises = require("../promises");
+
+
+exports.Files = Files;
+exports.uriToPath = uriToPath;
+
+
+function Files(options) {
+    options = options || {};
+    if (!options.externalFileAccess) {
+        return {
+            read: function(uri) {
+                return promises.reject(new Error("could not read external image '" + uri + "', external file access is disabled"));
+            }
+        };
+    }
+
+    var base = options.relativeToFile ? dirname(options.relativeToFile) : null;
+
+    function read(uri, encoding) {
+        return resolveUri(uri).then(function(path) {
+            return readFile(path, encoding).caught(function(error) {
+                var message = "could not open external image: '" + uri + "' (document directory: '" + base + "')\n" + error.message;
+                return promises.reject(new Error(message));
+            });
+        });
+    }
+
+    function resolveUri(uri) {
+        var path = uriToPath(uri);
+        if (isAbsolutePath(path)) {
+            return promises.resolve(path);
+        } else if (base) {
+            return promises.resolve(resolvePath(base, path));
+        } else {
+            return promises.reject(new Error("could not find external image '" + uri + "', path of input document is unknown"));
+        }
+    }
+
+    return {
+        read: read
+    };
+}
+
+
+var readFile = promises.promisify(fs.readFile.bind(fs));
+
+
+function uriToPath(uriString, platform) {
+    if (!platform) {
+        platform = os.platform();
+    }
+
+    var uri = url.parse(uriString);
+    if (isLocalFileUri(uri) || isRelativeUri(uri)) {
+        var path = decodeURIComponent(uri.path);
+        if (platform === "win32" && /^\/[a-z]:/i.test(path)) {
+            return path.slice(1);
+        } else {
+            return path;
+        }
+    } else {
+        throw new Error("Could not convert URI to path: " + uriString);
+    }
+}
+
+function isLocalFileUri(uri) {
+    return uri.protocol === "file:" && (!uri.host || uri.host === "localhost");
+}
+
+function isRelativeUri(uri) {
+    return !uri.protocol && !uri.host;
+}

package/lib/docx/notes-reader.js

@@ -0,0 +1,28 @@
+var documents = require("../documents");
+var Result = require("../results").Result;
+
+exports.createFootnotesReader = createReader.bind(this, "footnote");
+exports.createEndnotesReader = createReader.bind(this, "endnote");
+
+function createReader(noteType, bodyReader) {
+    function readNotesXml(element) {
+        return Result.combine(element.getElementsByTagName("w:" + noteType)
+            .filter(isFootnoteElement)
+            .map(readFootnoteElement));
+    }
+
+    function isFootnoteElement(element) {
+        var type = element.attributes["w:type"];
+        return type !== "continuationSeparator" && type !== "separator";
+    }
+
+    function readFootnoteElement(footnoteElement) {
+        var id = footnoteElement.attributes["w:id"];
+        return bodyReader.readXmlElements(footnoteElement.children)
+            .map(function(body) {
+                return documents.Note({noteType: noteType, noteId: id, body: body});
+            });
+    }
+    
+    return readNotesXml;
+}

package/lib/docx/numbering-xml.js

@@ -0,0 +1,111 @@
+var _ = require("underscore");
+
+exports.readNumberingXml = readNumberingXml;
+exports.Numbering = Numbering;
+exports.defaultNumbering = new Numbering({}, {});
+
+function Numbering(nums, abstractNums, styles) {
+    var allLevels = _.flatten(_.values(abstractNums).map(function(abstractNum) {
+        return _.values(abstractNum.levels);
+    }));
+
+    var levelsByParagraphStyleId = _.indexBy(
+        allLevels.filter(function(level) {
+            return level.paragraphStyleId != null;
+        }),
+        "paragraphStyleId"
+    );
+
+    function findLevel(numId, level) {
+        var num = nums[numId];
+        if (num) {
+            var abstractNum = abstractNums[num.abstractNumId];
+            if (!abstractNum) {
+                return null;
+            } else if (abstractNum.numStyleLink == null) {
+                return abstractNums[num.abstractNumId].levels[level];
+            } else {
+                var style = styles.findNumberingStyleById(abstractNum.numStyleLink);
+                return findLevel(style.numId, level);
+            }
+        } else {
+            return null;
+        }
+    }
+
+    function findLevelByParagraphStyleId(styleId) {
+        return levelsByParagraphStyleId[styleId] || null;
+    }
+
+    return {
+        findLevel: findLevel,
+        findLevelByParagraphStyleId: findLevelByParagraphStyleId
+    };
+}
+
+function readNumberingXml(root, options) {
+    if (!options || !options.styles) {
+        throw new Error("styles is missing");
+    }
+
+    var abstractNums = readAbstractNums(root);
+    var nums = readNums(root, abstractNums);
+    return new Numbering(nums, abstractNums, options.styles);
+}
+
+function readAbstractNums(root) {
+    var abstractNums = {};
+    root.getElementsByTagName("w:abstractNum").forEach(function(element) {
+        var id = element.attributes["w:abstractNumId"];
+        abstractNums[id] = readAbstractNum(element);
+    });
+    return abstractNums;
+}
+
+function readAbstractNum(element) {
+    var levels = {};
+
+    // Some malformed documents define numbering levels without an index, and
+    // reference the numbering using a w:numPr element without a w:ilvl child.
+    // To handle such cases, we assume a level of 0 as a fallback.
+    var levelWithoutIndex = null;
+
+    element.getElementsByTagName("w:lvl").forEach(function(levelElement) {
+        var levelIndex = levelElement.attributes["w:ilvl"];
+        var numFmt = levelElement.firstOrEmpty("w:numFmt").attributes["w:val"];
+        var isOrdered = numFmt !== "bullet";
+        var paragraphStyleId = levelElement.firstOrEmpty("w:pStyle").attributes["w:val"];
+
+        if (levelIndex === undefined) {
+            levelWithoutIndex = {
+                isOrdered: isOrdered,
+                level: "0",
+                paragraphStyleId: paragraphStyleId
+            };
+        } else {
+            levels[levelIndex] = {
+                isOrdered: isOrdered,
+                level: levelIndex,
+                paragraphStyleId: paragraphStyleId
+            };
+        }
+    });
+
+    if (levelWithoutIndex !== null && levels[levelWithoutIndex.level] === undefined) {
+        levels[levelWithoutIndex.level] = levelWithoutIndex;
+    }
+
+    var numStyleLink = element.firstOrEmpty("w:numStyleLink").attributes["w:val"];
+
+    return {levels: levels, numStyleLink: numStyleLink};
+}
+
+function readNums(root) {
+    var nums = {};
+    root.getElementsByTagName("w:num").forEach(function(element) {
+        var numId = element.attributes["w:numId"];
+        var abstractNumId = element.first("w:abstractNumId").attributes["w:val"];
+        nums[numId] = {abstractNumId: abstractNumId};
+    });
+    return nums;
+}

package/lib/docx/office-xml-reader.js

@@ -0,0 +1,73 @@
+var _ = require("underscore");
+
+var promises = require("../promises");
+var xml = require("../xml");
+
+
+exports.read = read;
+exports.readXmlFromZipFile = readXmlFromZipFile;
+
+var xmlNamespaceMap = {
+    // Transitional format
+    "http://schemas.openxmlformats.org/wordprocessingml/2006/main": "w",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships": "r",
+    "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing": "wp",
+    "http://schemas.openxmlformats.org/drawingml/2006/main": "a",
+    "http://schemas.openxmlformats.org/drawingml/2006/picture": "pic",
+
+    // Strict format
+    "http://purl.oclc.org/ooxml/wordprocessingml/main": "w",
+    "http://purl.oclc.org/ooxml/officeDocument/relationships": "r",
+    "http://purl.oclc.org/ooxml/drawingml/wordprocessingDrawing": "wp",
+    "http://purl.oclc.org/ooxml/drawingml/main": "a",
+    "http://purl.oclc.org/ooxml/drawingml/picture": "pic",
+
+    // Common
+    "http://schemas.openxmlformats.org/package/2006/content-types": "content-types",
+    "http://schemas.openxmlformats.org/package/2006/relationships": "relationships",
+    "http://schemas.openxmlformats.org/markup-compatibility/2006": "mc",
+    "urn:schemas-microsoft-com:vml": "v",
+    "urn:schemas-microsoft-com:office:word": "office-word",
+
+    // [MS-DOCX]: Word Extensions to the Office Open XML (.docx) File Format
+    // https://learn.microsoft.com/en-us/openspecs/office_standards/ms-docx/b839fe1f-e1ca-4fa6-8c26-5954d0abbccd
+    "http://schemas.microsoft.com/office/word/2010/wordml": "wordml"
+};
+
+
+function read(xmlString) {
+    return xml.readString(xmlString, xmlNamespaceMap)
+        .then(function(document) {
+            return collapseAlternateContent(document)[0];
+        });
+}
+
+
+function readXmlFromZipFile(docxFile, path) {
+    if (docxFile.exists(path)) {
+        return docxFile.read(path, "utf-8")
+            .then(stripUtf8Bom)
+            .then(read);
+    } else {
+        return promises.resolve(null);
+    }
+}
+
+
+function stripUtf8Bom(xmlString) {
+    return xmlString.replace(/^\uFEFF/g, '');
+}
+
+
+function collapseAlternateContent(node) {
+    if (node.type === "element") {
+        if (node.name === "mc:AlternateContent") {
+            return node.firstOrEmpty("mc:Fallback").children;
+        } else {
+            node.children = _.flatten(node.children.map(collapseAlternateContent, true));
+            return [node];
+        }
+    } else {
+        return [node];
+    }
+}

package/lib/docx/relationships-reader.js

@@ -0,0 +1,43 @@
+exports.readRelationships = readRelationships;
+exports.defaultValue = new Relationships([]);
+exports.Relationships = Relationships;
+
+
+function readRelationships(element) {
+    var relationships = [];
+    element.children.forEach(function(child) {
+        if (child.name === "relationships:Relationship") {
+            var relationship = {
+                relationshipId: child.attributes.Id,
+                target: child.attributes.Target,
+                type: child.attributes.Type
+            };
+            relationships.push(relationship);
+        }
+    });
+    return new Relationships(relationships);
+}
+
+function Relationships(relationships) {
+    var targetsByRelationshipId = {};
+    relationships.forEach(function(relationship) {
+        targetsByRelationshipId[relationship.relationshipId] = relationship.target;
+    });
+
+    var targetsByType = {};
+    relationships.forEach(function(relationship) {
+        if (!targetsByType[relationship.type]) {
+            targetsByType[relationship.type] = [];
+        }
+        targetsByType[relationship.type].push(relationship.target);
+    });
+
+    return {
+        findTargetByRelationshipId: function(relationshipId) {
+            return targetsByRelationshipId[relationshipId];
+        },
+        findTargetsByType: function(type) {
+            return targetsByType[type] || [];
+        }
+    };
+}