All new

alle new

node_modules/mammoth/lib/xml/index.js

@@ -0,0 +1,8 @@
+var nodes = require("./nodes");
+
+exports.Element = nodes.Element;
+exports.element = nodes.element;
+exports.emptyElement = nodes.emptyElement;
+exports.text = nodes.text;
+exports.readString = require("./reader").readString;
+exports.writeString = require("./writer").writeString;

node_modules/mammoth/lib/xml/nodes.js

@@ -0,0 +1,70 @@
+var _ = require("underscore");
+
+
+exports.Element = Element;
+exports.element = function(name, attributes, children) {
+    return new Element(name, attributes, children);
+};
+exports.text = function(value) {
+    return {
+        type: "text",
+        value: value
+    };
+};
+
+
+var emptyElement = exports.emptyElement = {
+    first: function() {
+        return null;
+    },
+    firstOrEmpty: function() {
+        return emptyElement;
+    },
+    attributes: {},
+    children: []
+};
+
+function Element(name, attributes, children) {
+    this.type = "element";
+    this.name = name;
+    this.attributes = attributes || {};
+    this.children = children || [];
+}
+
+Element.prototype.first = function(name) {
+    return _.find(this.children, function(child) {
+        return child.name === name;
+    });
+};
+
+Element.prototype.firstOrEmpty = function(name) {
+    return this.first(name) || emptyElement;
+};
+
+Element.prototype.getElementsByTagName = function(name) {
+    var elements = _.filter(this.children, function(child) {
+        return child.name === name;
+    });
+    return toElementList(elements);
+};
+
+Element.prototype.text = function() {
+    if (this.children.length === 0) {
+        return "";
+    } else if (this.children.length !== 1 || this.children[0].type !== "text") {
+        throw new Error("Not implemented");
+    }
+    return this.children[0].value;
+};
+
+var elementListPrototype = {
+    getElementsByTagName: function(name) {
+        return toElementList(_.flatten(this.map(function(element) {
+            return element.getElementsByTagName(name);
+        }, true)));
+    }
+};
+
+function toElementList(array) {
+    return _.extend(array, elementListPrototype);
+}

node_modules/mammoth/lib/xml/reader.js

@@ -0,0 +1,69 @@
+var promises = require("../promises");
+var _ = require("underscore");
+
+var xmldom = require("./xmldom");
+var nodes = require("./nodes");
+var Element = nodes.Element;
+
+exports.readString = readString;
+
+var Node = xmldom.Node;
+
+function readString(xmlString, namespaceMap) {
+    namespaceMap = namespaceMap || {};
+
+    try {
+        var document = xmldom.parseFromString(xmlString, "text/xml");
+    } catch (error) {
+        return promises.reject(error);
+    }
+
+    if (document.documentElement.tagName === "parsererror") {
+        return promises.resolve(new Error(document.documentElement.textContent));
+    }
+
+    function convertNode(node) {
+        switch (node.nodeType) {
+        case Node.ELEMENT_NODE:
+            return convertElement(node);
+        case Node.TEXT_NODE:
+            return nodes.text(node.nodeValue);
+        }
+    }
+
+    function convertElement(element) {
+        var convertedName = convertName(element);
+
+        var convertedChildren = [];
+        _.forEach(element.childNodes, function(childNode) {
+            var convertedNode = convertNode(childNode);
+            if (convertedNode) {
+                convertedChildren.push(convertedNode);
+            }
+        });
+
+        var convertedAttributes = Object.create(null);
+        _.forEach(element.attributes, function(attribute) {
+            convertedAttributes[convertName(attribute)] = attribute.value;
+        });
+
+        return new Element(convertedName, convertedAttributes, convertedChildren);
+    }
+
+    function convertName(node) {
+        if (node.namespaceURI) {
+            var mappedPrefix = namespaceMap[node.namespaceURI];
+            var prefix;
+            if (mappedPrefix) {
+                prefix = mappedPrefix + ":";
+            } else {
+                prefix = "{" + node.namespaceURI + "}";
+            }
+            return prefix + node.localName;
+        } else {
+            return node.localName;
+        }
+    }
+
+    return promises.resolve(convertNode(document.documentElement));
+}

node_modules/mammoth/lib/xml/writer.js

@@ -0,0 +1,61 @@
+var _ = require("underscore");
+var xmlbuilder = require("xmlbuilder");
+
+
+exports.writeString = writeString;
+
+
+function writeString(root, namespaces) {
+    var uriToPrefix = _.invert(namespaces);
+    
+    var nodeWriters = {
+        element: writeElement,
+        text: writeTextNode
+    };
+
+    function writeNode(builder, node) {
+        return nodeWriters[node.type](builder, node);
+    }
+
+    function writeElement(builder, element) {
+        var elementBuilder = builder.element(mapElementName(element.name), element.attributes);
+        element.children.forEach(function(child) {
+            writeNode(elementBuilder, child);
+        });
+    }
+    
+    function mapElementName(name) {
+        var longFormMatch = /^\{(.*)\}(.*)$/.exec(name);
+        if (longFormMatch) {
+            var prefix = uriToPrefix[longFormMatch[1]];
+            return prefix + (prefix === "" ? "" : ":") + longFormMatch[2];
+        } else {
+            return name;
+        }
+    }
+    
+    function writeDocument(root) {
+        var builder = xmlbuilder
+            .create(mapElementName(root.name), {
+                version: '1.0',
+                encoding: 'UTF-8',
+                standalone: true
+            });
+        
+        _.forEach(namespaces, function(uri, prefix) {
+            var key = "xmlns" + (prefix === "" ? "" : ":" + prefix);
+            builder.attribute(key, uri);
+        });
+        
+        root.children.forEach(function(child) {
+            writeNode(builder, child);
+        });
+        return builder.end();
+    }
+
+    return writeDocument(root);
+}
+
+function writeTextNode(builder, node) {
+    builder.text(node.value);
+}

node_modules/mammoth/lib/xml/xmldom.js

@@ -0,0 +1,23 @@
+var xmldom = require("@xmldom/xmldom");
+var dom = require("@xmldom/xmldom/lib/dom");
+
+function parseFromString(string) {
+    var error = null;
+
+    var domParser = new xmldom.DOMParser({
+        errorHandler: function(level, message) {
+            error = {level: level, message: message};
+        }
+    });
+
+    var document = domParser.parseFromString(string);
+
+    if (error === null) {
+        return document;
+    } else {
+        throw new Error(error.level + ": " + error.message);
+    }
+}
+
+exports.parseFromString = parseFromString;
+exports.Node = dom.Node;