@hyperlex/mammoth 1.4.10 → 1.4.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperlex/mammoth",
-  "version": "1.4.10",
+  "version": "1.4.21",
   "author": "Michael Williamson <mike@zwobble.org>",
   "description": "Convert Word documents from docx to simple HTML and Markdown",
   "keywords": [
@@ -19,30 +19,29 @@
   "dependencies": {
     "argparse": "~1.0.3",
     "bluebird": "~3.4.0",
-    "jszip": "~2.5.0",
-    "lop": "~0.4.1",
+    "dingbat-to-unicode": "^1.0.1",
+    "jszip": "^3.7.1",
+    "lop": "^0.4.1",
     "path-is-absolute": "^1.0.0",
     "sax": "~1.1.1",
-    "underscore": "~1.13.1",
+    "underscore": "^1.13.1",
     "xmlbuilder": "^10.0.0"
   },
   "devDependencies": {
     "browserify": "~13.0.1",
     "browserify-prepend-licenses": "~1.0.0",
-    "duck": "~0.1.12",
+    "duck": "^0.1.12",
     "eslint": "^7.28.0",
     "hamjest": "^3.7.2",
     "mocha": "~7.2.0",
-    "temp": "~0.9.4",
+    "temp": "^0.9.4",
     "uglify-js": "~2.8.29"
   },
   "browser": {
-    "./lib/unzip.js": "./browser/unzip.js",
-    "./lib/docx/files.js": "./browser/docx/files.js"
-  },
-  "bin": {
-    "mammoth": "bin/mammoth"
+    "./lib/docx/files.js": "./browser/docx/files.js",
+    "./lib/unzip.js": "./browser/unzip.js"
   },
+  "bin": "bin/mammoth",
   "scripts": {
     "pretest": "eslint lib test",
     "test": "mocha 'test/**/*.tests.js'",
@@ -62,4 +61,4 @@
     "lib": "lib",
     "test": "test"
   }
-}
+}

package/test/document-to-html.tests.js

@@ -330,6 +330,30 @@ test('subscript runs are wrapped in <sub> tags', function() {
     });
 });
 
