@depup/mammoth 1.12.0-depup.54

package/lib/options-reader.js

@@ -0,0 +1,107 @@
+exports.readOptions = readOptions;
+
+
+var _ = require("underscore");
+
+var defaultStyleMap = exports._defaultStyleMap = [
+    "p.Heading1 => h1:fresh",
+    "p.Heading2 => h2:fresh",
+    "p.Heading3 => h3:fresh",
+    "p.Heading4 => h4:fresh",
+    "p.Heading5 => h5:fresh",
+    "p.Heading6 => h6:fresh",
+    "p[style-name='Heading 1'] => h1:fresh",
+    "p[style-name='Heading 2'] => h2:fresh",
+    "p[style-name='Heading 3'] => h3:fresh",
+    "p[style-name='Heading 4'] => h4:fresh",
+    "p[style-name='Heading 5'] => h5:fresh",
+    "p[style-name='Heading 6'] => h6:fresh",
+    "p[style-name='heading 1'] => h1:fresh",
+    "p[style-name='heading 2'] => h2:fresh",
+    "p[style-name='heading 3'] => h3:fresh",
+    "p[style-name='heading 4'] => h4:fresh",
+    "p[style-name='heading 5'] => h5:fresh",
+    "p[style-name='heading 6'] => h6:fresh",
+
+    // Apple Pages
+    "p.Heading => h1:fresh",
+    "p[style-name='Heading'] => h1:fresh",
+
+    "r[style-name='Strong'] => strong",
+
+    "p[style-name='footnote text'] => p:fresh",
+    "r[style-name='footnote reference'] =>",
+    "p[style-name='endnote text'] => p:fresh",
+    "r[style-name='endnote reference'] =>",
+    "p[style-name='annotation text'] => p:fresh",
+    "r[style-name='annotation reference'] =>",
+
+    // LibreOffice
+    "p[style-name='Footnote'] => p:fresh",
+    "r[style-name='Footnote anchor'] =>",
+    "p[style-name='Endnote'] => p:fresh",
+    "r[style-name='Endnote anchor'] =>",
+
+    "p:unordered-list(1) => ul > li:fresh",
+    "p:unordered-list(2) => ul|ol > li > ul > li:fresh",
+    "p:unordered-list(3) => ul|ol > li > ul|ol > li > ul > li:fresh",
+    "p:unordered-list(4) => ul|ol > li > ul|ol > li > ul|ol > li > ul > li:fresh",
+    "p:unordered-list(5) => ul|ol > li > ul|ol > li > ul|ol > li > ul|ol > li > ul > li:fresh",
+    "p:ordered-list(1) => ol > li:fresh",
+    "p:ordered-list(2) => ul|ol > li > ol > li:fresh",
+    "p:ordered-list(3) => ul|ol > li > ul|ol > li > ol > li:fresh",
+    "p:ordered-list(4) => ul|ol > li > ul|ol > li > ul|ol > li > ol > li:fresh",
+    "p:ordered-list(5) => ul|ol > li > ul|ol > li > ul|ol > li > ul|ol > li > ol > li:fresh",
+
+    "r[style-name='Hyperlink'] =>",
+
+    "p[style-name='Normal'] => p:fresh",
+
+    // Apple Pages
+    "p.Body => p:fresh",
+    "p[style-name='Body'] => p:fresh"
+];
+
+var standardOptions = exports._standardOptions = {
+    externalFileAccess: false,
+    transformDocument: identity,
+    includeDefaultStyleMap: true,
+    includeEmbeddedStyleMap: true
+};
+
+function readOptions(options) {
+    options = options || {};
+    return _.extend({}, standardOptions, options, {
+        customStyleMap: readStyleMap(options.styleMap),
+        readStyleMap: function() {
+            var styleMap = this.customStyleMap;
+            if (this.includeEmbeddedStyleMap) {
+                styleMap = styleMap.concat(readStyleMap(this.embeddedStyleMap));
+            }
+            if (this.includeDefaultStyleMap) {
+                styleMap = styleMap.concat(defaultStyleMap);
+            }
+            return styleMap;
+        }
+    });
+}
+
+function readStyleMap(styleMap) {
+    if (!styleMap) {
+        return [];
+    } else if (_.isString(styleMap)) {
+        return styleMap.split("\n")
+            .map(function(line) {
+                return line.trim();
+            })
+            .filter(function(line) {
+                return line !== "" && line.charAt(0) !== "#";
+            });
+    } else {
+        return styleMap;
+    }
+}
+
+function identity(value) {
+    return value;
+}

