docx-to-html-mathml-v2 0.1.2

package/lib/writers/html-writer.js

@@ -0,0 +1,167 @@
+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";
+        });
+    }
+
+    function raw(value) {
+        // giữ format indent giống text: nếu đang trong block indent thì indent trước
+        startText();
+        writer._append(value);   // ✅ ghi thẳng
+    }
+
+    return {
+        asString: writer.asString,
+        open: open,
+        close: close,
+        text: text,
+        selfClosing: selfClosing,
+        raw: raw,
+    };
+}
+
+
+function simpleWriter() {
+    var fragments = [];
+
+    function open(tagName, attributes) {
+        var attributeString = generateAttributeString(attributes);
+        fragments.push("<" + tagName + attributeString + ">");
+    }
+
+    function close(tagName) {
+        fragments.push("</" + tagName + ">");
+    }
+
+    function selfClosing(tagName, attributes) {
+        var attributeString = generateAttributeString(attributes);
+        fragments.push("<" + tagName + attributeString + " />");
+    }
+
+    function generateAttributeString(attributes) {
+        return _.map(attributes, function (value, key) {
+            return " " + 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,
+        raw: 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,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;

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

package/lib/xml/reader.js

@@ -0,0 +1,75 @@
+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 = {};
+        _.forEach(element.attributes, function (attribute) {
+            convertedAttributes[convertName(attribute)] = attribute.value;
+        });
+
+        // return new Element(convertedName, convertedAttributes, convertedChildren);
+        var el = new Element(convertedName, convertedAttributes, convertedChildren);
+
+        // Giữ raw XML nguyên bản
+        el._rawXml = element.toString();
+
+        return el;
+    }
+
+    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));
+}

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/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;

package/lib/zipfile.js

@@ -0,0 +1,72 @@
+var base64js = require("base64-js");
+var JSZip = require("jszip");
+
+exports.openArrayBuffer = openArrayBuffer;
+exports.splitPath = splitPath;
+exports.joinPath = joinPath;
+
+function openArrayBuffer(arrayBuffer) {
+    return JSZip.loadAsync(arrayBuffer).then(function(zipFile) {
+        function exists(name) {
+            return zipFile.file(name) !== null;
+        }
+
+        function read(name, encoding) {
+            return zipFile.file(name).async("uint8array").then(function(array) {
+                if (encoding === "base64") {
+                    return base64js.fromByteArray(array);
+                } else if (encoding) {
+                    var decoder = new TextDecoder(encoding);
+                    return decoder.decode(array);
+                } else {
+                    return array;
+                }
+            });
+        }
+
+        function write(name, contents) {
+            zipFile.file(name, contents);
+        }
+
+        function toArrayBuffer() {
+            return zipFile.generateAsync({type: "arraybuffer"});
+        }
+
+        return {
+            exists: exists,
+            read: read,
+            write: write,
+            toArrayBuffer: toArrayBuffer
+        };
+    });
+}
+
+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("/");
+}