+test('all caps runs are ignored by default', function() {
+    var run = runOfText("Hello.", {isAllCaps: true});
+    var converter = new DocumentConverter();
+    return converter.convertToHtml(run).then(function(result) {
+        assert.equal(result.value, "Hello.");
+    });
+});
+
+test('all caps runs can be configured with style mapping', function() {
+    var run = runOfText("Hello.", {isAllCaps: true});
+    var converter = new DocumentConverter({
+        styleMap: [
+            {
+                from: documentMatchers.allCaps,
+                to: htmlPaths.elements([htmlPaths.element("span")])
+            }
+        ]
+    });
+    return converter.convertToHtml(run).then(function(result) {
+        assert.equal(result.value, "<span>Hello.</span>");
+    });
+});
+
+
 test('small caps runs are ignored by default', function() {
     var run = runOfText("Hello.", {isSmallCaps: true});
     var converter = new DocumentConverter();

package/test/docx/body-reader.tests.js

@@ -24,7 +24,7 @@ var _readNumberingProperties = require("../../lib/docx/body-reader")._readNumber
 var documents = require("../../lib/documents");
 var xml = require("../../lib/xml");
 var XmlElement = xml.Element;
-var Numbering = require("../../lib/docx/numbering-xml").Numbering;
+var defaultNumbering = require("../../lib/docx/numbering-xml").defaultNumbering;
 var Relationships = require("../../lib/docx/relationships-reader").Relationships;
 var Styles = require("../../lib/docx/styles-reader").Styles;
 var warning = require("../../lib/results").warning;
@@ -36,6 +36,7 @@ var createFakeDocxFile = testing.createFakeDocxFile;
 function readXmlElement(element, options) {
     options = Object.create(options || {});
     options.styles = options.styles || new Styles({}, {});
+    options.numbering = options.numbering || defaultNumbering;
     return createBodyReader(options).readXmlElement(element);
 }
 
@@ -207,21 +208,45 @@ test("paragraph has numbering properties from paragraph properties if present",
     var propertiesXml = new XmlElement("w:pPr", {}, [numberingPropertiesXml]);
     var paragraphXml = new XmlElement("w:p", {}, [propertiesXml]);
 
-    var numbering = new NumberingMap({"42": {"1": {isOrdered: true, level: "1"}}});
+    var numbering = new NumberingMap({
+        findLevel: {"42": {"1": {isOrdered: true, level: "1"}}}
+    });
 
     var paragraph = readXmlElementValue(paragraphXml, {numbering: numbering});
     assert.deepEqual(paragraph.numbering, {level: "1", isOrdered: true});
 });
 
+test("numbering on paragraph style takes precedence over numPr", function() {
+    var numberingPropertiesXml = new XmlElement("w:numPr", {}, [
+        new XmlElement("w:ilvl", {"w:val": "1"}),
+        new XmlElement("w:numId", {"w:val": "42"})
+    ]);
+    var propertiesXml = new XmlElement("w:pPr", {}, [
+        new XmlElement("w:pStyle", {"w:val": "List"}),
+        numberingPropertiesXml
+    ]);
+    var paragraphXml = new XmlElement("w:p", {}, [propertiesXml]);
+
+    var numbering = new NumberingMap({
+        findLevelByParagraphStyleId: {"List": {isOrdered: true, level: "1"}}
+    });
+    var styles = new Styles({"List": {name: "List"}}, {});
+
+    var paragraph = readXmlElementValue(paragraphXml, {numbering: numbering, styles: styles});
+    assert.deepEqual(paragraph.numbering, {level: "1", isOrdered: true});
+});
+
 test("numbering properties are converted to numbering at specified level", function() {
     var numberingPropertiesXml = new XmlElement("w:numPr", {}, [
         new XmlElement("w:ilvl", {"w:val": "1"}),
         new XmlElement("w:numId", {"w:val": "42"})
     ]);
 
-    var numbering = new NumberingMap({"42": {"1": {isOrdered: true, level: "1"}}});
+    var numbering = new NumberingMap({
+        findLevel: {"42": {"1": {isOrdered: true, level: "1"}}}
+    });
 
-    var numberingLevel = _readNumberingProperties(numberingPropertiesXml, numbering);
+    var numberingLevel = _readNumberingProperties(null, numberingPropertiesXml, numbering);
     assert.deepEqual(numberingLevel, {level: "1", isOrdered: true});
 });
 
@@ -230,9 +255,11 @@ test("numbering properties are ignored if w:ilvl is missing", function() {
         new XmlElement("w:numId", {"w:val": "42"})
     ]);
 
-    var numbering = new Numbering({"42": {"1": {isOrdered: true, level: "1"}}});
+    var numbering = new NumberingMap({
+        findLevel: {"42": {"1": {isOrdered: true, level: "1"}}}
+    });
 
-    var numberingLevel = _readNumberingProperties(numberingPropertiesXml, numbering);
+    var numberingLevel = _readNumberingProperties(null, numberingPropertiesXml, numbering);
     assert.equal(numberingLevel, null);
 });
 
@@ -241,9 +268,11 @@ test("numbering properties are ignored if w:numId is missing", function() {
         new XmlElement("w:ilvl", {"w:val": "1"})
     ]);
 
-    var numbering = new Numbering({"42": {"1": {isOrdered: true, level: "1"}}});
+    var numbering = new NumberingMap({
+        findLevel: {"42": {"1": {isOrdered: true, level: "1"}}}
+    });
 
-    var numberingLevel = _readNumberingProperties(numberingPropertiesXml, numbering);
+    var numberingLevel = _readNumberingProperties(null, numberingPropertiesXml, numbering);
     assert.equal(numberingLevel, null);
 });
 