package/lib/promises.js

@@ -0,0 +1,42 @@
+var _ = require("underscore");
+var bluebird = require("bluebird/js/release/promise")();
+
+exports.defer = defer;
+exports.when = bluebird.resolve;
+exports.resolve = bluebird.resolve;
+exports.all = bluebird.all;
+exports.props = bluebird.props;
+exports.reject = bluebird.reject;
+exports.promisify = bluebird.promisify;
+exports.mapSeries = bluebird.mapSeries;
+exports.attempt = bluebird.attempt;
+
+exports.nfcall = function(func) {
+    var args = Array.prototype.slice.call(arguments, 1);
+    var promisedFunc = bluebird.promisify(func);
+    return promisedFunc.apply(null, args);
+};
+
+bluebird.prototype.fail = bluebird.prototype.caught;
+
+bluebird.prototype.also = function(func) {
+    return this.then(function(value) {
+        var returnValue = _.extend({}, value, func(value));
+        return bluebird.props(returnValue);
+    });
+};
+
+function defer() {
+    var resolve;
+    var reject;
+    var promise = new bluebird.Promise(function(resolveArg, rejectArg) {
+        resolve = resolveArg;
+        reject = rejectArg;
+    });
+
+    return {
+        resolve: resolve,
+        reject: reject,
+        promise: promise
+    };
+}

package/lib/raw-text.js

@@ -0,0 +1,14 @@
+var documents = require("./documents");
+
+function convertElementToRawText(element) {
+    if (element.type === "text") {
+        return element.value;
+    } else if (element.type === documents.types.tab) {
+        return "\t";
+    } else {
+        var tail = element.type === "paragraph" ? "\n\n" : "";
+        return (element.children || []).map(convertElementToRawText).join("") + tail;
+    }
+}
+
+exports.convertElementToRawText = convertElementToRawText;

package/lib/results.js

@@ -0,0 +1,72 @@
+var _ = require("underscore");
+
+
+exports.Result = Result;
+exports.success = success;
+exports.warning = warning;
+exports.error = error;
+
+
+function Result(value, messages) {
+    this.value = value;
+    this.messages = messages || [];
+}
+
+Result.prototype.map = function(func) {
+    return new Result(func(this.value), this.messages);
+};
+
+Result.prototype.flatMap = function(func) {
+    var funcResult = func(this.value);
+    return new Result(funcResult.value, combineMessages([this, funcResult]));
+};
+
+Result.prototype.flatMapThen = function(func) {
+    var that = this;
+    return func(this.value).then(function(otherResult) {
+        return new Result(otherResult.value, combineMessages([that, otherResult]));
+    });
+};
+
+Result.combine = function(results) {
+    var values = _.flatten(_.pluck(results, "value"));
+    var messages = combineMessages(results);
+    return new Result(values, messages);
+};
+
+function success(value) {
+    return new Result(value, []);
+}
+
+function warning(message) {
+    return {
+        type: "warning",
+        message: message
+    };
+}
+
+function error(exception) {
+    return {
+        type: "error",
+        message: exception.message,
+        error: exception
+    };
+}
+
+function combineMessages(results) {
+    var messages = [];
+    _.flatten(_.pluck(results, "messages"), true).forEach(function(message) {
+        if (!containsMessage(messages, message)) {
+            messages.push(message);
+        }
+    });
+    return messages;
+}
+
+function containsMessage(messages, message) {
+    return _.find(messages, isSameMessage.bind(null, message)) !== undefined;
+}
+
+function isSameMessage(first, second) {
+    return first.type === second.type && first.message === second.message;
+}

