Merge branch 'master' into feat/right-indent

# Conflicts:
#	demo/21-bookmarks.ts
#	package-lock.json
#	src/file/core-properties/properties.ts
#	src/file/file.spec.ts
#	src/file/file.ts
#	src/file/footnotes/footnote/footnote.spec.ts
#	src/file/footnotes/footnote/footnote.ts
#	src/file/footnotes/footnotes.ts

src/file/paragraph/formatting/bidirectional.spec.ts

@@ -0,0 +1,15 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { Bidirectional } from "./bidirectional";
+
+describe("Bidirectional", () => {
+    it("should create", () => {
+        const bidirectional = new Bidirectional();
+        const tree = new Formatter().format(bidirectional);
+        expect(tree).to.deep.equal({
+            "w:bidi": {},
+        });
+    });
+});

src/file/paragraph/index.ts

@@ -3,3 +3,4 @@ export * from "./paragraph";
 export * from "./properties";
 export * from "./run";
 export * from "./links";
+export * from "./math";

src/file/paragraph/links/bookmark.spec.ts

@@ -19,7 +19,7 @@ describe("Bookmark", () => {
         const newJson = Utility.jsonify(bookmark);
         assert.equal(newJson.rootKey, undefined);
         assert.equal(newJson.start.rootKey, "w:bookmarkStart");
-        assert.equal(newJson.text.rootKey, "w:r");
+        assert.equal(newJson.children[0].rootKey, "w:r");
         assert.equal(newJson.end.rootKey, "w:bookmarkEnd");
     });
 