@@ -268,7 +297,7 @@ test("complex fields", (function() {
     function isHyperlinkedRun(hyperlinkProperties) {
         return isRun({
             children: contains(
-                isHyperlink(_.extend({href: uri}, hyperlinkProperties))
+                isHyperlink(hyperlinkProperties)
             )
         });
     }
@@ -279,7 +308,7 @@ test("complex fields", (function() {
             assert.deepEqual(instrText, []);
         },
 
-        "runs in a complex field for hyperlinks are read as hyperlinks": function() {
+        "runs in a complex field for hyperlink without switch are read as external hyperlinks": function() {
             var hyperlinkRunXml = runOfText("this is a hyperlink");
             var paragraphXml = new XmlElement("w:p", {}, [
                 beginXml,
@@ -294,6 +323,33 @@ test("complex fields", (function() {
                 isEmptyRun,
                 isEmptyHyperlinkedRun,
                 isHyperlinkedRun({
+                    href: uri,
+                    children: contains(
+                        isText("this is a hyperlink")
+                    )
+                }),
+                isEmptyRun
+            ));
+        },
+
+        "runs in a complex field for hyperlink with l switch are read as internal hyperlinks": function() {
+            var hyperlinkRunXml = runOfText("this is a hyperlink");
+            var paragraphXml = new XmlElement("w:p", {}, [
+                beginXml,
+                new XmlElement("w:instrText", {}, [
+                    xml.text(' HYPERLINK \\l "InternalLink"')
+                ]),
+                separateXml,
+                hyperlinkRunXml,
+                endXml
+            ]);
+            var paragraph = readXmlElementValue(paragraphXml);
+
+            assertThat(paragraph.children, contains(
+                isEmptyRun,
+                isEmptyHyperlinkedRun,
+                isHyperlinkedRun({
+                    anchor: "InternalLink",
                     children: contains(
                         isText("this is a hyperlink")
                     )
@@ -346,6 +402,7 @@ test("complex fields", (function() {
                 isEmptyRun,
                 isEmptyHyperlinkedRun,
                 isHyperlinkedRun({
+                    href: uri,
                     children: contains(
                         isText("this is a hyperlink")
                     )
@@ -378,6 +435,7 @@ test("complex fields", (function() {
                 isEmptyHyperlinkedRun,
                 isEmptyHyperlinkedRun,
                 isHyperlinkedRun({
+                    href: uri,
                     children: contains(
                         isText("this is a hyperlink")
                     )
@@ -409,6 +467,7 @@ test("complex fields", (function() {
                 isEmptyHyperlinkedRun,
                 isEmptyHyperlinkedRun,
                 isHyperlinkedRun({
+                    href: uri,
                     children: contains(
                         isText("John Doe")
                     )
@@ -437,6 +496,7 @@ test("complex fields", (function() {
                 isEmptyHyperlinkedRun,
                 isEmptyHyperlinkedRun,
                 isHyperlinkedRun({
+                    href: uri,
                     children: contains(
                         isText("this is a hyperlink")
                     )
@@ -503,10 +563,38 @@ test("isUnderline is false if underline element is not present", function() {
     assert.deepEqual(run.isUnderline, false);
 });
 
-test("isUnderline is true if underline element is present", function() {
+test("isUnderline is false if underline element is present without w:val attribute", function() {
     var underlineXml = new XmlElement("w:u");
     var runXml = runWithProperties([underlineXml]);
     var run = readXmlElementValue(runXml);
+    assert.equal(run.isUnderline, false);
+});
+
+test("isUnderline is false if underline element is present and w:val is false", function() {
+    var underlineXml = new XmlElement("w:u", {"w:val": "false"});
+    var runXml = runWithProperties([underlineXml]);
+    var run = readXmlElementValue(runXml);
+    assert.equal(run.isUnderline, false);
+});
+
+test("isUnderline is false if underline element is present and w:val is 0", function() {
+    var underlineXml = new XmlElement("w:u", {"w:val": "0"});
+    var runXml = runWithProperties([underlineXml]);
+    var run = readXmlElementValue(runXml);
+    assert.equal(run.isUnderline, false);
+});
+
+test("isUnderline is false if underline element is present and w:val is none", function() {
+    var underlineXml = new XmlElement("w:u", {"w:val": "none"});
+    var runXml = runWithProperties([underlineXml]);
+    var run = readXmlElementValue(runXml);
+    assert.equal(run.isUnderline, false);
+});
+
+test("isUnderline is true if underline element is present and w:val is not none or falsy", function() {
+    var underlineXml = new XmlElement("w:u", {"w:val": "single"});
+    var runXml = runWithProperties([underlineXml]);
+    var run = readXmlElementValue(runXml);
     assert.equal(run.isUnderline, true);
 });
 
@@ -554,6 +642,7 @@ var booleanRunProperties = [
     {name: "isUnderline", tagName: "w:u"},
     {name: "isItalic", tagName: "w:i"},
     {name: "isStrikethrough", tagName: "w:strike"},
+    {name: "isAllCaps", tagName: "w:caps"},
     {name: "isSmallCaps", tagName: "w:smallCaps"}
 ];
 
@@ -632,6 +721,29 @@ test("run has highlight read from properties", function() {
     assert.deepEqual(run.highlight, "FFFFFF");
 });
 
+test("run has null fontSize by default", function() {
+    var runXml = runWithProperties([]);
+
+    var run = readXmlElementValue(runXml);
+    assert.deepEqual(run.fontSize, null);
+});
+
+test("run has fontSize read from properties", function() {
+    var fontSizeXml = new XmlElement("w:sz", {"w:val": "28"});
+    var runXml = runWithProperties([fontSizeXml]);
+
+    var run = readXmlElementValue(runXml);
+    assert.deepEqual(run.fontSize, 14);
+});
+
+test("run with invalid w:sz has null font size", function() {
+    var fontSizeXml = new XmlElement("w:sz", {"w:val": "28a"});
+    var runXml = runWithProperties([fontSizeXml]);
+
+    var run = readXmlElementValue(runXml);
+    assert.deepEqual(run.fontSize, null);
+});
+
 test("run properties not included as child of run", function() {
     var runStyleXml = new XmlElement("w:rStyle");
     var runPropertiesXml = new XmlElement("w:rPr", {}, [runStyleXml]);
@@ -652,6 +764,33 @@ test("w:noBreakHyphen is read as non-breaking hyphen character", function() {
     assert.deepEqual(result.value, new documents.Text("\u2011"));
 });
 
+test("soft hyphens are read as text", function() {
+    var element = new XmlElement("w:softHyphen", {}, []);
+    var text = readXmlElementValue(element);
+    assert.deepEqual(text, new documents.Text("\u00AD"));
+});
+
+test("w:sym with supported font and supported code point in ASCII range is converted to text", function() {
+    var element = new XmlElement("w:sym", {"w:font": "Wingdings", "w:char": "28"}, []);
+    var text = readXmlElementValue(element);
+    assert.deepEqual(text, new documents.Text("🕿"));
+});
+
+test("w:sym with supported font and supported code point in private use area is converted to text", function() {
+    var element = new XmlElement("w:sym", {"w:font": "Wingdings", "w:char": "F028"}, []);
+    var text = readXmlElementValue(element);
+    assert.deepEqual(text, new documents.Text("🕿"));
+});
+
+test("w:sym with unsupported font and code point produces empty result with warning", function() {
+    var element = new XmlElement("w:sym", {"w:font": "Dingwings", "w:char": "28"}, []);
+
+    var result = readXmlElement(element);
+
+    assert.deepEqual(result.value, []);
+    assert.deepEqual(result.messages, [warning("A w:sym element with an unsupported character was ignored: char 28 in font Dingwings")]);
+});
+
 test("w:tbl is read as document table element", function() {
     var tableXml = new XmlElement("w:tbl", {}, [
         new XmlElement("w:tr", {}, [
@@ -1015,6 +1154,18 @@ test("can read linked pictures", function() {
     }));
 });
 
+test("warning if blip has no image file", function() {
+    var drawing = createInlineImage({
+        blip: new XmlElement("a:blip"),
+        description: "It's a hat"
+    });
+
+    var result = readXmlElement(drawing);
+
+    assert.deepEqual(result.messages, [warning("Could not find image file for a:blip element")]);
+    assert.deepEqual(result.value, []);
+});
+
 test("warning if unsupported image type", function() {
     var drawing = createInlineImage({
         blip: createEmbeddedBlip("rId5"),
@@ -1333,10 +1484,16 @@ function imageRelationship(relationshipId, target) {
     };
 }
 
-function NumberingMap(nums) {
+function NumberingMap(options) {
+    var findLevel = options.findLevel;
+    var findLevelByParagraphStyleId = options.findLevelByParagraphStyleId || {};
+
     return {
         findLevel: function(numId, level) {
-            return nums[numId][level];
+            return findLevel[numId][level];
+        },
+        findLevelByParagraphStyleId: function(styleId) {
+            return findLevelByParagraphStyleId[styleId];
         }
     };
 }

package/test/docx/numbering-xml.tests.js

@@ -33,6 +33,19 @@ test('w:num element inherits levels from w:abstractNum', function() {
 });
 
 
+test('w:num element referencing non-existent w:abstractNumId is ignored', function() {
+    var numbering = readNumberingXml(
+        new XmlElement("w:numbering", {}, [
+            new XmlElement("w:num", {"w:numId": "47"}, [
+                new XmlElement("w:abstractNumId", {"w:val": "42"})
+            ])
+        ]),
+        {styles: stylesReader.defaultStyles}
+    );
+    duck.assertThat(numbering.findLevel("47", "0"), duck.equalTo(null));
+});
+
+
 test('when w:abstractNum has w:numStyleLink then style is used to find w:num', function() {
     var numbering = readNumberingXml(
         new XmlElement("w:numbering", {}, [
@@ -58,6 +71,31 @@ test('when w:abstractNum has w:numStyleLink then style is used to find w:num', f
     }));
 });
 
+
+// See: 17.9.23 pStyle (Paragraph Style's Associated Numbering Level) in ECMA-376, 4th Edition
+test('numbering level can be found by paragraph style ID', function() {
+    var numbering = readNumberingXml(
+        new XmlElement("w:numbering", {}, [
+            new XmlElement("w:abstractNum", {"w:abstractNumId": "42"}, [
+                new XmlElement("w:lvl", {"w:ilvl": "0"}, [
+                    new XmlElement("w:numFmt", {"w:val": "bullet"})
+                ])
+            ]),
+            new XmlElement("w:abstractNum", {"w:abstractNumId": "43"}, [
+                new XmlElement("w:lvl", {"w:ilvl": "0"}, [
+                    new XmlElement("w:pStyle", {"w:val": "List"}),
+                    new XmlElement("w:numFmt", {"w:val": "decimal"})
+                ])
+            ])
+        ]),
+        {styles: stylesReader.defaultStyles}
+    );
+    duck.assertThat(numbering.findLevelByParagraphStyleId("List"), duck.hasProperties({
+        isOrdered: true
+    }));
+    duck.assertThat(numbering.findLevelByParagraphStyleId("Paragraph"), duck.equalTo(null));
+});
+
 test('when styles is missing then error is thrown', function() {
     assert.throws(function() {
         readNumberingXml(new XmlElement("w:numbering", {}, []));

package/test/docx/style-map.tests.js

@@ -7,77 +7,77 @@ var styleMap = require("../../lib/docx/style-map");
 var test = require("../test")(module);
 
 test('reading embedded style map on document without embedded style map returns null', function() {
-    var zip = normalDocx();
-    
-    return styleMap.readStyleMap(zip).then(function(contents) {
-        assert.equal(contents, null);
+    return normalDocx().then(function(zip) {
+        return styleMap.readStyleMap(zip).then(function(contents) {
+            assert.equal(contents, null);
+        });
     });
 });
 
 test('embedded style map can be read after being written', function() {
-    var zip = normalDocx();
-    
-    return styleMap.writeStyleMap(zip, "p => h1").then(function() {
-        return styleMap.readStyleMap(zip).then(function(contents) {
-            assert.equal(contents, "p => h1");
+    return normalDocx().then(function(zip) {
+        return styleMap.writeStyleMap(zip, "p => h1").then(function() {
+            return styleMap.readStyleMap(zip).then(function(contents) {
+                assert.equal(contents, "p => h1");
+            });
         });
     });
 });
 
 test('embedded style map is written to separate file', function() {
-    var zip = normalDocx();
-    
-    return styleMap.writeStyleMap(zip, "p => h1").then(function() {
-        return zip.read("mammoth/style-map", "utf8").then(function(contents) {
-            assert.equal(contents, "p => h1");
+    return normalDocx().then(function(zip) {
+        return styleMap.writeStyleMap(zip, "p => h1").then(function() {
+            return zip.read("mammoth/style-map", "utf8").then(function(contents) {
+                assert.equal(contents, "p => h1");
+            });
         });
     });
 });
 
 test('embedded style map is referenced in relationships', function() {
-    var zip = normalDocx();
-    
-    return styleMap.writeStyleMap(zip, "p => h1").then(function() {
-        return zip.read("word/_rels/document.xml.rels", "utf8").then(function(contents) {
-            assert.equal(contents, expectedRelationshipsXml);
+    return normalDocx().then(function(zip) {
+        return styleMap.writeStyleMap(zip, "p => h1").then(function() {
+            return zip.read("word/_rels/document.xml.rels", "utf8").then(function(contents) {
+                assert.equal(contents, expectedRelationshipsXml);
+            });
         });
     });
 });
 
 test('re-embedding style map replaces original', function() {
-    var zip = normalDocx();
-    
-    return styleMap.writeStyleMap(zip, "p => h1").then(function() {
-        return styleMap.writeStyleMap(zip, "p => h2");
-    }).then(function() {
-        return zip.read("word/_rels/document.xml.rels", "utf8").then(function(contents) {
-            assert.equal(contents, expectedRelationshipsXml);
-        });
-    }).then(function() {
-        return styleMap.readStyleMap(zip).then(function(contents) {
-            assert.equal(contents, "p => h2");
+    return normalDocx().then(function(zip) {
+        return styleMap.writeStyleMap(zip, "p => h1").then(function() {
+            return styleMap.writeStyleMap(zip, "p => h2");
+        }).then(function() {
+            return zip.read("word/_rels/document.xml.rels", "utf8").then(function(contents) {
+                assert.equal(contents, expectedRelationshipsXml);
+            });
+        }).then(function() {
+            return styleMap.readStyleMap(zip).then(function(contents) {
+                assert.equal(contents, "p => h2");
+            });
         });
     });
 });
 
 test('embedded style map has override content type in [Content_Types].xml', function() {
-    var zip = normalDocx();
-    
-    return styleMap.writeStyleMap(zip, "p => h1").then(function() {
-        return zip.read("[Content_Types].xml", "utf8").then(function(contents) {
-            assert.equal(contents, expectedContentTypesXml);
+    return normalDocx().then(function(zip) {
+        return styleMap.writeStyleMap(zip, "p => h1").then(function() {
+            return zip.read("[Content_Types].xml", "utf8").then(function(contents) {
+                assert.equal(contents, expectedContentTypesXml);
+            });
         });
     });
 });
 
 test('replacing style map keeps content type', function() {
-    var zip = normalDocx();
-    
-    return styleMap.writeStyleMap(zip, "p => h1").then(function() {
-        return styleMap.writeStyleMap(zip, "p => h2");
-    }).then(function() {
-        return zip.read("[Content_Types].xml", "utf8").then(function(contents) {
-            assert.equal(contents, expectedContentTypesXml);
+    return normalDocx().then(function(zip) {
+        return styleMap.writeStyleMap(zip, "p => h1").then(function() {
+            return styleMap.writeStyleMap(zip, "p => h2");
+        }).then(function() {
+            return zip.read("[Content_Types].xml", "utf8").then(function(contents) {
+                assert.equal(contents, expectedContentTypesXml);
+            });
         });
     });
 });
@@ -106,7 +106,8 @@ function normalDocx() {
         '</Types>';
     zip.file("word/_rels/document.xml.rels", originalRelationshipsXml);
     zip.file("[Content_Types].xml", originalContentTypesXml);
-    var buffer = zip.generate({type: "arraybuffer"});
-    return zipfile.openArrayBuffer(buffer);
+    return zip.generateAsync({type: "arraybuffer"}).then(function(buffer) {
+        return zipfile.openArrayBuffer(buffer);
+    });
 }
 

package/test/raw-text.tests.js

@@ -0,0 +1,61 @@
+var assert = require("assert");
+
+var documents = require("../lib/documents");
+var test = require("./test")(module);
+var convertElementToRawText = require("../lib/raw-text").convertElementToRawText;
+
+
+test('text element is converted to text content', function() {
+    var element = new documents.Text("Hello.");
+
+    var result = convertElementToRawText(element);
+
+    assert.strictEqual(result, "Hello.");
+});
+
+test('tab element is converted to tab character', function() {
+    var element = documents.tab();
+
+    var result = convertElementToRawText(element);
+
+    assert.strictEqual(result, "\t");
+});
+
+test('paragraphs are terminated with newlines', function() {
+    var element = new documents.Paragraph(
+        [
+            new documents.Text("Hello "),
+            new documents.Text("world.")
+        ],
+        {}
+    );
+
+    var result = convertElementToRawText(element);
+
+    assert.strictEqual(result, "Hello world.\n\n");
+});
+
+test('children are recursively converted to text', function() {
+    var element = new documents.Document([
+        new documents.Paragraph(
+            [
+                new documents.Text("Hello "),
+                new documents.Text("world.")
+            ],
+            {}
+        )
+    ]);
+
+    var result = convertElementToRawText(element);
+
+    assert.strictEqual(result, "Hello world.\n\n");
+});
+
+
+test('non-text element without children is converted to empty string', function() {
+    var element = documents.lineBreak;
+
+    var result = convertElementToRawText(element);
+
+    assert.strictEqual(result, "");
+});