package/lib/style-reader.js

@@ -0,0 +1,365 @@
+var _ = require("underscore");
+var lop = require("lop");
+
+var documentMatchers = require("./styles/document-matchers");
+var htmlPaths = require("./styles/html-paths");
+var tokenise = require("./styles/parser/tokeniser").tokenise;
+var results = require("./results");
+
+exports.readHtmlPath = readHtmlPath;
+exports.readDocumentMatcher = readDocumentMatcher;
+exports.readStyle = readStyle;
+
+
+function readStyle(string) {
+    return parseString(styleRule, string);
+}
+
+function createStyleRule() {
+    return lop.rules.sequence(
+        lop.rules.sequence.capture(documentMatcherRule()),
+        lop.rules.tokenOfType("whitespace"),
+        lop.rules.tokenOfType("arrow"),
+        lop.rules.sequence.capture(lop.rules.optional(lop.rules.sequence(
+            lop.rules.tokenOfType("whitespace"),
+            lop.rules.sequence.capture(htmlPathRule())
+        ).head())),
+        lop.rules.tokenOfType("end")
+    ).map(function(documentMatcher, htmlPath) {
+        return {
+            from: documentMatcher,
+            to: htmlPath.valueOrElse(htmlPaths.empty)
+        };
+    });
+}
+
+function readDocumentMatcher(string) {
+    return parseString(documentMatcherRule(), string);
+}
+
+function documentMatcherRule() {
+    var sequence = lop.rules.sequence;
+
+    var identifierToConstant = function(identifier, constant) {
+        return lop.rules.then(
+            lop.rules.token("identifier", identifier),
+            function() {
+                return constant;
+            }
+        );
+    };
+
+    var paragraphRule = identifierToConstant("p", documentMatchers.paragraph);
+    var runRule = identifierToConstant("r", documentMatchers.run);
+
+    var elementTypeRule = lop.rules.firstOf("p or r or table",
+        paragraphRule,
+        runRule
+    );
+
+    var styleIdRule = lop.rules.sequence(
+        lop.rules.tokenOfType("dot"),
+        lop.rules.sequence.cut(),
+        lop.rules.sequence.capture(identifierRule)
+    ).map(function(styleId) {
+        return {styleId: styleId};
+    });
+
+    var styleNameMatcherRule = lop.rules.firstOf("style name matcher",
+        lop.rules.then(
+            lop.rules.sequence(
+                lop.rules.tokenOfType("equals"),
+                lop.rules.sequence.cut(),
+                lop.rules.sequence.capture(stringRule)
+            ).head(),
+            function(styleName) {
+                return {styleName: documentMatchers.equalTo(styleName)};
+            }
+        ),
+        lop.rules.then(
+            lop.rules.sequence(
+                lop.rules.tokenOfType("startsWith"),
+                lop.rules.sequence.cut(),
+                lop.rules.sequence.capture(stringRule)
+            ).head(),
+            function(styleName) {
+                return {styleName: documentMatchers.startsWith(styleName)};
+            }
+        )
+    );
+
+    var styleNameRule = lop.rules.sequence(
+        lop.rules.tokenOfType("open-square-bracket"),
+        lop.rules.sequence.cut(),
+        lop.rules.token("identifier", "style-name"),
+        lop.rules.sequence.capture(styleNameMatcherRule),
+        lop.rules.tokenOfType("close-square-bracket")
+    ).head();
+
+
+    var listTypeRule = lop.rules.firstOf("list type",
+        identifierToConstant("ordered-list", {isOrdered: true}),
+        identifierToConstant("unordered-list", {isOrdered: false})
+    );
+    var listRule = sequence(
+        lop.rules.tokenOfType("colon"),
+        sequence.capture(listTypeRule),
+        sequence.cut(),
+        lop.rules.tokenOfType("open-paren"),
+        sequence.capture(integerRule),
+        lop.rules.tokenOfType("close-paren")
+    ).map(function(listType, levelNumber) {
+        return {
+            list: {
+                isOrdered: listType.isOrdered,
+                levelIndex: levelNumber - 1
+            }
+        };
+    });
+
+    function createMatcherSuffixesRule(rules) {
+        var matcherSuffix = lop.rules.firstOf.apply(
+            lop.rules.firstOf,
+            ["matcher suffix"].concat(rules)
+        );
+        var matcherSuffixes = lop.rules.zeroOrMore(matcherSuffix);
+        return lop.rules.then(matcherSuffixes, function(suffixes) {
+            var matcherOptions = {};
+            suffixes.forEach(function(suffix) {
+                _.extend(matcherOptions, suffix);
+            });
+            return matcherOptions;
+        });
+    }
+
+    var paragraphOrRun = sequence(
+        sequence.capture(elementTypeRule),
+        sequence.capture(createMatcherSuffixesRule([
+            styleIdRule,
+            styleNameRule,
+            listRule
+        ]))
+    ).map(function(createMatcher, matcherOptions) {
+        return createMatcher(matcherOptions);
+    });
+
+    var table = sequence(
+        lop.rules.token("identifier", "table"),
+        sequence.capture(createMatcherSuffixesRule([
+            styleIdRule,
+            styleNameRule
+        ]))
+    ).map(function(options) {
+        return documentMatchers.table(options);
+    });
+
+    var bold = identifierToConstant("b", documentMatchers.bold);
+    var italic = identifierToConstant("i", documentMatchers.italic);
+    var underline = identifierToConstant("u", documentMatchers.underline);
+    var strikethrough = identifierToConstant("strike", documentMatchers.strikethrough);
+    var allCaps = identifierToConstant("all-caps", documentMatchers.allCaps);
+    var smallCaps = identifierToConstant("small-caps", documentMatchers.smallCaps);
+
+    var highlight = sequence(
+        lop.rules.token("identifier", "highlight"),
+        lop.rules.sequence.capture(lop.rules.optional(lop.rules.sequence(
+            lop.rules.tokenOfType("open-square-bracket"),
+            lop.rules.sequence.cut(),
+            lop.rules.token("identifier", "color"),
+            lop.rules.tokenOfType("equals"),
+            lop.rules.sequence.capture(stringRule),
+            lop.rules.tokenOfType("close-square-bracket")
+        ).head()))
+    ).map(function(color) {
+        return documentMatchers.highlight({
+            color: color.valueOrElse(undefined)
+        });
+    });
+
+    var commentReference = identifierToConstant("comment-reference", documentMatchers.commentReference);
+
+    var breakMatcher = sequence(
+        lop.rules.token("identifier", "br"),
+        sequence.cut(),
+        lop.rules.tokenOfType("open-square-bracket"),
+        lop.rules.token("identifier", "type"),
+        lop.rules.tokenOfType("equals"),
+        sequence.capture(stringRule),
+        lop.rules.tokenOfType("close-square-bracket")
+    ).map(function(breakType) {
+        switch (breakType) {
+        case "line":
+            return documentMatchers.lineBreak;
+        case "page":
+            return documentMatchers.pageBreak;
+        case "column":
+            return documentMatchers.columnBreak;
+        default:
+            // TODO: handle unknown document matchers
+        }
+    });
+
+    return lop.rules.firstOf("element type",
+        paragraphOrRun,
+        table,
+        bold,
+        italic,
+        underline,
+        strikethrough,
+        allCaps,
+        smallCaps,
+        highlight,
+        commentReference,
+        breakMatcher
+    );
+}
+
+function readHtmlPath(string) {
+    return parseString(htmlPathRule(), string);
+}
+
+function htmlPathRule() {
+    var capture = lop.rules.sequence.capture;
+    var whitespaceRule = lop.rules.tokenOfType("whitespace");
+    var freshRule = lop.rules.then(
+        lop.rules.optional(lop.rules.sequence(
+            lop.rules.tokenOfType("colon"),
+            lop.rules.token("identifier", "fresh")
+        )),
+        function(option) {
+            return option.map(function() {
+                return true;
+            }).valueOrElse(false);
+        }
+    );
+
+    var separatorRule = lop.rules.then(
+        lop.rules.optional(lop.rules.sequence(
+            lop.rules.tokenOfType("colon"),
+            lop.rules.token("identifier", "separator"),
+            lop.rules.tokenOfType("open-paren"),
+            capture(stringRule),
+            lop.rules.tokenOfType("close-paren")
+        ).head()),
+        function(option) {
+            return option.valueOrElse("");
+        }
+    );
+
+    var tagNamesRule = lop.rules.oneOrMoreWithSeparator(
+        identifierRule,
+        lop.rules.tokenOfType("choice")
+    );
+
+    var styleElementRule = lop.rules.sequence(
+        capture(tagNamesRule),
+        capture(lop.rules.zeroOrMore(attributeOrClassRule)),
+        capture(freshRule),
+        capture(separatorRule)
+    ).map(function(tagName, attributesList, fresh, separator) {
+        var attributes = {};
+        var options = {};
+        attributesList.forEach(function(attribute) {
+            if (attribute.append && attributes[attribute.name]) {
+                attributes[attribute.name] += " " + attribute.value;
+            } else {
+                attributes[attribute.name] = attribute.value;
+            }
+        });
+        if (fresh) {
+            options.fresh = true;
+        }
+        if (separator) {
+            options.separator = separator;
+        }
+        return htmlPaths.element(tagName, attributes, options);
+    });
+
+    return lop.rules.firstOf("html path",
+        lop.rules.then(lop.rules.tokenOfType("bang"), function() {
+            return htmlPaths.ignore;
+        }),
+        lop.rules.then(
+            lop.rules.zeroOrMoreWithSeparator(
+                styleElementRule,
+                lop.rules.sequence(
+                    whitespaceRule,
+                    lop.rules.tokenOfType("gt"),
+                    whitespaceRule
+                )
+            ),
+            htmlPaths.elements
+        )
+    );
+}
+
+var identifierRule = lop.rules.then(
+    lop.rules.tokenOfType("identifier"),
+    decodeEscapeSequences
+);
+var integerRule = lop.rules.tokenOfType("integer");
+
+var stringRule = lop.rules.then(
+    lop.rules.tokenOfType("string"),
+    decodeEscapeSequences
+);
+
+var escapeSequences = {
+    "n": "\n",
+    "r": "\r",
+    "t": "\t"
+};
+
+function decodeEscapeSequences(value) {
+    return value.replace(/\\(.)/g, function(match, code) {
+        return escapeSequences[code] || code;
+    });
+}
+
+var attributeRule = lop.rules.sequence(
+    lop.rules.tokenOfType("open-square-bracket"),
+    lop.rules.sequence.cut(),
+    lop.rules.sequence.capture(identifierRule),
+    lop.rules.tokenOfType("equals"),
+    lop.rules.sequence.capture(stringRule),
+    lop.rules.tokenOfType("close-square-bracket")
+).map(function(name, value) {
+    return {name: name, value: value, append: false};
+});
+
+var classRule = lop.rules.sequence(
+    lop.rules.tokenOfType("dot"),
+    lop.rules.sequence.cut(),
+    lop.rules.sequence.capture(identifierRule)
+).map(function(className) {
+    return {name: "class", value: className, append: true};
+});
+
+var attributeOrClassRule = lop.rules.firstOf(
+    "attribute or class",
+    attributeRule,
+    classRule
+);
+
+function parseString(rule, string) {
+    var tokens = tokenise(string);
+    var parser = lop.Parser();
+    var parseResult = parser.parseTokens(rule, tokens);
+    if (parseResult.isSuccess()) {
+        return results.success(parseResult.value());
+    } else {
+        return new results.Result(null, [results.warning(describeFailure(string, parseResult))]);
+    }
+}
+
+function describeFailure(input, parseResult) {
+    return "Did not understand this style mapping, so ignored it: " + input + "\n" +
+        parseResult.errors().map(describeError).join("\n");
+}
+
+function describeError(error) {
+    return "Error was at character number " + error.characterNumber() + ": " +
+        "Expected " + error.expected + " but got " + error.actual;
+}
+
+var styleRule = createStyleRule();

