@hyperlex/mammoth 1.4.9-beta

package/lib/writers/html-writer.js

@@ -0,0 +1,160 @@
+var util = require("util");
+var _ = require("underscore");
+
+exports.writer = writer;
+
+function writer(options) {
+    options = options || {};
+    if (options.prettyPrint) {
+        return prettyWriter();
+    } else {
+        return simpleWriter();
+    }
+}
+
+
+var indentedElements = {
+    div: true,
+    p: true,
+    ul: true,
+    li: true
+};
+
+
+function prettyWriter() {
+    var indentationLevel = 0;
+    var indentation = "  ";
+    var stack = [];
+    var start = true;
+    var inText = false;
+    
+    var writer = simpleWriter();
+    
+    function open(tagName, attributes) {
+        if (indentedElements[tagName]) {
+            indent();
+        }
+        stack.push(tagName);
+        writer.open(tagName, attributes);
+        if (indentedElements[tagName]) {
+            indentationLevel++;
+        }
+        start = false;
+    }
+    
+    function close(tagName) {
+        if (indentedElements[tagName]) {
+            indentationLevel--;
+            indent();
+        }
+        stack.pop();
+        writer.close(tagName);
+    }
+    
+    function text(value) {
+        startText();
+        var text = isInPre() ? value : value.replace("\n", "\n" + indentation);
+        writer.text(text);
+    }
+    
+    function selfClosing(tagName, attributes) {
+        indent();
+        writer.selfClosing(tagName, attributes);
+    }
+    
+    function insideIndentedElement() {
+        return stack.length === 0 || indentedElements[stack[stack.length - 1]];
+    }
+    
+    function startText() {
+        if (!inText) {
+            indent();
+            inText = true;
+        }
+    }
+    
+    function indent() {
+        inText = false;
+        if (!start && insideIndentedElement() && !isInPre()) {
+            writer._append("\n");
+            for (var i = 0; i < indentationLevel; i++) {
+                writer._append(indentation);
+            }
+        }
+    }
+    
+    function isInPre() {
+        return _.some(stack, function(tagName) {
+            return tagName === "pre";
+        });
+    }
+    
+    return {
+        asString: writer.asString,
+        open: open,
+        close: close,
+        text: text,
+        selfClosing: selfClosing
+    };
+}
+
+
+function simpleWriter() {
+    var fragments = [];
+    
+    function open(tagName, attributes) {
+        var attributeString = generateAttributeString(attributes);
+        fragments.push(util.format("<%s%s>", tagName, attributeString));
+    }
+    
+    function close(tagName) {
+        fragments.push(util.format("</%s>", tagName));
+    }
+    
+    function selfClosing(tagName, attributes) {
+        var attributeString = generateAttributeString(attributes);
+        fragments.push(util.format("<%s%s />", tagName, attributeString));
+    }
+    
+    function generateAttributeString(attributes) {
+        return _.map(attributes, function(value, key) {
+            return util.format(' %s="%s"', key, escapeHtmlAttribute(value));
+        }).join("");
+    }
+    
+    function text(value) {
+        fragments.push(escapeHtmlText(value));
+    }
+    
+    function append(html) {
+        fragments.push(html);
+    }
+    
+    function asString() {
+        return fragments.join("");
+    }
+    
+    return {
+        asString: asString,
+        open: open,
+        close: close,
+        text: text,
+        selfClosing: selfClosing,
+        _append: append
+    };
+}
+
+function escapeHtmlText(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+
+function escapeHtmlAttribute(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/"/g, '&quot;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}

package/lib/writers/index.js

@@ -0,0 +1,14 @@
+var htmlWriter = require("./html-writer");
+var markdownWriter = require("./markdown-writer");
+
+exports.writer = writer;
+
+
+function writer(options) {
+    options = options || {};
+    if (options.outputFormat === "markdown") {
+        return markdownWriter.writer();
+    } else {
+        return htmlWriter.writer(options);
+    }
+}

package/lib/writers/markdown-writer.js

@@ -0,0 +1,163 @@
+var _ = require("underscore");
+
+
+function symmetricMarkdownElement(end) {
+    return markdownElement(end, end);
+}
+
+function markdownElement(start, end) {
+    return function() {
+        return {start: start, end: end};
+    };
+}
+
+function markdownLink(attributes) {
+    var href = attributes.href || "";
+    if (href) {
+        return {
+            start: "[",
+            end: "](" + href + ")",
+            anchorPosition: "before"
+        };
+    } else {
+        return {};
+    }
+}
+
+function markdownImage(attributes) {
+    var src = attributes.src || "";
+    var altText = attributes.alt || "";
+    if (src || altText) {
+        return {start: "![" + altText + "](" + src + ")"};
+    } else {
+        return {};
+    }
+}
+
+function markdownList(options) {
+    return function(attributes, list) {
+        return {
+            start: list ? "\n" : "",
+            end: list ? "" : "\n",
+            list: {
+                isOrdered: options.isOrdered,
+                indent: list ? list.indent + 1 : 0,
+                count: 0
+            }
+        };
+    };
+}
+
+function markdownListItem(attributes, list, listItem) {
+    list = list || {indent: 0, isOrdered: false, count: 0};
+    list.count++;
+    listItem.hasClosed = false;
+    
+    var bullet = list.isOrdered ? list.count + "." : "-";
+    var start = repeatString("\t", list.indent) + bullet + " ";
+        
+    return {
+        start: start,
+        end: function() {
+            if (!listItem.hasClosed) {
+                listItem.hasClosed = true;
+                return "\n";
+            }
+        }
+    };
+}
+
+var htmlToMarkdown = {
+    "p": markdownElement("", "\n\n"),
+    "br": markdownElement("", "  \n"),
+    "ul": markdownList({isOrdered: false}),
+    "ol": markdownList({isOrdered: true}),
+    "li": markdownListItem,
+    "strong": symmetricMarkdownElement("__"),
+    "em": symmetricMarkdownElement("*"),
+    "a": markdownLink,
+    "img": markdownImage
+};
+
+(function() {
+    for (var i = 1; i <= 6; i++) {
+        htmlToMarkdown["h" + i] = markdownElement(repeatString("#", i) + " ", "\n\n");
+    }
+})();
+
+function repeatString(value, count) {
+    return new Array(count + 1).join(value);
+}
+
+function markdownWriter() {
+    var fragments = [];
+    var elementStack = [];
+    var list = null;
+    var listItem = {};
+    
+    function open(tagName, attributes) {
+        attributes = attributes || {};
+        
+        var createElement = htmlToMarkdown[tagName] || function() {
+            return {};
+        };
+        var element = createElement(attributes, list, listItem);
+        elementStack.push({end: element.end, list: list});
+        
+        if (element.list) {
+            list = element.list;
+        }
+        
+        var anchorBeforeStart = element.anchorPosition === "before";
+        if (anchorBeforeStart) {
+            writeAnchor(attributes);
+        }
+
+        fragments.push(element.start || "");
+        if (!anchorBeforeStart) {
+            writeAnchor(attributes);
+        }
+    }
+    
+    function writeAnchor(attributes) {
+        if (attributes.id) {
+            fragments.push('<a id="' + attributes.id + '"></a>');
+        }
+    }
+    
+    function close(tagName) {
+        var element = elementStack.pop();
+        list = element.list;
+        var end = _.isFunction(element.end) ? element.end() : element.end;
+        fragments.push(end || "");
+    }
+    
+    function selfClosing(tagName, attributes) {
+        open(tagName, attributes);
+        close(tagName);
+    }
+    
+    function text(value) {
+        fragments.push(escapeMarkdown(value));
+    }
+    
+    function asString() {
+        return fragments.join("");
+    }
+
+    return {
+        asString: asString,
+        open: open,
+        close: close,
+        text: text,
+        selfClosing: selfClosing
+    };
+}
+
+exports.writer = markdownWriter;
+
+function escapeMarkdown(value) {
+    return value
+        .replace(/\\/g, '\\\\')
+        .replace(/([\`\*_\{\}\[\]\(\)\#\+\-\.\!])/g, '\\$1');
+}

package/lib/xml/index.js

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

package/lib/xml/nodes.js

@@ -0,0 +1,69 @@
+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 = {
+    first: function() {
+        return null;
+    },
+    firstOrEmpty: function() {
+        return emptyElement;
+    },
+    attributes: {}
+};
+
+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);
+}

package/lib/xml/reader.js

@@ -0,0 +1,83 @@
+var promises = require("../promises");
+var sax = require("sax");
+var _ = require("underscore");
+
+var nodes = require("./nodes");
+var Element = nodes.Element;
+
+exports.readString = readString;
+
+function readString(xmlString, namespaceMap) {
+    namespaceMap = namespaceMap || {};
+    
+    var finished = false;
+    var parser = sax.parser(true, {xmlns: true, position: false});
+    
+    var rootElement = {children: []};
+    var currentElement = rootElement;
+    var stack = [];
+    
+    var deferred = promises.defer();
+    
+    parser.onopentag = function(node) {
+        var attributes = mapObject(node.attributes, function(attribute) {
+            return attribute.value;
+        }, mapName);
+        
+        var element = new Element(mapName(node), attributes);
+        currentElement.children.push(element);
+        stack.push(currentElement);
+        currentElement = element;
+    };
+    
+    function mapName(node) {
+        if (node.uri) {
+            var mappedPrefix = namespaceMap[node.uri];
+            var prefix;
+            if (mappedPrefix) {
+                prefix = mappedPrefix + ":";
+            } else {
+                prefix = "{" + node.uri + "}";
+            }
+            return prefix + node.local;
+        } else {
+            return node.local;
+        }
+    }
+    
+    parser.onclosetag = function(node) {
+        currentElement = stack.pop();
+    };
+    
+    parser.ontext = function(text) {
+        if (currentElement !== rootElement) {
+            currentElement.children.push(nodes.text(text));
+        }
+    };
+    
+    parser.onend = function() {
+        if (!finished) {
+            finished = true;
+            deferred.resolve(rootElement.children[0]);
+        }
+    };
+    
+    parser.onerror = function(error) {
+        if (!finished) {
+            finished = true;
+            deferred.reject(error);
+        }
+    };
+    
+    parser.write(xmlString).close();
+    
+    return deferred.promise;
+}
+
+function mapObject(input, valueFunc, keyFunc) {
+    return _.reduce(input, function(result, value, key) {
+        var mappedKey = keyFunc(value, key, input);
+        result[mappedKey] = valueFunc(value, key, input);
+        return result;
+    }, {});
+}

package/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);
+}

package/lib/zipfile.js

@@ -0,0 +1,77 @@
+var JSZip = require("jszip");
+
+var promises = require("./promises");
+
+exports.openArrayBuffer = openArrayBuffer;
+exports.splitPath = splitPath;
+exports.joinPath = joinPath;
+
+function openArrayBuffer(arrayBuffer) {
+    var zipFile = new JSZip(arrayBuffer);
+    function exists(name) {
+        return zipFile.file(name) !== null;
+    }
+
+    function read(name, encoding) {
+        var array = zipFile.file(name).asUint8Array();
+        var buffer = uint8ArrayToBuffer(array);
+        if (encoding) {
+            return promises.when(buffer.toString(encoding));
+        } else {
+            return promises.when(buffer);
+        }
+    }
+
+    function write(name, contents) {
+        zipFile.file(name, contents);
+    }
+
+    function toBuffer() {
+        return zipFile.generate({type: "nodebuffer"});
+    }
+
+    return {
+        exists: exists,
+        read: read,
+        write: write,
+        toBuffer: toBuffer
+    };
+}
+
+function uint8ArrayToBuffer(array) {
+    if (Buffer.from && Buffer.from !== Uint8Array.from) {
+        return Buffer.from(array);
+    } else {
+        return new Buffer(array);
+    }
+}
+
+function splitPath(path) {
+    var lastIndex = path.lastIndexOf("/");
+    if (lastIndex === -1) {
+        return {dirname: "", basename: path};
+    } else {
+        return {
+            dirname: path.substring(0, lastIndex),
+            basename: path.substring(lastIndex + 1)
+        };
+    }
+}
+
+function joinPath() {
+    var nonEmptyPaths = Array.prototype.filter.call(arguments, function(path) {
+        return path;
+    });
+
+    var relevantPaths = [];
+
+    nonEmptyPaths.forEach(function(path) {
+        if (/^\//.test(path)) {
+            relevantPaths = [path];
+        } else {
+            relevantPaths.push(path);
+        }
+    });
+
+    return relevantPaths.join("/");
+}