@@ -31,7 +31,7 @@ describe("Bookmark", () => {
 
     it("should create a bookmark with the correct attributes on the text element", () => {
         const newJson = Utility.jsonify(bookmark);
-        assert.equal(JSON.stringify(newJson.text.root[1].root[1]), JSON.stringify("Internal Link"));
+        assert.equal(JSON.stringify(newJson.children[0].root[1].root[1]), JSON.stringify("Internal Link"));
     });
 
     it("should create a bookmark with the correct attributes on the bookmark end element", () => {

src/file/paragraph/links/hyperlink.spec.ts

@@ -2,14 +2,20 @@ import { expect } from "chai";
 
 import { Formatter } from "export/formatter";
 
-import { Hyperlink } from "./";
-import { HyperlinkRef } from "./hyperlink";
+import { TextRun } from "../run";
+import { ConcreteHyperlink, ExternalHyperlink, InternalHyperlink } from "./hyperlink";
 
-describe("Hyperlink", () => {
-    let hyperlink: Hyperlink;
+describe("ConcreteHyperlink", () => {
+    let hyperlink: ConcreteHyperlink;
 
     beforeEach(() => {
-        hyperlink = new Hyperlink("https://example.com", "superid");
+        hyperlink = new ConcreteHyperlink(
+            new TextRun({
+                text: "https://example.com",
+                style: "Hyperlink",
+            }),
+            "superid",
+        );
     });
 
     describe("#constructor()", () => {
@@ -35,7 +41,14 @@ describe("Hyperlink", () => {
 
         describe("with optional anchor parameter", () => {
             beforeEach(() => {
-                hyperlink = new Hyperlink("Anchor Text", "superid2", "anchor");
+                hyperlink = new ConcreteHyperlink(
+                    new TextRun({
+                        text: "Anchor Text",
+                        style: "Hyperlink",
+                    }),
+                    "superid2",
+                    "anchor",
+                );
             });
 
             it("should create an internal link with anchor tag", () => {
@@ -61,10 +74,53 @@ describe("Hyperlink", () => {
     });
 });
 
-describe("HyperlinkRef", () => {
+describe("ExternalHyperlink", () => {
     describe("#constructor()", () => {
-        const hyperlinkRef = new HyperlinkRef("test-id");
+        it("should create", () => {
+            const externalHyperlink = new ExternalHyperlink({
+                child: new TextRun("test"),
+                link: "http://www.google.com",
+            });
 
-        expect(hyperlinkRef.id).to.equal("test-id");
+            expect(externalHyperlink.options.link).to.equal("http://www.google.com");
+        });
+    });
+});
+
+describe("InternalHyperlink", () => {
+    describe("#constructor()", () => {
+        it("should create", () => {
+            const internalHyperlink = new InternalHyperlink({
+                child: new TextRun("test"),
+                anchor: "test-id",
+            });
+
+            const tree = new Formatter().format(internalHyperlink);
+
+            expect(tree).to.deep.equal({
+                "w:hyperlink": [
+                    {
+                        _attr: {
+                            "w:anchor": "test-id",
+                            "w:history": 1,
+                        },
+                    },
+                    {
+                        "w:r": [
+                            {
+                                "w:t": [
+                                    {
+                                        _attr: {
+                                            "xml:space": "preserve",
+                                        },
+                                    },
+                                    "test",
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
     });
 });

src/file/paragraph/links/hyperlink.ts

@@ -1,6 +1,9 @@
 // http://officeopenxml.com/WPhyperlink.php
+import * as shortid from "shortid";
+
 import { XmlComponent } from "file/xml-components";
-import { TextRun } from "../run";
+
+import { ParagraphChild } from "../paragraph";
 import { HyperlinkAttributes, IHyperlinkAttributesProperties } from "./hyperlink-attributes";
 
 export enum HyperlinkType {
@@ -8,15 +11,10 @@ export enum HyperlinkType {
     EXTERNAL = "EXTERNAL",
 }
 
-export class HyperlinkRef {
-    constructor(public readonly id: string) {}
-}
-
-export class Hyperlink extends XmlComponent {
+export class ConcreteHyperlink extends XmlComponent {
     public readonly linkId: string;
-    private readonly textRun: TextRun;
 
-    constructor(text: string, relationshipId: string, anchor?: string) {
+    constructor(child: ParagraphChild, relationshipId: string, anchor?: string) {
         super("w:hyperlink");
 
         this.linkId = relationshipId;
@@ -29,14 +27,16 @@ export class Hyperlink extends XmlComponent {
 
         const attributes = new HyperlinkAttributes(props);
         this.root.push(attributes);
-        this.textRun = new TextRun({
-            text: text,
-            style: "Hyperlink",
-        });
-        this.root.push(this.textRun);
-    }
-
-    public get TextRun(): TextRun {
-        return this.textRun;
+        this.root.push(child);
     }
 }
+
+export class InternalHyperlink extends ConcreteHyperlink {
+    constructor(options: { readonly child: ParagraphChild; readonly anchor: string }) {
+        super(options.child, shortid.generate().toLowerCase(), options.anchor);
+    }
+}
+
+export class ExternalHyperlink {
+    constructor(public readonly options: { readonly child: ParagraphChild; readonly link: string }) {}
+}

src/file/paragraph/math/brackets/index.ts

@@ -0,0 +1,4 @@
+export * from "./math-round-brackets";
+export * from "./math-square-brackets";
+export * from "./math-curly-brackets";
+export * from "./math-angled-brackets";

src/file/paragraph/math/brackets/math-angled-brackets.spec.ts

@@ -0,0 +1,51 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "../math-run";
+import { MathAngledBrackets } from "./math-angled-brackets";
+
+describe("MathAngledBrackets", () => {
+    describe("#constructor()", () => {
+        it("should create a MathAngledBrackets with correct root key", () => {
+            const mathAngledBrackets = new MathAngledBrackets({
+                children: [new MathRun("60")],
+            });
+
+            const tree = new Formatter().format(mathAngledBrackets);
+            expect(tree).to.deep.equal({
+                "m:d": [
+                    {
+                        "m:dPr": [
+                            {
+                                "m:begChr": {
+                                    _attr: {
+                                        "m:val": "〈",
+                                    },
+                                },
+                            },
+                            {
+                                "m:endChr": {
+                                    _attr: {
+                                        "m:val": "〉",
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        "m:e": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["60"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/brackets/math-angled-brackets.ts

@@ -0,0 +1,20 @@
+// http://www.datypic.com/sc/ooxml/e-m_d-1.html
+import { XmlComponent } from "file/xml-components";
+
+import { MathComponent } from "../math-component";
+import { MathBase } from "../n-ary";
+import { MathBracketProperties } from "./math-bracket-properties";
+
+export class MathAngledBrackets extends XmlComponent {
+    constructor(options: { readonly children: MathComponent[] }) {
+        super("m:d");
+
+        this.root.push(
+            new MathBracketProperties({
+                beginningCharacter: "〈",
+                endingCharacter: "〉",
+            }),
+        );
+        this.root.push(new MathBase(options.children));
+    }
+}

src/file/paragraph/math/brackets/math-beginning-character.spec.ts

@@ -0,0 +1,22 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathBeginningCharacter } from "./math-beginning-character";
+
+describe("MathBeginningCharacter", () => {
+    describe("#constructor()", () => {
+        it("should create a MathBeginningCharacter with correct root key", () => {
+            const mathBeginningCharacter = new MathBeginningCharacter("[");
+
+            const tree = new Formatter().format(mathBeginningCharacter);
+            expect(tree).to.deep.equal({
+                "m:begChr": {
+                    _attr: {
+                        "m:val": "[",
+                    },
+                },
+            });
+        });
+    });
+});

src/file/paragraph/math/brackets/math-beginning-character.ts

@@ -0,0 +1,14 @@
+// http://www.datypic.com/sc/ooxml/e-m_begChr-1.html
+import { XmlAttributeComponent, XmlComponent } from "file/xml-components";
+
+class MathBeginningCharacterAttributes extends XmlAttributeComponent<{ readonly character: string }> {
+    protected readonly xmlKeys = { character: "m:val" };
+}
+
+export class MathBeginningCharacter extends XmlComponent {
+    constructor(character: string) {
+        super("m:begChr");
+
+        this.root.push(new MathBeginningCharacterAttributes({ character }));
+    }
+}

src/file/paragraph/math/brackets/math-bracket-properties.spec.ts

@@ -0,0 +1,45 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathBracketProperties } from "./math-bracket-properties";
+
+describe("MathBracketProperties", () => {
+    describe("#constructor()", () => {
+        it("should create a MathBracketProperties with correct root key", () => {
+            const mathBracketProperties = new MathBracketProperties();
+
+            const tree = new Formatter().format(mathBracketProperties);
+            expect(tree).to.deep.equal({
+                "m:dPr": {},
+            });
+        });
+
+        it("should create a MathBracketProperties with correct root key and add brackets", () => {
+            const mathBracketProperties = new MathBracketProperties({
+                beginningCharacter: "[",
+                endingCharacter: "]",
+            });
+
+            const tree = new Formatter().format(mathBracketProperties);
+            expect(tree).to.deep.equal({
+                "m:dPr": [
+                    {
+                        "m:begChr": {
+                            _attr: {
+                                "m:val": "[",
+                            },
+                        },
+                    },
+                    {
+                        "m:endChr": {
+                            _attr: {
+                                "m:val": "]",
+                            },
+                        },
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/brackets/math-bracket-properties.ts

@@ -0,0 +1,16 @@
+// http://www.datypic.com/sc/ooxml/e-m_dPr-1.html
+import { XmlComponent } from "file/xml-components";
+
+import { MathBeginningCharacter } from "./math-beginning-character";
+import { MathEndingCharacter } from "./math-ending-char";
+
+export class MathBracketProperties extends XmlComponent {
+    constructor(options?: { readonly beginningCharacter: string; readonly endingCharacter: string }) {
+        super("m:dPr");
+
+        if (!!options) {
+            this.root.push(new MathBeginningCharacter(options.beginningCharacter));
+            this.root.push(new MathEndingCharacter(options.endingCharacter));
+        }
+    }
+}

src/file/paragraph/math/brackets/math-curly-brackets.spec.ts

@@ -0,0 +1,51 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "../math-run";
+import { MathCurlyBrackets } from "./math-curly-brackets";
+
+describe("MathCurlyBrackets", () => {
+    describe("#constructor()", () => {
+        it("should create a MathCurlyBrackets with correct root key", () => {
+            const mathCurlyBrackets = new MathCurlyBrackets({
+                children: [new MathRun("60")],
+            });
+
+            const tree = new Formatter().format(mathCurlyBrackets);
+            expect(tree).to.deep.equal({
+                "m:d": [
+                    {
+                        "m:dPr": [
+                            {
+                                "m:begChr": {
+                                    _attr: {
+                                        "m:val": "{",
+                                    },
+                                },
+                            },
+                            {
+                                "m:endChr": {
+                                    _attr: {
+                                        "m:val": "}",
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        "m:e": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["60"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/brackets/math-curly-brackets.ts

@@ -0,0 +1,20 @@
+// http://www.datypic.com/sc/ooxml/e-m_d-1.html
+import { XmlComponent } from "file/xml-components";
+
+import { MathComponent } from "../math-component";
+import { MathBase } from "../n-ary";
+import { MathBracketProperties } from "./math-bracket-properties";
+
+export class MathCurlyBrackets extends XmlComponent {
+    constructor(options: { readonly children: MathComponent[] }) {
+        super("m:d");
+
+        this.root.push(
+            new MathBracketProperties({
+                beginningCharacter: "{",
+                endingCharacter: "}",
+            }),
+        );
+        this.root.push(new MathBase(options.children));
+    }
+}

src/file/paragraph/math/brackets/math-ending-char.ts

@@ -0,0 +1,14 @@
+// http://www.datypic.com/sc/ooxml/e-m_endChr-1.html
+import { XmlAttributeComponent, XmlComponent } from "file/xml-components";
+
+class MathEndingCharacterAttributes extends XmlAttributeComponent<{ readonly character: string }> {
+    protected readonly xmlKeys = { character: "m:val" };
+}
+
+export class MathEndingCharacter extends XmlComponent {
+    constructor(character: string) {
+        super("m:endChr");
+
+        this.root.push(new MathEndingCharacterAttributes({ character }));
+    }
+}

src/file/paragraph/math/brackets/math-ending-character.spec.ts

@@ -0,0 +1,22 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathEndingCharacter } from "./math-ending-char";
+
+describe("MathEndingCharacter", () => {
+    describe("#constructor()", () => {
+        it("should create a MathEndingCharacter with correct root key", () => {
+            const mathEndingCharacter = new MathEndingCharacter("]");
+
+            const tree = new Formatter().format(mathEndingCharacter);
+            expect(tree).to.deep.equal({
+                "m:endChr": {
+                    _attr: {
+                        "m:val": "]",
+                    },
+                },
+            });
+        });
+    });
+});

src/file/paragraph/math/brackets/math-round-brackets.spec.ts

@@ -0,0 +1,36 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "../math-run";
+import { MathRoundBrackets } from "./math-round-brackets";
+
+describe("MathRoundBrackets", () => {
+    describe("#constructor()", () => {
+        it("should create a MathRoundBrackets with correct root key", () => {
+            const mathRoundBrackets = new MathRoundBrackets({
+                children: [new MathRun("60")],
+            });
+
+            const tree = new Formatter().format(mathRoundBrackets);
+            expect(tree).to.deep.equal({
+                "m:d": [
+                    {
+                        "m:dPr": {},
+                    },
+                    {
+                        "m:e": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["60"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/brackets/math-round-brackets.ts

@@ -0,0 +1,15 @@
+// http://www.datypic.com/sc/ooxml/e-m_d-1.html
+import { XmlComponent } from "file/xml-components";
+
+import { MathComponent } from "../math-component";
+import { MathBase } from "../n-ary";
+import { MathBracketProperties } from "./math-bracket-properties";
+
+export class MathRoundBrackets extends XmlComponent {
+    constructor(options: { readonly children: MathComponent[] }) {
+        super("m:d");
+
+        this.root.push(new MathBracketProperties());
+        this.root.push(new MathBase(options.children));
+    }
+}

src/file/paragraph/math/brackets/math-square-brackets.spec.ts

@@ -0,0 +1,51 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "../math-run";
+import { MathSquareBrackets } from "./math-square-brackets";
+
+describe("MathSquareBrackets", () => {
+    describe("#constructor()", () => {
+        it("should create a MathSquareBrackets with correct root key", () => {
+            const mathSquareBrackets = new MathSquareBrackets({
+                children: [new MathRun("60")],
+            });
+
+            const tree = new Formatter().format(mathSquareBrackets);
+            expect(tree).to.deep.equal({
+                "m:d": [
+                    {
+                        "m:dPr": [
+                            {
+                                "m:begChr": {
+                                    _attr: {
+                                        "m:val": "[",
+                                    },
+                                },
+                            },
+                            {
+                                "m:endChr": {
+                                    _attr: {
+                                        "m:val": "]",
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        "m:e": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["60"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/brackets/math-square-brackets.ts

@@ -0,0 +1,20 @@
+// http://www.datypic.com/sc/ooxml/e-m_d-1.html
+import { XmlComponent } from "file/xml-components";
+
+import { MathComponent } from "../math-component";
+import { MathBase } from "../n-ary";
+import { MathBracketProperties } from "./math-bracket-properties";
+
+export class MathSquareBrackets extends XmlComponent {
+    constructor(options: { readonly children: MathComponent[] }) {
+        super("m:d");
+
+        this.root.push(
+            new MathBracketProperties({
+                beginningCharacter: "[",
+                endingCharacter: "]",
+            }),
+        );
+        this.root.push(new MathBase(options.children));
+    }
+}

src/file/paragraph/math/fraction/index.ts

@@ -0,0 +1,3 @@
+export * from "./math-fraction";
+export * from "./math-denominator";
+export * from "./math-numerator";

src/file/paragraph/math/fraction/math-denominator.spec.ts

@@ -0,0 +1,26 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "../math-run";
+import { MathDenominator } from "./math-denominator";
+
+describe("MathDenominator", () => {
+    describe("#constructor()", () => {
+        it("should create a MathDenominator with correct root key", () => {
+            const mathDenominator = new MathDenominator([new MathRun("2+2")]);
+            const tree = new Formatter().format(mathDenominator);
+            expect(tree).to.deep.equal({
+                "m:den": [
+                    {
+                        "m:r": [
+                            {
+                                "m:t": ["2+2"],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/fraction/math-denominator.ts

@@ -0,0 +1,13 @@
+import { XmlComponent } from "file/xml-components";
+
+import { MathComponent } from "../math-component";
+
+export class MathDenominator extends XmlComponent {
+    constructor(children: MathComponent[]) {
+        super("m:den");
+
+        for (const child of children) {
+            this.root.push(child);
+        }
+    }
+}

src/file/paragraph/math/fraction/math-fraction.spec.ts

@@ -0,0 +1,44 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "../math-run";
+import { MathFraction } from "./math-fraction";
+
+describe("MathFraction", () => {
+    describe("#constructor()", () => {
+        it("should create a MathFraction with correct root key", () => {
+            const mathFraction = new MathFraction({
+                numerator: [new MathRun("2")],
+                denominator: [new MathRun("2")],
+            });
+            const tree = new Formatter().format(mathFraction);
+            expect(tree).to.deep.equal({
+                "m:f": [
+                    {
+                        "m:num": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["2"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        "m:den": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["2"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/fraction/math-fraction.ts

@@ -0,0 +1,19 @@
+import { XmlComponent } from "file/xml-components";
+
+import { MathComponent } from "../math-component";
+import { MathDenominator } from "./math-denominator";
+import { MathNumerator } from "./math-numerator";
+
+export interface IMathFractionOptions {
+    readonly numerator: MathComponent[];
+    readonly denominator: MathComponent[];
+}
+
+export class MathFraction extends XmlComponent {
+    constructor(options: IMathFractionOptions) {
+        super("m:f");
+
+        this.root.push(new MathNumerator(options.numerator));
+        this.root.push(new MathDenominator(options.denominator));
+    }
+}

src/file/paragraph/math/fraction/math-numerator.spec.ts

@@ -0,0 +1,26 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "../math-run";
+import { MathNumerator } from "./math-numerator";
+
+describe("MathNumerator", () => {
+    describe("#constructor()", () => {
+        it("should create a MathNumerator with correct root key", () => {
+            const mathNumerator = new MathNumerator([new MathRun("2+2")]);
+            const tree = new Formatter().format(mathNumerator);
+            expect(tree).to.deep.equal({
+                "m:num": [
+                    {
+                        "m:r": [
+                            {
+                                "m:t": ["2+2"],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/fraction/math-numerator.ts

@@ -0,0 +1,13 @@
+import { XmlComponent } from "file/xml-components";
+
+import { MathComponent } from "../math-component";
+
+export class MathNumerator extends XmlComponent {
+    constructor(children: MathComponent[]) {
+        super("m:num");
+
+        for (const child of children) {
+            this.root.push(child);
+        }
+    }
+}

src/file/paragraph/math/function/index.ts

@@ -0,0 +1,3 @@
+export * from "./math-function";
+export * from "./math-function-name";
+export * from "./math-function-properties";

src/file/paragraph/math/function/math-function-name.spec.ts

@@ -0,0 +1,27 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "../math-run";
+import { MathFunctionName } from "./math-function-name";
+
+describe("MathFunctionName", () => {
+    describe("#constructor()", () => {
+        it("should create a MathFunctionName with correct root key", () => {
+            const mathFunctionName = new MathFunctionName([new MathRun("2")]);
+
+            const tree = new Formatter().format(mathFunctionName);
+            expect(tree).to.deep.equal({
+                "m:fName": [
+                    {
+                        "m:r": [
+                            {
+                                "m:t": ["2"],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/function/math-function-name.ts

@@ -0,0 +1,13 @@
+// http://www.datypic.com/sc/ooxml/e-m_fName-1.html
+import { XmlComponent } from "file/xml-components";
+import { MathComponent } from "../math-component";
+
+export class MathFunctionName extends XmlComponent {
+    constructor(children: MathComponent[]) {
+        super("m:fName");
+
+        for (const child of children) {
+            this.root.push(child);
+        }
+    }
+}

src/file/paragraph/math/function/math-function-properties.spec.ts

@@ -0,0 +1,18 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathFunctionProperties } from "./math-function-properties";
+
+describe("MathFunctionProperties", () => {
+    describe("#constructor()", () => {
+        it("should create a MathFunctionProperties with correct root key", () => {
+            const mathFunctionProperties = new MathFunctionProperties();
+
+            const tree = new Formatter().format(mathFunctionProperties);
+            expect(tree).to.deep.equal({
+                "m:funcPr": {},
+            });
+        });
+    });
+});

src/file/paragraph/math/function/math-function-properties.ts

@@ -0,0 +1,8 @@
+// http://www.datypic.com/sc/ooxml/e-m_radPr-1.html
+import { XmlComponent } from "file/xml-components";
+
+export class MathFunctionProperties extends XmlComponent {
+    constructor() {
+        super("m:funcPr");
+    }
+}

src/file/paragraph/math/function/math-function.spec.ts

@@ -0,0 +1,48 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "../math-run";
+import { MathFunction } from "./math-function";
+
+describe("MathFunction", () => {
+    describe("#constructor()", () => {
+        it("should create a MathFunction with correct root key", () => {
+            const mathFunction = new MathFunction({
+                name: [new MathRun("sin")],
+                children: [new MathRun("60")],
+            });
+
+            const tree = new Formatter().format(mathFunction);
+            expect(tree).to.deep.equal({
+                "m:func": [
+                    {
+                        "m:funcPr": {},
+                    },
+                    {
+                        "m:fName": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["sin"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        "m:e": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["60"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/function/math-function.ts

@@ -0,0 +1,22 @@
+// http://www.datypic.com/sc/ooxml/e-m_func-1.html
+import { XmlComponent } from "file/xml-components";
+
+import { MathComponent } from "../math-component";
+import { MathBase } from "../n-ary";
+import { MathFunctionName } from "./math-function-name";
+import { MathFunctionProperties } from "./math-function-properties";
+
+export interface IMathFunctionOptions {
+    readonly children: MathComponent[];
+    readonly name: MathComponent[];
+}
+
+export class MathFunction extends XmlComponent {
+    constructor(options: IMathFunctionOptions) {
+        super("m:func");
+
+        this.root.push(new MathFunctionProperties());
+        this.root.push(new MathFunctionName(options.name));
+        this.root.push(new MathBase(options.children));
+    }
+}

src/file/paragraph/math/index.ts

@@ -0,0 +1,9 @@
+export * from "./math";
+export * from "./math-run";
+export * from "./fraction";
+export * from "./n-ary";
+export * from "./script";
+export * from "./math-component";
+export * from "./radical";
+export * from "./function";
+export * from "./brackets";

src/file/paragraph/math/math-component.ts

@@ -0,0 +1,27 @@
+import { MathAngledBrackets, MathCurlyBrackets, MathRoundBrackets, MathSquareBrackets } from "./brackets";
+import { MathFraction } from "./fraction";
+import { MathFunction } from "./function";
+import { MathRun } from "./math-run";
+import { MathSum } from "./n-ary";
+import { MathRadical } from "./radical";
+import { MathSubScript, MathSubSuperScript, MathSuperScript } from "./script";
+
+export type MathComponent =
+    | MathRun
+    | MathFraction
+    | MathSum
+    | MathSuperScript
+    | MathSubScript
+    | MathSubSuperScript
+    | MathRadical
+    | MathFunction
+    | MathRoundBrackets
+    | MathCurlyBrackets
+    | MathAngledBrackets
+    | MathSquareBrackets;
+
+// Needed because of: https://github.com/s-panferov/awesome-typescript-loader/issues/432
+/**
+ * @ignore
+ */
+export const WORKAROUND4 = "";

src/file/paragraph/math/math-run.spec.ts

@@ -0,0 +1,21 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "./math-run";
+
+describe("MathRun", () => {
+    describe("#constructor()", () => {
+        it("should create a MathRun with correct root key", () => {
+            const mathRun = new MathRun("2+2");
+            const tree = new Formatter().format(mathRun);
+            expect(tree).to.deep.equal({
+                "m:r": [
+                    {
+                        "m:t": ["2+2"],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/math-run.ts

@@ -0,0 +1,12 @@
+// http://www.datypic.com/sc/ooxml/e-m_r-1.html
+import { XmlComponent } from "file/xml-components";
+
+import { MathText } from "./math-text";
+
+export class MathRun extends XmlComponent {
+    constructor(text: string) {
+        super("m:r");
+
+        this.root.push(new MathText(text));
+    }
+}

src/file/paragraph/math/math-text.spec.ts

@@ -0,0 +1,17 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathText } from "./math-text";
+
+describe("MathText", () => {
+    describe("#constructor()", () => {
+        it("should create a MathText with correct root key", () => {
+            const mathText = new MathText("2+2");
+            const tree = new Formatter().format(mathText);
+            expect(tree).to.deep.equal({
+                "m:t": ["2+2"],
+            });
+        });
+    });
+});

src/file/paragraph/math/math-text.ts

@@ -0,0 +1,9 @@
+import { XmlComponent } from "file/xml-components";
+
+export class MathText extends XmlComponent {
+    constructor(text: string) {
+        super("m:t");
+
+        this.root.push(text);
+    }
+}

src/file/paragraph/math/math.spec.ts

@@ -0,0 +1,38 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { Math } from "./math";
+import { MathRun } from "./math-run";
+
+describe("Math", () => {
+    describe("#constructor()", () => {
+        it("should create a Math with correct root key", () => {
+            const math = new Math({
+                children: [],
+            });
+            const tree = new Formatter().format(math);
+            expect(tree).to.deep.equal({
+                "m:oMath": {},
+            });
+        });
+
+        it("should be able to add children", () => {
+            const math = new Math({
+                children: [new MathRun("2+2")],
+            });
+            const tree = new Formatter().format(math);
+            expect(tree).to.deep.equal({
+                "m:oMath": [
+                    {
+                        "m:r": [
+                            {
+                                "m:t": ["2+2"],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/math.ts

@@ -0,0 +1,18 @@
+// http://www.datypic.com/sc/ooxml/e-m_oMath-1.html
+import { XmlComponent } from "file/xml-components";
+
+import { MathComponent } from "./math-component";
+
+export interface IMathOptions {
+    readonly children: MathComponent[];
+}
+
+export class Math extends XmlComponent {
+    constructor(options: IMathOptions) {
+        super("m:oMath");
+
+        for (const child of options.children) {
+            this.root.push(child);
+        }
+    }
+}

src/file/paragraph/math/n-ary/index.ts

@@ -0,0 +1,7 @@
+export * from "./math-accent-character";
+export * from "./math-base";
+export * from "./math-limit-location";
+export * from "./math-naray-properties";
+export * from "./math-sub-script";
+export * from "./math-sum";
+export * from "./math-super-script";

src/file/paragraph/math/n-ary/math-accent-character.spec.ts

@@ -0,0 +1,22 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathAccentCharacter } from "./math-accent-character";
+
+describe("MathAccentCharacter", () => {
+    describe("#constructor()", () => {
+        it("should create a MathAccentCharacter with correct root key", () => {
+            const mathAccentCharacter = new MathAccentCharacter("∑");
+
+            const tree = new Formatter().format(mathAccentCharacter);
+            expect(tree).to.deep.equal({
+                "m:chr": {
+                    _attr: {
+                        "m:val": "∑",
+                    },
+                },
+            });
+        });
+    });
+});

src/file/paragraph/math/n-ary/math-accent-character.ts

@@ -0,0 +1,14 @@
+// http://www.datypic.com/sc/ooxml/e-m_chr-1.html
+import { XmlAttributeComponent, XmlComponent } from "file/xml-components";
+
+class MathAccentCharacterAttributes extends XmlAttributeComponent<{ readonly accent: string }> {
+    protected readonly xmlKeys = { accent: "m:val" };
+}
+
+export class MathAccentCharacter extends XmlComponent {
+    constructor(accent: string) {
+        super("m:chr");
+
+        this.root.push(new MathAccentCharacterAttributes({ accent }));
+    }
+}

src/file/paragraph/math/n-ary/math-base.spec.ts

@@ -0,0 +1,27 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "../math-run";
+import { MathBase } from "./math-base";
+
+describe("MathBase", () => {
+    describe("#constructor()", () => {
+        it("should create a MathBase with correct root key", () => {
+            const mathBase = new MathBase([new MathRun("2+2")]);
+
+            const tree = new Formatter().format(mathBase);
+            expect(tree).to.deep.equal({
+                "m:e": [
+                    {
+                        "m:r": [
+                            {
+                                "m:t": ["2+2"],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/n-ary/math-base.ts

@@ -0,0 +1,14 @@
+// http://www.datypic.com/sc/ooxml/e-m_e-1.html
+import { XmlComponent } from "file/xml-components";
+
+import { MathComponent } from "../math-component";
+
+export class MathBase extends XmlComponent {
+    constructor(children: MathComponent[]) {
+        super("m:e");
+
+        for (const child of children) {
+            this.root.push(child);
+        }
+    }
+}

src/file/paragraph/math/n-ary/math-limit-location.spec.ts

@@ -0,0 +1,22 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathLimitLocation } from "./math-limit-location";
+
+describe("MathLimitLocation", () => {
+    describe("#constructor()", () => {
+        it("should create a MathLimitLocation with correct root key", () => {
+            const mathLimitLocation = new MathLimitLocation();
+
+            const tree = new Formatter().format(mathLimitLocation);
+            expect(tree).to.deep.equal({
+                "m:limLoc": {
+                    _attr: {
+                        "m:val": "undOvr",
+                    },
+                },
+            });
+        });
+    });
+});

src/file/paragraph/math/n-ary/math-limit-location.ts

@@ -0,0 +1,14 @@
+// http://www.datypic.com/sc/ooxml/e-m_limLoc-1.html
+import { XmlAttributeComponent, XmlComponent } from "file/xml-components";
+
+class MathLimitLocationAttributes extends XmlAttributeComponent<{ readonly value: string }> {
+    protected readonly xmlKeys = { value: "m:val" };
+}
+
+export class MathLimitLocation extends XmlComponent {
+    constructor() {
+        super("m:limLoc");
+
+        this.root.push(new MathLimitLocationAttributes({ value: "undOvr" }));
+    }
+}

src/file/paragraph/math/n-ary/math-naray-properties.spec.ts

@@ -0,0 +1,133 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathNArayProperties } from "./math-naray-properties";
+
+describe("MathNArayProperties", () => {
+    describe("#constructor()", () => {
+        it("should create a MathNArayProperties with correct root key", () => {
+            const mathNArayProperties = new MathNArayProperties("∑", true, true);
+
+            const tree = new Formatter().format(mathNArayProperties);
+            expect(tree).to.deep.equal({
+                "m:naryPr": [
+                    {
+                        "m:chr": {
+                            _attr: {
+                                "m:val": "∑",
+                            },
+                        },
+                    },
+                    {
+                        "m:limLoc": {
+                            _attr: {
+                                "m:val": "undOvr",
+                            },
+                        },
+                    },
+                ],
+            });
+        });
+
+        it("should add super-script hide attributes", () => {
+            const mathNArayProperties = new MathNArayProperties("∑", false, true);
+
+            const tree = new Formatter().format(mathNArayProperties);
+            expect(tree).to.deep.equal({
+                "m:naryPr": [
+                    {
+                        "m:chr": {
+                            _attr: {
+                                "m:val": "∑",
+                            },
+                        },
+                    },
+                    {
+                        "m:limLoc": {
+                            _attr: {
+                                "m:val": "undOvr",
+                            },
+                        },
+                    },
+                    {
+                        "m:supHide": {
+                            _attr: {
+                                "m:val": 1,
+                            },
+                        },
+                    },
+                ],
+            });
+        });
+
+        it("should add sub-script hide attributes", () => {
+            const mathNArayProperties = new MathNArayProperties("∑", true, false);
+
+            const tree = new Formatter().format(mathNArayProperties);
+            expect(tree).to.deep.equal({
+                "m:naryPr": [
+                    {
+                        "m:chr": {
+                            _attr: {
+                                "m:val": "∑",
+                            },
+                        },
+                    },
+                    {
+                        "m:limLoc": {
+                            _attr: {
+                                "m:val": "undOvr",
+                            },
+                        },
+                    },
+                    {
+                        "m:subHide": {
+                            _attr: {
+                                "m:val": 1,
+                            },
+                        },
+                    },
+                ],
+            });
+        });
+
+        it("should add both super-script and sub-script hide attributes", () => {
+            const mathNArayProperties = new MathNArayProperties("∑", false, false);
+
+            const tree = new Formatter().format(mathNArayProperties);
+            expect(tree).to.deep.equal({
+                "m:naryPr": [
+                    {
+                        "m:chr": {
+                            _attr: {
+                                "m:val": "∑",
+                            },
+                        },
+                    },
+                    {
+                        "m:limLoc": {
+                            _attr: {
+                                "m:val": "undOvr",
+                            },
+                        },
+                    },
+                    {
+                        "m:supHide": {
+                            _attr: {
+                                "m:val": 1,
+                            },
+                        },
+                    },
+                    {
+                        "m:subHide": {
+                            _attr: {
+                                "m:val": 1,
+                            },
+                        },
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/n-ary/math-naray-properties.ts

@@ -0,0 +1,24 @@
+// http://www.datypic.com/sc/ooxml/e-m_naryPr-1.html
+import { XmlComponent } from "file/xml-components";
+
+import { MathAccentCharacter } from "./math-accent-character";
+import { MathLimitLocation } from "./math-limit-location";
+import { MathSubScriptHide } from "./math-sub-script-hide";
+import { MathSuperScriptHide } from "./math-super-script-hide";
+
+export class MathNArayProperties extends XmlComponent {
+    constructor(accent: string, hasSuperScript: boolean, hasSubScript: boolean) {
+        super("m:naryPr");
+
+        this.root.push(new MathAccentCharacter(accent));
+        this.root.push(new MathLimitLocation());
+
+        if (!hasSuperScript) {
+            this.root.push(new MathSuperScriptHide());
+        }
+
+        if (!hasSubScript) {
+            this.root.push(new MathSubScriptHide());
+        }
+    }
+}

src/file/paragraph/math/n-ary/math-sub-script-hide.spec.ts

@@ -0,0 +1,22 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathSubScriptHide } from "./math-sub-script-hide";
+
+describe("MathSubScriptHide", () => {
+    describe("#constructor()", () => {
+        it("should create a MathSubScriptHide with correct root key", () => {
+            const mathSubScriptHide = new MathSubScriptHide();
+
+            const tree = new Formatter().format(mathSubScriptHide);
+            expect(tree).to.deep.equal({
+                "m:subHide": {
+                    _attr: {
+                        "m:val": 1,
+                    },
+                },
+            });
+        });
+    });
+});

src/file/paragraph/math/n-ary/math-sub-script-hide.ts

@@ -0,0 +1,14 @@
+// http://www.datypic.com/sc/ooxml/e-m_subHide-1.html
+import { XmlAttributeComponent, XmlComponent } from "file/xml-components";
+
+class MathSubScriptHideAttributes extends XmlAttributeComponent<{ readonly hide: number }> {
+    protected readonly xmlKeys = { hide: "m:val" };
+}
+
+export class MathSubScriptHide extends XmlComponent {
+    constructor() {
+        super("m:subHide");
+
+        this.root.push(new MathSubScriptHideAttributes({ hide: 1 }));
+    }
+}

src/file/paragraph/math/n-ary/math-sub-script.spec.ts

@@ -0,0 +1,27 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "../math-run";
+import { MathSubScriptElement } from "./math-sub-script";
+
+describe("MathSubScriptElement", () => {
+    describe("#constructor()", () => {
+        it("should create a MathSubScriptElement with correct root key", () => {
+            const mathSubScriptElement = new MathSubScriptElement([new MathRun("2+2")]);
+
+            const tree = new Formatter().format(mathSubScriptElement);
+            expect(tree).to.deep.equal({
+                "m:sub": [
+                    {
+                        "m:r": [
+                            {
+                                "m:t": ["2+2"],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/n-ary/math-sub-script.ts

@@ -0,0 +1,14 @@
+// http://www.datypic.com/sc/ooxml/e-m_sub-3.html
+import { XmlComponent } from "file/xml-components";
+
+import { MathComponent } from "../math-component";
+
+export class MathSubScriptElement extends XmlComponent {
+    constructor(children: MathComponent[]) {
+        super("m:sub");
+
+        for (const child of children) {
+            this.root.push(child);
+        }
+    }
+}

src/file/paragraph/math/n-ary/math-sum.spec.ts

@@ -0,0 +1,130 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "../math-run";
+import { MathSum } from "./math-sum";
+
+describe("MathSum", () => {
+    describe("#constructor()", () => {
+        it("should create a MathSum with correct root key", () => {
+            const mathSum = new MathSum({
+                children: [new MathRun("1")],
+                subScript: [new MathRun("2")],
+                superScript: [new MathRun("3")],
+            });
+
+            const tree = new Formatter().format(mathSum);
+            expect(tree).to.deep.equal({
+                "m:nary": [
+                    {
+                        "m:naryPr": [
+                            {
+                                "m:chr": {
+                                    _attr: {
+                                        "m:val": "∑",
+                                    },
+                                },
+                            },
+                            {
+                                "m:limLoc": {
+                                    _attr: {
+                                        "m:val": "undOvr",
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        "m:sub": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["2"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        "m:sup": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["3"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        "m:e": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["1"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+
+        it("should add a hide when there is no subScript or superScript", () => {
+            const mathSum = new MathSum({
+                children: [new MathRun("1")],
+            });
+
+            const tree = new Formatter().format(mathSum);
+            expect(tree).to.deep.equal({
+                "m:nary": [
+                    {
+                        "m:naryPr": [
+                            {
+                                "m:chr": {
+                                    _attr: {
+                                        "m:val": "∑",
+                                    },
+                                },
+                            },
+                            {
+                                "m:limLoc": {
+                                    _attr: {
+                                        "m:val": "undOvr",
+                                    },
+                                },
+                            },
+                            {
+                                "m:supHide": {
+                                    _attr: {
+                                        "m:val": 1,
+                                    },
+                                },
+                            },
+                            {
+                                "m:subHide": {
+                                    _attr: {
+                                        "m:val": 1,
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        "m:e": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["1"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/n-ary/math-sum.ts

@@ -0,0 +1,32 @@
+// http://www.datypic.com/sc/ooxml/e-m_nary-1.html
+import { XmlComponent } from "file/xml-components";
+
+import { MathComponent } from "../math-component";
+import { MathBase } from "./math-base";
+import { MathNArayProperties } from "./math-naray-properties";
+import { MathSubScriptElement } from "./math-sub-script";
+import { MathSuperScriptElement } from "./math-super-script";
+
+export interface IMathSumOptions {
+    readonly children: MathComponent[];
+    readonly subScript?: MathComponent[];
+    readonly superScript?: MathComponent[];
+}
+
+export class MathSum extends XmlComponent {
+    constructor(options: IMathSumOptions) {
+        super("m:nary");
+
+        this.root.push(new MathNArayProperties("∑", !!options.superScript, !!options.subScript));
+
+        if (!!options.subScript) {
+            this.root.push(new MathSubScriptElement(options.subScript));
+        }
+
+        if (!!options.superScript) {
+            this.root.push(new MathSuperScriptElement(options.superScript));
+        }
+
+        this.root.push(new MathBase(options.children));
+    }
+}

src/file/paragraph/math/n-ary/math-super-script-hide.spec.ts

@@ -0,0 +1,22 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathSuperScriptHide } from "./math-super-script-hide";
+
+describe("MathSuperScriptHide", () => {
+    describe("#constructor()", () => {
+        it("should create a MathSuperScriptHide with correct root key", () => {
+            const mathSuperScriptHide = new MathSuperScriptHide();
+
+            const tree = new Formatter().format(mathSuperScriptHide);
+            expect(tree).to.deep.equal({
+                "m:supHide": {
+                    _attr: {
+                        "m:val": 1,
+                    },
+                },
+            });
+        });
+    });
+});

src/file/paragraph/math/n-ary/math-super-script-hide.ts

@@ -0,0 +1,14 @@
+// http://www.datypic.com/sc/ooxml/e-m_subHide-1.html
+import { XmlAttributeComponent, XmlComponent } from "file/xml-components";
+
+class MathSuperScriptHideAttributes extends XmlAttributeComponent<{ readonly hide: number }> {
+    protected readonly xmlKeys = { hide: "m:val" };
+}
+
+export class MathSuperScriptHide extends XmlComponent {
+    constructor() {
+        super("m:supHide");
+
+        this.root.push(new MathSuperScriptHideAttributes({ hide: 1 }));
+    }
+}

src/file/paragraph/math/n-ary/math-super-script.spec.ts

@@ -0,0 +1,27 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "../math-run";
+import { MathSuperScriptElement } from "./math-super-script";
+
+describe("MathSuperScriptElement", () => {
+    describe("#constructor()", () => {
+        it("should create a MathSuperScriptElement with correct root key", () => {
+            const mathSuperScriptElement = new MathSuperScriptElement([new MathRun("2+2")]);
+
+            const tree = new Formatter().format(mathSuperScriptElement);
+            expect(tree).to.deep.equal({
+                "m:sup": [
+                    {
+                        "m:r": [
+                            {
+                                "m:t": ["2+2"],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/n-ary/math-super-script.ts

@@ -0,0 +1,14 @@
+// http://www.datypic.com/sc/ooxml/e-m_sup-3.html
+import { XmlComponent } from "file/xml-components";
+
+import { MathComponent } from "../math-component";
+
+export class MathSuperScriptElement extends XmlComponent {
+    constructor(children: MathComponent[]) {
+        super("m:sup");
+
+        for (const child of children) {
+            this.root.push(child);
+        }
+    }
+}

src/file/paragraph/math/radical/index.ts

@@ -0,0 +1,3 @@
+export * from "./math-degree";
+export * from "./math-radical";
+export * from "./math-radical-properties";

src/file/paragraph/math/radical/math-degree-hide.spec.ts

@@ -0,0 +1,22 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathDegreeHide } from "./math-degree-hide";
+
+describe("MathDegreeHide", () => {
+    describe("#constructor()", () => {
+        it("should create a MathDegreeHide with correct root key", () => {
+            const mathDegreeHide = new MathDegreeHide();
+
+            const tree = new Formatter().format(mathDegreeHide);
+            expect(tree).to.deep.equal({
+                "m:degHide": {
+                    _attr: {
+                        "m:val": 1,
+                    },
+                },
+            });
+        });
+    });
+});

src/file/paragraph/math/radical/math-degree-hide.ts

@@ -0,0 +1,14 @@
+// http://www.datypic.com/sc/ooxml/e-m_degHide-1.html
+import { XmlAttributeComponent, XmlComponent } from "file/xml-components";
+
+class MathDegreeHideAttributes extends XmlAttributeComponent<{ readonly hide: number }> {
+    protected readonly xmlKeys = { hide: "m:val" };
+}
+
+export class MathDegreeHide extends XmlComponent {
+    constructor() {
+        super("m:degHide");
+
+        this.root.push(new MathDegreeHideAttributes({ hide: 1 }));
+    }
+}

src/file/paragraph/math/radical/math-degree.spec.ts

@@ -0,0 +1,36 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "../math-run";
+import { MathDegree } from "./math-degree";
+
+describe("MathDegree", () => {
+    describe("#constructor()", () => {
+        it("should create a MathDegree with correct root key", () => {
+            const mathDegree = new MathDegree();
+
+            const tree = new Formatter().format(mathDegree);
+            expect(tree).to.deep.equal({
+                "m:deg": {},
+            });
+        });
+
+        it("should create a MathDegree with correct root key with child", () => {
+            const mathDegree = new MathDegree([new MathRun("2")]);
+
+            const tree = new Formatter().format(mathDegree);
+            expect(tree).to.deep.equal({
+                "m:deg": [
+                    {
+                        "m:r": [
+                            {
+                                "m:t": ["2"],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/radical/math-degree.ts

@@ -0,0 +1,15 @@
+// http://www.datypic.com/sc/ooxml/e-m_deg-1.html
+import { XmlComponent } from "file/xml-components";
+import { MathComponent } from "../math-component";
+
+export class MathDegree extends XmlComponent {
+    constructor(children?: MathComponent[]) {
+        super("m:deg");
+
+        if (!!children) {
+            for (const child of children) {
+                this.root.push(child);
+            }
+        }
+    }
+}

src/file/paragraph/math/radical/math-radical-properties.spec.ts

@@ -0,0 +1,35 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRadicalProperties } from "./math-radical-properties";
+
+describe("MathRadicalProperties", () => {
+    describe("#constructor()", () => {
+        it("should create a MathRadicalProperties with correct root key", () => {
+            const mathRadicalProperties = new MathRadicalProperties(true);
+
+            const tree = new Formatter().format(mathRadicalProperties);
+            expect(tree).to.deep.equal({
+                "m:radPr": {},
+            });
+        });
+
+        it("should create a MathRadicalProperties with correct root key with degree hide", () => {
+            const mathRadicalProperties = new MathRadicalProperties(false);
+
+            const tree = new Formatter().format(mathRadicalProperties);
+            expect(tree).to.deep.equal({
+                "m:radPr": [
+                    {
+                        "m:degHide": {
+                            _attr: {
+                                "m:val": 1,
+                            },
+                        },
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/radical/math-radical-properties.ts

@@ -0,0 +1,13 @@
+// http://www.datypic.com/sc/ooxml/e-m_radPr-1.html
+import { XmlComponent } from "file/xml-components";
+import { MathDegreeHide } from "./math-degree-hide";
+
+export class MathRadicalProperties extends XmlComponent {
+    constructor(hasDegree: boolean) {
+        super("m:radPr");
+
+        if (!hasDegree) {
+            this.root.push(new MathDegreeHide());
+        }
+    }
+}

src/file/paragraph/math/radical/math-radical.spec.ts

@@ -0,0 +1,48 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "../math-run";
+import { MathRadical } from "./math-radical";
+
+describe("MathRadical", () => {
+    describe("#constructor()", () => {
+        it("should create a MathRadical with correct root key", () => {
+            const mathRadical = new MathRadical({
+                children: [new MathRun("e")],
+                degree: [new MathRun("2")],
+            });
+
+            const tree = new Formatter().format(mathRadical);
+            expect(tree).to.deep.equal({
+                "m:rad": [
+                    {
+                        "m:radPr": {},
+                    },
+                    {
+                        "m:deg": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["2"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        "m:e": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["e"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/radical/math-radical.ts

@@ -0,0 +1,22 @@
+// http://www.datypic.com/sc/ooxml/e-m_rad-1.html
+import { XmlComponent } from "file/xml-components";
+
+import { MathComponent } from "../math-component";
+import { MathBase } from "../n-ary";
+import { MathDegree } from "./math-degree";
+import { MathRadicalProperties } from "./math-radical-properties";
+
+export interface IMathRadicalOptions {
+    readonly children: MathComponent[];
+    readonly degree?: MathComponent[];
+}
+
+export class MathRadical extends XmlComponent {
+    constructor(options: IMathRadicalOptions) {
+        super("m:rad");
+
+        this.root.push(new MathRadicalProperties(!!options.degree));
+        this.root.push(new MathDegree(options.degree));
+        this.root.push(new MathBase(options.children));
+    }
+}

src/file/paragraph/math/script/index.ts

@@ -0,0 +1,4 @@
+export * from "./super-script";
+export * from "./sub-script";
+export * from "./sub-super-script";
+export * from "./pre-sub-super-script";

src/file/paragraph/math/script/pre-sub-super-script/index.ts

@@ -0,0 +1,2 @@
+export * from "./math-pre-sub-super-script-function";
+export * from "./math-pre-sub-super-script-function-properties";

src/file/paragraph/math/script/pre-sub-super-script/math-pre-sub-super-script-function-properties.spec.ts

@@ -0,0 +1,17 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+import { MathPreSubSuperScriptProperties } from "./math-pre-sub-super-script-function-properties";
+
+describe("MathPreSubSuperScriptProperties", () => {
+    describe("#constructor()", () => {
+        it("should create a MathPreSubSuperScriptProperties with correct root key", () => {
+            const mathPreSubSuperScriptProperties = new MathPreSubSuperScriptProperties();
+
+            const tree = new Formatter().format(mathPreSubSuperScriptProperties);
+            expect(tree).to.deep.equal({
+                "m:sPrePr": {},
+            });
+        });
+    });
+});

src/file/paragraph/math/script/pre-sub-super-script/math-pre-sub-super-script-function-properties.ts

@@ -0,0 +1,8 @@
+// http://www.datypic.com/sc/ooxml/e-m_sPrePr-1.html
+import { XmlComponent } from "file/xml-components";
+
+export class MathPreSubSuperScriptProperties extends XmlComponent {
+    constructor() {
+        super("m:sPrePr");
+    }
+}

src/file/paragraph/math/script/pre-sub-super-script/math-pre-sub-super-script-function.spec.ts

@@ -0,0 +1,60 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "../../math-run";
+import { MathPreSubSuperScript } from "./math-pre-sub-super-script-function";
+
+describe("MathPreSubScript", () => {
+    describe("#constructor()", () => {
+        it("should create a MathPreSubScript with correct root key", () => {
+            const mathPreSubScript = new MathPreSubSuperScript({
+                children: [new MathRun("e")],
+                subScript: [new MathRun("2")],
+                superScript: [new MathRun("5")],
+            });
+
+            const tree = new Formatter().format(mathPreSubScript);
+            expect(tree).to.deep.equal({
+                "m:sPre": [
+                    {
+                        "m:sPrePr": {},
+                    },
+                    {
+                        "m:e": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["e"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        "m:sub": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["2"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        "m:sup": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["5"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/script/pre-sub-super-script/math-pre-sub-super-script-function.ts

@@ -0,0 +1,23 @@
+// http://www.datypic.com/sc/ooxml/e-m_sPre-1.html
+import { XmlComponent } from "file/xml-components";
+
+import { MathComponent } from "../../math-component";
+import { MathBase, MathSubScriptElement, MathSuperScriptElement } from "../../n-ary";
+import { MathPreSubSuperScriptProperties } from "./math-pre-sub-super-script-function-properties";
+
+export interface IMathPreSubSuperScriptOptions {
+    readonly children: MathComponent[];
+    readonly subScript: MathComponent[];
+    readonly superScript: MathComponent[];
+}
+
+export class MathPreSubSuperScript extends XmlComponent {
+    constructor(options: IMathPreSubSuperScriptOptions) {
+        super("m:sPre");
+
+        this.root.push(new MathPreSubSuperScriptProperties());
+        this.root.push(new MathBase(options.children));
+        this.root.push(new MathSubScriptElement(options.subScript));
+        this.root.push(new MathSuperScriptElement(options.superScript));
+    }
+}

src/file/paragraph/math/script/sub-script/index.ts

@@ -0,0 +1,2 @@
+export * from "./math-sub-script-function";
+export * from "./math-sub-script-function-properties";

src/file/paragraph/math/script/sub-script/math-sub-script-function-properties.spec.ts

@@ -0,0 +1,17 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+import { MathSubScriptProperties } from "./math-sub-script-function-properties";
+
+describe("MathSubScriptProperties", () => {
+    describe("#constructor()", () => {
+        it("should create a MathSubScriptProperties with correct root key", () => {
+            const mathSubScriptProperties = new MathSubScriptProperties();
+
+            const tree = new Formatter().format(mathSubScriptProperties);
+            expect(tree).to.deep.equal({
+                "m:sSubPr": {},
+            });
+        });
+    });
+});

src/file/paragraph/math/script/sub-script/math-sub-script-function-properties.ts

@@ -0,0 +1,8 @@
+// http://www.datypic.com/sc/ooxml/e-m_sSubPr-1.html
+import { XmlComponent } from "file/xml-components";
+
+export class MathSubScriptProperties extends XmlComponent {
+    constructor() {
+        super("m:sSubPr");
+    }
+}

src/file/paragraph/math/script/sub-script/math-sub-script-function.spec.ts

@@ -0,0 +1,48 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "../../math-run";
+import { MathSubScript } from "./math-sub-script-function";
+
+describe("MathSubScript", () => {
+    describe("#constructor()", () => {
+        it("should create a MathSubScript with correct root key", () => {
+            const mathSubScript = new MathSubScript({
+                children: [new MathRun("e")],
+                subScript: [new MathRun("2")],
+            });
+
+            const tree = new Formatter().format(mathSubScript);
+            expect(tree).to.deep.equal({
+                "m:sSub": [
+                    {
+                        "m:sSubPr": {},
+                    },
+                    {
+                        "m:e": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["e"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        "m:sub": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["2"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/script/sub-script/math-sub-script-function.ts

@@ -0,0 +1,21 @@
+// http://www.datypic.com/sc/ooxml/e-m_sSub-1.html
+import { XmlComponent } from "file/xml-components";
+
+import { MathComponent } from "../../math-component";
+import { MathBase, MathSubScriptElement } from "../../n-ary";
+import { MathSubScriptProperties } from "./math-sub-script-function-properties";
+
+export interface IMathSubScriptOptions {
+    readonly children: MathComponent[];
+    readonly subScript: MathComponent[];
+}
+
+export class MathSubScript extends XmlComponent {
+    constructor(options: IMathSubScriptOptions) {
+        super("m:sSub");
+
+        this.root.push(new MathSubScriptProperties());
+        this.root.push(new MathBase(options.children));
+        this.root.push(new MathSubScriptElement(options.subScript));
+    }
+}

src/file/paragraph/math/script/sub-super-script/index.ts

@@ -0,0 +1,2 @@
+export * from "./math-sub-super-script-function";
+export * from "./math-sub-super-script-function-properties";

src/file/paragraph/math/script/sub-super-script/math-sub-super-script-function-properties.spec.ts

@@ -0,0 +1,17 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+import { MathSubSuperScriptProperties } from "./math-sub-super-script-function-properties";
+
+describe("MathSubSuperScriptProperties", () => {
+    describe("#constructor()", () => {
+        it("should create a MathSubSuperScriptProperties with correct root key", () => {
+            const mathSubSuperScriptProperties = new MathSubSuperScriptProperties();
+
+            const tree = new Formatter().format(mathSubSuperScriptProperties);
+            expect(tree).to.deep.equal({
+                "m:sSubSupPr": {},
+            });
+        });
+    });
+});

src/file/paragraph/math/script/sub-super-script/math-sub-super-script-function-properties.ts

@@ -0,0 +1,8 @@
+// http://www.datypic.com/sc/ooxml/e-m_sSubSupPr-1.html
+import { XmlComponent } from "file/xml-components";
+
+export class MathSubSuperScriptProperties extends XmlComponent {
+    constructor() {
+        super("m:sSubSupPr");
+    }
+}

src/file/paragraph/math/script/sub-super-script/math-sub-super-script-function.spec.ts

@@ -0,0 +1,60 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "../../math-run";
+import { MathSubSuperScript } from "./math-sub-super-script-function";
+
+describe("MathSubScript", () => {
+    describe("#constructor()", () => {
+        it("should create a MathSubScript with correct root key", () => {
+            const mathSubScript = new MathSubSuperScript({
+                children: [new MathRun("e")],
+                subScript: [new MathRun("2")],
+                superScript: [new MathRun("5")],
+            });
+
+            const tree = new Formatter().format(mathSubScript);
+            expect(tree).to.deep.equal({
+                "m:sSubSup": [
+                    {
+                        "m:sSubSupPr": {},
+                    },
+                    {
+                        "m:e": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["e"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        "m:sub": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["2"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        "m:sup": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["5"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/script/sub-super-script/math-sub-super-script-function.ts

@@ -0,0 +1,23 @@
+// http://www.datypic.com/sc/ooxml/e-m_sSubSup-1.html
+import { XmlComponent } from "file/xml-components";
+
+import { MathComponent } from "../../math-component";
+import { MathBase, MathSubScriptElement, MathSuperScriptElement } from "../../n-ary";
+import { MathSubSuperScriptProperties } from "./math-sub-super-script-function-properties";
+
+export interface IMathSubSuperScriptOptions {
+    readonly children: MathComponent[];
+    readonly subScript: MathComponent[];
+    readonly superScript: MathComponent[];
+}
+
+export class MathSubSuperScript extends XmlComponent {
+    constructor(options: IMathSubSuperScriptOptions) {
+        super("m:sSubSup");
+
+        this.root.push(new MathSubSuperScriptProperties());
+        this.root.push(new MathBase(options.children));
+        this.root.push(new MathSubScriptElement(options.subScript));
+        this.root.push(new MathSuperScriptElement(options.superScript));
+    }
+}

src/file/paragraph/math/script/super-script/index.ts

@@ -0,0 +1,2 @@
+export * from "./math-super-script-function";
+export * from "./math-super-script-function-properties";

src/file/paragraph/math/script/super-script/math-super-script-function-properties.spec.ts

@@ -0,0 +1,17 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+import { MathSuperScriptProperties } from "./math-super-script-function-properties";
+
+describe("MathSuperScriptProperties", () => {
+    describe("#constructor()", () => {
+        it("should create a MathSuperScriptProperties with correct root key", () => {
+            const mathSuperScriptProperties = new MathSuperScriptProperties();
+
+            const tree = new Formatter().format(mathSuperScriptProperties);
+            expect(tree).to.deep.equal({
+                "m:sSupPr": {},
+            });
+        });
+    });
+});

src/file/paragraph/math/script/super-script/math-super-script-function-properties.ts

@@ -0,0 +1,8 @@
+// http://www.datypic.com/sc/ooxml/e-m_sSupPr-1.html
+import { XmlComponent } from "file/xml-components";
+
+export class MathSuperScriptProperties extends XmlComponent {
+    constructor() {
+        super("m:sSupPr");
+    }
+}

src/file/paragraph/math/script/super-script/math-super-script-function.spec.ts

@@ -0,0 +1,48 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import { MathRun } from "../../math-run";
+import { MathSuperScript } from "./math-super-script-function";
+
+describe("MathSuperScript", () => {
+    describe("#constructor()", () => {
+        it("should create a MathSuperScript with correct root key", () => {
+            const mathSuperScript = new MathSuperScript({
+                children: [new MathRun("e")],
+                superScript: [new MathRun("2")],
+            });
+
+            const tree = new Formatter().format(mathSuperScript);
+            expect(tree).to.deep.equal({
+                "m:sSup": [
+                    {
+                        "m:sSupPr": {},
+                    },
+                    {
+                        "m:e": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["e"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        "m:sup": [
+                            {
+                                "m:r": [
+                                    {
+                                        "m:t": ["2"],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/paragraph/math/script/super-script/math-super-script-function.ts

@@ -0,0 +1,21 @@
+// http://www.datypic.com/sc/ooxml/e-m_sSup-1.html
+import { XmlComponent } from "file/xml-components";
+
+import { MathComponent } from "../../math-component";
+import { MathBase, MathSuperScriptElement } from "../../n-ary";
+import { MathSuperScriptProperties } from "./math-super-script-function-properties";
+
+export interface IMathSuperScriptOptions {
+    readonly children: MathComponent[];
+    readonly superScript: MathComponent[];
+}
+
+export class MathSuperScript extends XmlComponent {
+    constructor(options: IMathSuperScriptOptions) {
+        super("m:sSup");
+
+        this.root.push(new MathSuperScriptProperties());
+        this.root.push(new MathBase(options.children));
+        this.root.push(new MathSuperScriptElement(options.superScript));
+    }
+}

src/file/paragraph/paragraph.spec.ts

@@ -5,8 +5,10 @@ import { stub } from "sinon";
 import { Formatter } from "export/formatter";
 import { EMPTY_OBJECT } from "file/xml-components";
 
+import { IViewWrapper } from "../document-wrapper";
+import { ShadingType } from "../table/shading";
 import { AlignmentType, HeadingLevel, LeaderType, PageBreak, TabStopPosition, TabStopType } from "./formatting";
-import { Bookmark } from "./links";
+import { Bookmark, ExternalHyperlink } from "./links";
 import { Paragraph } from "./paragraph";
 import { TextRun } from "./run";
 
@@ -543,14 +545,8 @@ describe("Paragraph", () => {
                 },
             });
             const tree = new Formatter().format(paragraph);
-            expect(tree)
-                .to.have.property("w:p")
-                .which.is.an("array")
-                .which.has.length.at.least(1);
-            expect(tree["w:p"][0])
-                .to.have.property("w:pPr")
-                .which.is.an("array")
-                .which.has.length.at.least(1);
+            expect(tree).to.have.property("w:p").which.is.an("array").which.has.length.at.least(1);
+            expect(tree["w:p"][0]).to.have.property("w:pPr").which.is.an("array").which.has.length.at.least(1);
             expect(tree["w:p"][0]["w:pPr"][0]).to.deep.equal({
                 "w:pStyle": { _attr: { "w:val": "ListParagraph" } },
             });
@@ -563,14 +559,8 @@ describe("Paragraph", () => {
                 },
             });
             const tree = new Formatter().format(paragraph);
-            expect(tree)
-                .to.have.property("w:p")
-                .which.is.an("array")
-                .which.has.length.at.least(1);
-            expect(tree["w:p"][0])
-                .to.have.property("w:pPr")
-                .which.is.an("array")
-                .which.has.length.at.least(1);
+            expect(tree).to.have.property("w:p").which.is.an("array").which.has.length.at.least(1);
+            expect(tree["w:p"][0]).to.have.property("w:pPr").which.is.an("array").which.has.length.at.least(1);
             expect(tree["w:p"][0]["w:pPr"][0]).to.deep.equal({
                 "w:pStyle": { _attr: { "w:val": "ListParagraph" } },
             });
@@ -583,14 +573,8 @@ describe("Paragraph", () => {
                 },
             });
             const tree = new Formatter().format(paragraph);
-            expect(tree)
-                .to.have.property("w:p")
-                .which.is.an("array")
-                .which.has.length.at.least(1);
-            expect(tree["w:p"][0])
-                .to.have.property("w:pPr")
-                .which.is.an("array")
-                .which.has.length.at.least(2);
+            expect(tree).to.have.property("w:p").which.is.an("array").which.has.length.at.least(1);
+            expect(tree["w:p"][0]).to.have.property("w:pPr").which.is.an("array").which.has.length.at.least(2);
             expect(tree["w:p"][0]["w:pPr"][1]).to.deep.equal({
                 "w:numPr": [{ "w:ilvl": { _attr: { "w:val": 1 } } }, { "w:numId": { _attr: { "w:val": 1 } } }],
             });
@@ -606,14 +590,8 @@ describe("Paragraph", () => {
                 },
             });
             const tree = new Formatter().format(paragraph);
-            expect(tree)
-                .to.have.property("w:p")
-                .which.is.an("array")
-                .which.has.length.at.least(1);
-            expect(tree["w:p"][0])
-                .to.have.property("w:pPr")
-                .which.is.an("array")
-                .which.has.length.at.least(1);
+            expect(tree).to.have.property("w:p").which.is.an("array").which.has.length.at.least(1);
+            expect(tree["w:p"][0]).to.have.property("w:pPr").which.is.an("array").which.has.length.at.least(1);
             expect(tree["w:p"][0]["w:pPr"][0]).to.deep.equal({
                 "w:pStyle": { _attr: { "w:val": "ListParagraph" } },
             });
@@ -789,4 +767,82 @@ describe("Paragraph", () => {
             });
         });
     });
+
+    describe("#shading", () => {
+        it("should set shading to the given value", () => {
+            const paragraph = new Paragraph({
+                shading: {
+                    type: ShadingType.REVERSE_DIAGONAL_STRIPE,
+                    color: "00FFFF",
+                    fill: "FF0000",
+                },
+            });
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [
+                            {
+                                "w:shd": {
+                                    _attr: {
+                                        "w:color": "00FFFF",
+                                        "w:fill": "FF0000",
+                                        "w:val": "reverseDiagStripe",
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+
+    describe("#prepForXml", () => {
+        it("should set Internal Hyperlink", () => {
+            const paragraph = new Paragraph({
+                children: [
+                    new ExternalHyperlink({
+                        child: new TextRun("test"),
+                        link: "http://www.google.com",
+                    }),
+                ],
+            });
+            const fileMock = ({
+                Relationships: {
+                    createRelationship: () => ({}),
+                },
+            } as unknown) as IViewWrapper;
+            paragraph.prepForXml(fileMock);
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:hyperlink": [
+                            {
+                                _attr: {
+                                    "r:id": "rIdtest-unique-id",
+                                    "w:history": 1,
+                                },
+                            },
+                            {
+                                "w:r": [
+                                    {
+                                        "w:t": [
+                                            {
+                                                _attr: {
+                                                    "xml:space": "preserve",
+                                                },
+                                            },
+                                            "test",
+                                        ],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
 });

src/file/paragraph/paragraph.ts

@@ -1,53 +1,35 @@
 // http://officeopenxml.com/WPparagraph.php
+import * as shortid from "shortid";
+
 import { FootnoteReferenceRun } from "file/footnotes/footnote/run/reference-run";
 import { IXmlableObject, XmlComponent } from "file/xml-components";
 
-import { File } from "../file";
-import { Alignment, AlignmentType } from "./formatting/alignment";
-import { Bidirectional } from "./formatting/bidirectional";
-import { IBorderOptions, ThematicBreak } from "./formatting/border";
-import { IIndentAttributesProperties, Indent } from "./formatting/indent";
-import { KeepLines, KeepNext } from "./formatting/keep";
-import { PageBreak, PageBreakBefore } from "./formatting/page-break";
-import { ContextualSpacing, ISpacingProperties, Spacing } from "./formatting/spacing";
-import { HeadingLevel, Style } from "./formatting/style";
-import { LeaderType, TabStop, TabStopPosition, TabStopType } from "./formatting/tab-stop";
-import { NumberProperties } from "./formatting/unordered-list";
-import { Bookmark, HyperlinkRef, OutlineLevel } from "./links";
-import { ParagraphProperties } from "./properties";
+import { IViewWrapper } from "../document-wrapper";
+import { TargetModeType } from "../relationships/relationship/relationship";
+import { DeletedTextRun, InsertedTextRun } from "../track-revision";
+import { PageBreak } from "./formatting/page-break";
+import { Bookmark, ConcreteHyperlink, ExternalHyperlink, InternalHyperlink } from "./links";
+import { Math } from "./math";
+import { IParagraphPropertiesOptions, ParagraphProperties } from "./properties";
 import { PictureRun, Run, SequentialIdentifier, SymbolRun, TextRun } from "./run";
 
-export interface IParagraphOptions {
+export type ParagraphChild =
+    | TextRun
+    | PictureRun
+    | SymbolRun
+    | Bookmark
+    | PageBreak
+    | SequentialIdentifier
+    | FootnoteReferenceRun
+    | InternalHyperlink
+    | ExternalHyperlink
+    | InsertedTextRun
+    | DeletedTextRun
+    | Math;
+
+export interface IParagraphOptions extends IParagraphPropertiesOptions {
     readonly text?: string;
-    readonly border?: IBorderOptions;
-    readonly spacing?: ISpacingProperties;
-    readonly outlineLevel?: number;
-    readonly alignment?: AlignmentType;
-    readonly heading?: HeadingLevel;
-    readonly bidirectional?: boolean;
-    readonly thematicBreak?: boolean;
-    readonly pageBreakBefore?: boolean;
-    readonly contextualSpacing?: boolean;
-    readonly indent?: IIndentAttributesProperties;
-    readonly keepLines?: boolean;
-    readonly keepNext?: boolean;
-    readonly tabStops?: Array<{
-        readonly position: number | TabStopPosition;
-        readonly type: TabStopType;
-        readonly leader?: LeaderType;
-    }>;
-    readonly style?: string;
-    readonly bullet?: {
-        readonly level: number;
-    };
-    readonly numbering?: {
-        readonly reference: string;
-        readonly level: number;
-        readonly custom?: boolean;
-    };
-    readonly children?: Array<
-        TextRun | PictureRun | SymbolRun | Bookmark | PageBreak | SequentialIdentifier | FootnoteReferenceRun | HyperlinkRef
-    >;
+    readonly children?: ParagraphChild[];
 }
 
 export class Paragraph extends XmlComponent {
@@ -70,9 +52,7 @@ export class Paragraph extends XmlComponent {
             return;
         }
 
-        this.properties = new ParagraphProperties({
-            border: options.border,
-        });
+        this.properties = new ParagraphProperties(options);
 
         this.root.push(this.properties);
 
@@ -80,72 +60,6 @@ export class Paragraph extends XmlComponent {
             this.root.push(new TextRun(options.text));
         }
 
-        if (options.spacing) {
-            this.properties.push(new Spacing(options.spacing));
-        }
-
-        if (options.outlineLevel !== undefined) {
-            this.properties.push(new OutlineLevel(options.outlineLevel));
-        }
-
-        if (options.alignment) {
-            this.properties.push(new Alignment(options.alignment));
-        }
-
-        if (options.heading) {
-            this.properties.push(new Style(options.heading));
-        }
-
-        if (options.bidirectional) {
-            this.properties.push(new Bidirectional());
-        }
-
-        if (options.thematicBreak) {
-            this.properties.push(new ThematicBreak());
-        }
-
-        if (options.pageBreakBefore) {
-            this.properties.push(new PageBreakBefore());
-        }
-
-        if (options.contextualSpacing) {
-            this.properties.push(new ContextualSpacing(options.contextualSpacing));
-        }
-
-        if (options.indent) {
-            this.properties.push(new Indent(options.indent));
-        }
-
-        if (options.keepLines) {
-            this.properties.push(new KeepLines());
-        }
-
-        if (options.keepNext) {
-            this.properties.push(new KeepNext());
-        }
-
-        if (options.tabStops) {
-            for (const tabStop of options.tabStops) {
-                this.properties.push(new TabStop(tabStop.type, tabStop.position, tabStop.leader));
-            }
-        }
-
-        if (options.style) {
-            this.properties.push(new Style(options.style));
-        }
-
-        if (options.bullet) {
-            this.properties.push(new Style("ListParagraph"));
-            this.properties.push(new NumberProperties(1, options.bullet.level));
-        }
-
-        if (options.numbering) {
-            if (!options.numbering.custom) {
-                this.properties.push(new Style("ListParagraph"));
-            }
-            this.properties.push(new NumberProperties(options.numbering.reference, options.numbering.level));
-        }
-
         if (options.children) {
             for (const child of options.children) {
                 if (child instanceof Bookmark) {
@@ -162,11 +76,18 @@ export class Paragraph extends XmlComponent {
         }
     }
 
-    public prepForXml(file: File): IXmlableObject | undefined {
+    public prepForXml(file: IViewWrapper): IXmlableObject | undefined {
         for (const element of this.root) {
-            if (element instanceof HyperlinkRef) {
+            if (element instanceof ExternalHyperlink) {
                 const index = this.root.indexOf(element);
-                this.root[index] = file.HyperlinkCache[element.id];
+                const concreteHyperlink = new ConcreteHyperlink(element.options.child, shortid.generate().toLowerCase());
+                file.Relationships.createRelationship(
+                    concreteHyperlink.linkId,
+                    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink",
+                    element.options.link,
+                    TargetModeType.EXTERNAL,
+                );
+                this.root[index] = concreteHyperlink;
             }
         }
 

src/file/paragraph/properties.ts

@@ -1,19 +1,147 @@
 // http://officeopenxml.com/WPparagraphProperties.php
 import { IgnoreIfEmptyXmlComponent, XmlComponent } from "file/xml-components";
+import { ShadingType } from "../table/shading";
+import { Alignment, AlignmentType } from "./formatting/alignment";
+import { Bidirectional } from "./formatting/bidirectional";
+import { Border, IBorderOptions, ThematicBreak } from "./formatting/border";
+import { IIndentAttributesProperties, Indent } from "./formatting/indent";
+import { KeepLines, KeepNext } from "./formatting/keep";
+import { PageBreakBefore } from "./formatting/page-break";
+import { ContextualSpacing, ISpacingProperties, Spacing } from "./formatting/spacing";
+import { HeadingLevel, Style } from "./formatting/style";
+import { LeaderType, TabStop, TabStopPosition, TabStopType } from "./formatting/tab-stop";
+import { NumberProperties } from "./formatting/unordered-list";
+import { OutlineLevel } from "./links";
+import { Shading } from "./run/formatting";
 
-import { Border, IBorderOptions } from "./formatting/border";
+export interface IParagraphStylePropertiesOptions {
+    readonly alignment?: AlignmentType;
+    readonly thematicBreak?: boolean;
+    readonly contextualSpacing?: boolean;
+    readonly rightTabStop?: number;
+    readonly leftTabStop?: number;
+    readonly indent?: IIndentAttributesProperties;
+    readonly spacing?: ISpacingProperties;
+    readonly keepNext?: boolean;
+    readonly keepLines?: boolean;
+    readonly outlineLevel?: number;
+}
 
-interface IParagraphPropertiesOptions {
+export interface IParagraphPropertiesOptions extends IParagraphStylePropertiesOptions {
     readonly border?: IBorderOptions;
+    readonly heading?: HeadingLevel;
+    readonly bidirectional?: boolean;
+    readonly pageBreakBefore?: boolean;
+    readonly tabStops?: {
+        readonly position: number | TabStopPosition;
+        readonly type: TabStopType;
+        readonly leader?: LeaderType;
+    }[];
+    readonly style?: string;
+    readonly bullet?: {
+        readonly level: number;
+    };
+    readonly numbering?: {
+        readonly reference: string;
+        readonly level: number;
+        readonly custom?: boolean;
+    };
+    readonly shading?: {
+        readonly type: ShadingType;
+        readonly fill: string;
+        readonly color: string;
+    };
 }
 
 export class ParagraphProperties extends IgnoreIfEmptyXmlComponent {
-    constructor(options: IParagraphPropertiesOptions) {
+    constructor(options?: IParagraphPropertiesOptions) {
         super("w:pPr");
 
+        if (!options) {
+            return;
+        }
+
         if (options.border) {
             this.push(new Border(options.border));
         }
+
+        if (options.spacing) {
+            this.push(new Spacing(options.spacing));
+        }
+
+        if (options.outlineLevel !== undefined) {
+            this.push(new OutlineLevel(options.outlineLevel));
+        }
+
+        if (options.alignment) {
+            this.push(new Alignment(options.alignment));
+        }
+
+        if (options.heading) {
+            this.push(new Style(options.heading));
+        }
+
+        if (options.bidirectional) {
+            this.push(new Bidirectional());
+        }
+
+        if (options.thematicBreak) {
+            this.push(new ThematicBreak());
+        }
+
+        if (options.pageBreakBefore) {
+            this.push(new PageBreakBefore());
+        }
+
+        if (options.contextualSpacing) {
+            this.push(new ContextualSpacing(options.contextualSpacing));
+        }
+
+        if (options.indent) {
+            this.push(new Indent(options.indent));
+        }
+
+        if (options.keepLines) {
+            this.push(new KeepLines());
+        }
+
+        if (options.keepNext) {
+            this.push(new KeepNext());
+        }
+
+        if (options.tabStops) {
+            for (const tabStop of options.tabStops) {
+                this.push(new TabStop(tabStop.type, tabStop.position, tabStop.leader));
+            }
+        }
+
+        if (options.style) {
+            this.push(new Style(options.style));
+        }
+
+        if (options.bullet) {
+            this.push(new Style("ListParagraph"));
+            this.push(new NumberProperties(1, options.bullet.level));
+        }
+
+        if (options.numbering) {
+            if (!options.numbering.custom) {
+                this.push(new Style("ListParagraph"));
+            }
+            this.push(new NumberProperties(options.numbering.reference, options.numbering.level));
+        }
+
+        if (options.rightTabStop) {
+            this.push(new TabStop(TabStopType.RIGHT, options.rightTabStop));
+        }
+
+        if (options.leftTabStop) {
+            this.push(new TabStop(TabStopType.LEFT, options.leftTabStop));
+        }
+
+        if (options.shading) {
+            this.push(new Shading(options.shading.type, options.shading.fill, options.shading.color));
+        }
     }
 
     public push(item: XmlComponent): void {

src/file/paragraph/run/caps.ts

@@ -1,13 +0,0 @@
-import { XmlComponent } from "file/xml-components";
-
-export class SmallCaps extends XmlComponent {
-    constructor() {
-        super("w:smallCaps");
-    }
-}
-
-export class Caps extends XmlComponent {
-    constructor() {
-        super("w:caps");
-    }
-}

src/file/paragraph/run/emphasis-mark.spec.ts

@@ -0,0 +1,29 @@
+import { expect } from "chai";
+
+import { Formatter } from "export/formatter";
+
+import * as em from "./emphasis-mark";
+
+describe("EmphasisMark", () => {
+    describe("#constructor()", () => {
+        it("should create a new EmphasisMark object with w:em as the rootKey", () => {
+            const emphasisMark = new em.EmphasisMark();
+            const tree = new Formatter().format(emphasisMark);
+            expect(tree).to.deep.equal({
+                "w:em": { _attr: { "w:val": "dot" } },
+            });
+        });
+    });
+});
+
+describe("DotEmphasisMark", () => {
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const emphasisMark = new em.DotEmphasisMark();
+            const tree = new Formatter().format(emphasisMark);
+            expect(tree).to.deep.equal({
+                "w:em": { _attr: { "w:val": "dot" } },
+            });
+        });
+    });
+});

src/file/paragraph/run/emphasis-mark.ts

@@ -0,0 +1,28 @@
+import { Attributes, XmlComponent } from "file/xml-components";
+
+export enum EmphasisMarkType {
+    DOT = "dot",
+}
+
+export abstract class BaseEmphasisMark extends XmlComponent {
+    protected constructor(emphasisMarkType: EmphasisMarkType) {
+        super("w:em");
+        this.root.push(
+            new Attributes({
+                val: emphasisMarkType,
+            }),
+        );
+    }
+}
+
+export class EmphasisMark extends BaseEmphasisMark {
+    constructor(emphasisMarkType: EmphasisMarkType = EmphasisMarkType.DOT) {
+        super(emphasisMarkType);
+    }
+}
+
+export class DotEmphasisMark extends BaseEmphasisMark {
+    constructor() {
+        super(EmphasisMarkType.DOT);
+    }
+}

src/file/paragraph/run/formatting.ts

@@ -1,7 +1,9 @@
 import { Attributes, XmlComponent } from "file/xml-components";
+
 export { Underline } from "./underline";
+export { EmphasisMark } from "./emphasis-mark";
 export { SubScript, SuperScript } from "./script";
-export { RunFonts } from "./run-fonts";
+export { RunFonts, IFontAttributesProperties } from "./run-fonts";
 
 export class Bold extends XmlComponent {
     constructor() {
@@ -113,17 +115,6 @@ export class Imprint extends XmlComponent {
     }
 }
 
-/* export class Shadow extends XmlComponent {
-    constructor() {
-        super("w:shadow");
-        this.root.push(
-            new Attributes({
-                val: true,
-            }),
-        );
-    }
-} */
-
 export class SmallCaps extends XmlComponent {
     constructor() {
         super("w:smallCaps");

src/file/paragraph/run/index.ts

@@ -1,8 +1,10 @@
 export * from "./run";
+export * from "./properties";
 export * from "./text-run";
 export * from "./symbol-run";
 export * from "./picture-run";
 export * from "./run-fonts";
 export * from "./sequential-identifier";
 export * from "./underline";
+export * from "./emphasis-mark";
 export * from "./tab";

src/file/paragraph/run/properties.ts

@@ -1,8 +1,183 @@
+import { ShadingType } from "file/table";
 import { IgnoreIfEmptyXmlComponent, XmlComponent } from "file/xml-components";
+import { EmphasisMark, EmphasisMarkType } from "./emphasis-mark";
+import {
+    Bold,
+    BoldComplexScript,
+    Caps,
+    CharacterSpacing,
+    Color,
+    DoubleStrike,
+    Highlight,
+    HighlightComplexScript,
+    Italics,
+    ItalicsComplexScript,
+    RightToLeft,
+    Shading,
+    ShadowComplexScript,
+    Size,
+    SizeComplexScript,
+    SmallCaps,
+    Strike,
+} from "./formatting";
+import { IFontAttributesProperties, RunFonts } from "./run-fonts";
+import { SubScript, SuperScript } from "./script";
+import { Style } from "./style";
+import { Underline, UnderlineType } from "./underline";
+
+interface IFontOptions {
+    readonly name: string;
+    readonly hint?: string;
+}
+
+export interface IRunStylePropertiesOptions {
+    readonly bold?: boolean;
+    readonly boldComplexScript?: boolean;
+    readonly italics?: boolean;
+    readonly italicsComplexScript?: boolean;
+    readonly underline?: {
+        readonly color?: string;
+        readonly type?: UnderlineType;
+    };
+    readonly emphasisMark?: {
+        readonly type?: EmphasisMarkType;
+    };
+    readonly color?: string;
+    readonly size?: number;
+    readonly sizeComplexScript?: boolean | number;
+    readonly rightToLeft?: boolean;
+    readonly smallCaps?: boolean;
+    readonly allCaps?: boolean;
+    readonly strike?: boolean;
+    readonly doubleStrike?: boolean;
+    readonly subScript?: boolean;
+    readonly superScript?: boolean;
+    readonly font?: string | IFontOptions | IFontAttributesProperties;
+    readonly highlight?: string;
+    readonly highlightComplexScript?: boolean | string;
+    readonly characterSpacing?: number;
+    readonly shading?: {
+        readonly type: ShadingType;
+        readonly fill: string;
+        readonly color: string;
+    };
+    readonly shadingComplexScript?: boolean | IRunStylePropertiesOptions["shading"];
+    readonly shadow?: IRunStylePropertiesOptions["shading"];
+}
+
+export interface IRunPropertiesOptions extends IRunStylePropertiesOptions {
+    readonly style?: string;
+}
 
 export class RunProperties extends IgnoreIfEmptyXmlComponent {
-    constructor() {
+    constructor(options?: IRunPropertiesOptions) {
         super("w:rPr");
+
+        if (!options) {
+            return;
+        }
+
+        if (options.bold) {
+            this.push(new Bold());
+        }
+        if ((options.boldComplexScript === undefined && options.bold) || options.boldComplexScript) {
+            this.push(new BoldComplexScript());
+        }
+
+        if (options.italics) {
+            this.push(new Italics());
+        }
+        if ((options.italicsComplexScript === undefined && options.italics) || options.italicsComplexScript) {
+            this.push(new ItalicsComplexScript());
+        }
+
+        if (options.underline) {
+            this.push(new Underline(options.underline.type, options.underline.color));
+        }
+
+        if (options.emphasisMark) {
+            this.push(new EmphasisMark(options.emphasisMark.type));
+        }
+
+        if (options.color) {
+            this.push(new Color(options.color));
+        }
+
+        if (options.size) {
+            this.push(new Size(options.size));
+        }
+        const szCs =
+            options.sizeComplexScript === undefined || options.sizeComplexScript === true ? options.size : options.sizeComplexScript;
+        if (szCs) {
+            this.push(new SizeComplexScript(szCs));
+        }
+
+        if (options.rightToLeft) {
+            this.push(new RightToLeft());
+        }
+
+        if (options.smallCaps) {
+            this.push(new SmallCaps());
+        }
+
+        if (options.allCaps) {
+            this.push(new Caps());
+        }
+
+        if (options.strike) {
+            this.push(new Strike());
+        }
+
+        if (options.doubleStrike) {
+            this.push(new DoubleStrike());
+        }
+
+        if (options.subScript) {
+            this.push(new SubScript());
+        }
+
+        if (options.superScript) {
+            this.push(new SuperScript());
+        }
+
+        if (options.style) {
+            this.push(new Style(options.style));
+        }
+
+        if (options.font) {
+            if (typeof options.font === "string") {
+                this.push(new RunFonts(options.font));
+            } else if ("name" in options.font) {
+                this.push(new RunFonts(options.font.name, options.font.hint));
+            } else {
+                this.push(new RunFonts(options.font));
+            }
+        }
+
+        if (options.highlight) {
+            this.push(new Highlight(options.highlight));
+        }
+        const highlightCs =
+            options.highlightComplexScript === undefined || options.highlightComplexScript === true
+                ? options.highlight
+                : options.highlightComplexScript;
+        if (highlightCs) {
+            this.push(new HighlightComplexScript(highlightCs));
+        }
+
+        if (options.characterSpacing) {
+            this.push(new CharacterSpacing(options.characterSpacing));
+        }
+
+        const shading = options.shading || options.shadow;
+        if (shading) {
+            this.push(new Shading(shading.type, shading.fill, shading.color));
+        }
+        const shdCs =
+            options.shadingComplexScript === undefined || options.shadingComplexScript === true ? shading : options.shadingComplexScript;
+        if (shdCs) {
+            this.push(new ShadowComplexScript(shdCs.type, shdCs.fill, shdCs.color));
+        }
     }
 
     public push(item: XmlComponent): void {