package/lib/styles/document-matchers.js

@@ -0,0 +1,100 @@
+exports.paragraph = paragraph;
+exports.run = run;
+exports.table = table;
+exports.bold = new Matcher("bold");
+exports.italic = new Matcher("italic");
+exports.underline = new Matcher("underline");
+exports.strikethrough = new Matcher("strikethrough");
+exports.allCaps = new Matcher("allCaps");
+exports.smallCaps = new Matcher("smallCaps");
+exports.highlight = highlight;
+exports.commentReference = new Matcher("commentReference");
+exports.lineBreak = new BreakMatcher({breakType: "line"});
+exports.pageBreak = new BreakMatcher({breakType: "page"});
+exports.columnBreak = new BreakMatcher({breakType: "column"});
+exports.equalTo = equalTo;
+exports.startsWith = startsWith;
+
+
+function paragraph(options) {
+    return new Matcher("paragraph", options);
+}
+
+function run(options) {
+    return new Matcher("run", options);
+}
+
+function table(options) {
+    return new Matcher("table", options);
+}
+
+function highlight(options) {
+    return new HighlightMatcher(options);
+}
+
+function Matcher(elementType, options) {
+    options = options || {};
+    this._elementType = elementType;
+    this._styleId = options.styleId;
+    this._styleName = options.styleName;
+    if (options.list) {
+        this._listIndex = options.list.levelIndex;
+        this._listIsOrdered = options.list.isOrdered;
+    }
+}
+
+Matcher.prototype.matches = function(element) {
+    return element.type === this._elementType &&
+        (this._styleId === undefined || element.styleId === this._styleId) &&
+        (this._styleName === undefined || (element.styleName && this._styleName.operator(this._styleName.operand, element.styleName))) &&
+        (this._listIndex === undefined || isList(element, this._listIndex, this._listIsOrdered)) &&
+        (this._breakType === undefined || this._breakType === element.breakType);
+};
+
+function HighlightMatcher(options) {
+    options = options || {};
+    this._color = options.color;
+}
+
+HighlightMatcher.prototype.matches = function(element) {
+    return element.type === "highlight" &&
+        (this._color === undefined || element.color === this._color);
+};
+
+function BreakMatcher(options) {
+    options = options || {};
+    this._breakType = options.breakType;
+}
+
+BreakMatcher.prototype.matches = function(element) {
+    return element.type === "break" &&
+        (this._breakType === undefined || element.breakType === this._breakType);
+};
+
+function isList(element, levelIndex, isOrdered) {
+    return element.numbering &&
+        element.numbering.level == levelIndex &&
+        element.numbering.isOrdered == isOrdered;
+}
+
+function equalTo(value) {
+    return {
+        operator: operatorEqualTo,
+        operand: value
+    };
+}
+
+function startsWith(value) {
+    return {
+        operator: operatorStartsWith,
+        operand: value
+    };
+}
+
+function operatorEqualTo(first, second) {
+    return first.toUpperCase() === second.toUpperCase();
+}
+
+function operatorStartsWith(first, second) {
+    return second.toUpperCase().indexOf(first.toUpperCase()) === 0;
+}