Move ts to src folder for standards

src/docx/document/body/body.spec.ts

@@ -0,0 +1,50 @@
+import { assert } from "chai";
+
+import { Utility } from "../../../tests/utility";
+import { Body } from "./";
+import { Columns } from "./columns";
+import { DocumentGrid } from "./doc-grid";
+import { PageMargin } from "./page-margin";
+import { PageSize } from "./page-size";
+import { SectionProperties } from "./section-properties";
+
+describe("Body", () => {
+    let body: Body;
+
+    beforeEach(() => {
+        body = new Body();
+        body.push(new SectionProperties());
+        body.push(new PageSize());
+        body.push(new PageMargin());
+        body.push(new Columns());
+        body.push(new DocumentGrid());
+    });
+
+    describe("#constructor()", () => {
+
+        it("should create the Section Properties", () => {
+            const newJson = Utility.jsonify(body);
+            assert.equal(newJson.root[0].rootKey, "w:sectPr");
+        });
+
+        it("should create the Page Size", () => {
+            const newJson = Utility.jsonify(body);
+            assert.equal(newJson.root[1].rootKey, "w:pgSz");
+        });
+
+        it("should create the Page Margin", () => {
+            const newJson = Utility.jsonify(body);
+            assert.equal(newJson.root[2].rootKey, "w:pgMar");
+        });
+
+        it("should create the Columns", () => {
+            const newJson = Utility.jsonify(body);
+            assert.equal(newJson.root[3].rootKey, "w:cols");
+        });
+
+        it("should create the Document Grid", () => {
+            const newJson = Utility.jsonify(body);
+            assert.equal(newJson.root[4].rootKey, "w:docGrid");
+        });
+    });
+});

src/docx/document/body/body.ts

@@ -0,0 +1,12 @@
+import { XmlComponent } from "../../xml-components";
+
+export class Body extends XmlComponent {
+
+    constructor() {
+        super("w:body");
+    }
+
+    public push(component: XmlComponent): void {
+        this.root.push(component);
+    }
+}

src/docx/document/body/columns.ts

@@ -0,0 +1,11 @@
+import { Attributes, XmlComponent } from "../../xml-components";
+
+export class Columns extends XmlComponent {
+
+    constructor() {
+        super("w:cols");
+        this.root.push(new Attributes({
+            space: "708",
+        }));
+    }
+}

src/docx/document/body/doc-grid.ts

@@ -0,0 +1,11 @@
+import { Attributes, XmlComponent } from "../../xml-components";
+
+export class DocumentGrid extends XmlComponent {
+
+    constructor() {
+        super("w:docGrid");
+        this.root.push(new Attributes({
+            linePitch: "360",
+        }));
+    }
+}

src/docx/document/body/index.ts

@@ -0,0 +1 @@
+export * from "./body";

src/docx/document/body/page-margin.ts

@@ -0,0 +1,17 @@
+import { Attributes, XmlComponent } from "../../xml-components";
+
+export class PageMargin extends XmlComponent {
+
+    constructor() {
+        super("w:pgMar");
+        this.root.push(new Attributes({
+            top: "1440",
+            right: "1440",
+            bottom: "1440",
+            left: "1440",
+            header: "708",
+            footer: "708",
+            gutter: "0",
+        }));
+    }
+}

src/docx/document/body/page-size.ts

@@ -0,0 +1,12 @@
+import { Attributes, XmlComponent } from "../../xml-components";
+
+export class PageSize extends XmlComponent {
+
+    constructor() {
+        super("w:pgSz");
+        this.root.push(new Attributes({
+            w: "11906",
+            h: "16838",
+        }));
+    }
+}

src/docx/document/body/section-properties.ts

@@ -0,0 +1,21 @@
+import { Attributes, XmlComponent } from "../../xml-components";
+import { Columns } from "./columns";
+import { DocumentGrid } from "./doc-grid";
+import { PageMargin } from "./page-margin";
+import { PageSize } from "./page-size";
+
+export class SectionProperties extends XmlComponent {
+
+    constructor() {
+        super("w:sectPr");
+        this.root.push(new Attributes({
+            rsidR: "00B64E8F",
+            rsidRPr: "00D842E4",
+            rsidSect: "000A6AD0",
+        }));
+        this.root.push(new PageSize());
+        this.root.push(new PageMargin());
+        this.root.push(new Columns());
+        this.root.push(new DocumentGrid());
+    }
+}

src/docx/document/document-attributes.ts

@@ -0,0 +1,55 @@
+import { XmlAttributeComponent } from "../xml-components";
+
+export interface IDocumentAttributesProperties {
+    wpc?: string;
+    mc?: string;
+    o?: string;
+    r?: string;
+    m?: string;
+    v?: string;
+    wp14?: string;
+    wp?: string;
+    w10?: string;
+    w?: string;
+    w14?: string;
+    w15?: string;
+    wpg?: string;
+    wpi?: string;
+    wne?: string;
+    wps?: string;
+    Ignorable?: string;
+    cp?: string;
+    dc?: string;
+    dcterms?: string;
+    dcmitype?: string;
+    xsi?: string;
+    type?: string;
+}
+
+export class DocumentAttributes extends XmlAttributeComponent<IDocumentAttributesProperties> {
+    protected xmlKeys = {
+        wpc: "xmlns:wpc",
+        mc: "xmlns:mc",
+        o: "xmlns:o",
+        r: "xmlns:r",
+        m: "xmlns:m",
+        v: "xmlns:v",
+        wp14: "xmlns:wp14",
+        wp: "xmlns:wp",
+        w10: "xmlns:w10",
+        w: "xmlns:w",
+        w14: "xmlns:w14",
+        w15: "xmlns:w15",
+        wpg: "xmlns:wpg",
+        wpi: "xmlns:wpi",
+        wne: "xmlns:wne",
+        wps: "xmlns:wps",
+        Ignorable: "mc:Ignorable",
+        cp: "xmlns:cp",
+        dc: "xmlns:dc",
+        dcterms: "xmlns:dcterms",
+        dcmitype: "xmlns:dcmitype",
+        xsi: "xmlns:xsi",
+        type: "xsi:type",
+    };
+}

src/docx/document/document.spec.ts

@@ -0,0 +1,74 @@
+import { assert, expect } from "chai";
+
+import * as docx from "../../";
+import { Formatter } from "../../export/formatter";
+
+describe("Document", () => {
+    let document: docx.Document;
+
+    beforeEach(() => {
+        document = new docx.Document();
+    });
+
+    describe("#constructor()", () => {
+
+        it("should create valid JSON", () => {
+            const stringifiedJson = JSON.stringify(document);
+            let newJson;
+
+            try {
+                newJson = JSON.parse(stringifiedJson);
+            } catch (e) {
+                assert.isTrue(false);
+            }
+            assert.isTrue(true);
+        });
+    });
+
+    describe("#createParagraph", () => {
+        it("should create a new paragraph and append it to body", () => {
+            const para = document.createParagraph();
+            expect(para).to.be.an.instanceof(docx.Paragraph);
+            const body = new Formatter().format(document)["w:document"][1]["w:body"];
+            expect(body).to.be.an("array").which.has.length.at.least(1);
+            expect(body[0]).to.have.property("w:p");
+        });
+
+        it("should use the text given to create a run in the paragraph", () => {
+            const para = document.createParagraph("sample paragraph text");
+            expect(para).to.be.an.instanceof(docx.Paragraph);
+            const body = new Formatter().format(document)["w:document"][1]["w:body"];
+            expect(body).to.be.an("array").which.has.length.at.least(1);
+            expect(body[0]).to.have.property("w:p").which.includes({
+                "w:r": [
+                    {"w:rPr": []},
+                    {"w:t": [{_attr: {"xml:space": "preserve"}}, "sample paragraph text"]},
+                ],
+            });
+        });
+    });
+
+    describe("#createTable", () => {
+        it("should create a new table and append it to body", () => {
+            const table = document.createTable(2, 3);
+            expect(table).to.be.an.instanceof(docx.Table);
+            const body = new Formatter().format(document)["w:document"][1]["w:body"];
+            expect(body).to.be.an("array").which.has.length.at.least(1);
+            expect(body[0]).to.have.property("w:tbl");
+        });
+
+        it("should create a table with the correct dimensions", () => {
+            document.createTable(2, 3);
+            const body = new Formatter().format(document)["w:document"][1]["w:body"];
+            expect(body).to.be.an("array").which.has.length.at.least(1);
+            expect(body[0]).to.have.property("w:tbl").which.includes({
+                "w:tblGrid": [
+                    {"w:gridCol": [{_attr: {"w:w": 1}}]},
+                    {"w:gridCol": [{_attr: {"w:w": 1}}]},
+                    {"w:gridCol": [{_attr: {"w:w": 1}}]},
+                ],
+            });
+            expect(body[0]["w:tbl"].filter((x) => x["w:tr"])).to.have.length(2);
+        });
+    });
+});

src/docx/document/document.ts

@@ -0,0 +1,56 @@
+// http://officeopenxml.com/WPdocument.php
+import { Paragraph } from "../paragraph";
+import { Table } from "../table";
+import { XmlComponent } from "../xml-components";
+import { Body } from "./body";
+import { DocumentAttributes } from "./document-attributes";
+
+export class Document extends XmlComponent {
+    private body: Body;
+
+    constructor() {
+        super("w:document");
+        this.root.push(new DocumentAttributes({
+            wpc: "http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas",
+            mc: "http://schemas.openxmlformats.org/markup-compatibility/2006",
+            o: "urn:schemas-microsoft-com:office:office",
+            r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+            m: "http://schemas.openxmlformats.org/officeDocument/2006/math",
+            v: "urn:schemas-microsoft-com:vml",
+            wp14: "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing",
+            wp: "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
+            w10: "urn:schemas-microsoft-com:office:word",
+            w: "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+            w14: "http://schemas.microsoft.com/office/word/2010/wordml",
+            w15: "http://schemas.microsoft.com/office/word/2012/wordml",
+            wpg: "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup",
+            wpi: "http://schemas.microsoft.com/office/word/2010/wordprocessingInk",
+            wne: "http://schemas.microsoft.com/office/word/2006/wordml",
+            wps: "http://schemas.microsoft.com/office/word/2010/wordprocessingShape",
+            Ignorable: "w14 w15 wp14",
+        }));
+        this.body = new Body();
+        this.root.push(this.body);
+    }
+
+    public addParagraph(paragraph: Paragraph): void {
+        this.body.push(paragraph);
+    }
+
+    public createParagraph(text?: string): Paragraph {
+        const para = new Paragraph(text);
+        this.addParagraph(para);
+        return para;
+    }
+
+    public addTable(table: Table): void {
+        this.body.push(table);
+    }
+
+    public createTable(rows: number, cols: number): Table {
+        const table = new Table(rows, cols);
+        this.addTable(table);
+        return table;
+    }
+
+}

src/docx/document/index.ts

@@ -0,0 +1 @@
+export * from "./document";

src/docx/index.ts

@@ -0,0 +1,4 @@
+export * from "./document";
+export * from "./paragraph";
+export * from "./run";
+export { Table } from "./table";

src/docx/paragraph/formatting/alignment.ts

@@ -0,0 +1,16 @@
+// http://officeopenxml.com/WPalignment.php
+import { XmlAttributeComponent, XmlComponent } from "../../xml-components";
+
+export type AlignmentOptions = "left" | "center" | "right" | "both";
+
+export class AlignmentAttributes extends XmlAttributeComponent<{val: AlignmentOptions}> {
+    protected xmlKeys = {val: "w:val"};
+}
+
+export class Alignment extends XmlComponent {
+
+    constructor(type: AlignmentOptions) {
+        super("w:jc");
+        this.root.push(new AlignmentAttributes({val: type}));
+    }
+}

src/docx/paragraph/formatting/border.spec.ts

@@ -0,0 +1,41 @@
+import { assert } from "chai";
+
+import { Utility } from "../../../tests/utility";
+import { ThematicBreak } from "./border";
+
+describe("Border", () => {
+    // TODO: Need tests here
+});
+
+describe("ThematicBreak", () => {
+    let thematicBreak: ThematicBreak;
+
+    beforeEach(() => {
+        thematicBreak = new ThematicBreak();
+    });
+
+    describe("#constructor()", () => {
+        it("should create valid JSON", () => {
+            const stringifiedJson = JSON.stringify(thematicBreak);
+            let newJson;
+
+            try {
+                newJson = JSON.parse(stringifiedJson);
+            } catch (e) {
+                assert.isTrue(false);
+            }
+            assert.isTrue(true);
+        });
+
+        it("should create a Thematic Break with correct border properties", () => {
+            const newJson = Utility.jsonify(thematicBreak);
+            const attributes = {
+                color: "auto",
+                space: "1",
+                val: "single",
+                sz: "6",
+            };
+            assert.equal(JSON.stringify(newJson.root[0].root[0].root), JSON.stringify(attributes));
+        });
+    });
+});

src/docx/paragraph/formatting/border.ts

@@ -0,0 +1,23 @@
+// http://officeopenxml.com/WPborders.php
+import { Attributes, XmlComponent } from "../../xml-components";
+
+class Border extends XmlComponent {
+
+    constructor() {
+        super("w:bottom");
+        this.root.push(new Attributes({
+            color: "auto",
+            space: "1",
+            val: "single",
+            sz: "6",
+        }));
+    }
+}
+
+export class ThematicBreak extends XmlComponent {
+
+    constructor() {
+        super("w:pBdr");
+        this.root.push(new Border());
+    }
+}

src/docx/paragraph/formatting/indent.ts

@@ -0,0 +1,28 @@
+// http://officeopenxml.com/WPindentation.php
+import { XmlAttributeComponent, XmlComponent } from "../../xml-components";
+
+interface IIndentAttributesProperties {
+    left?: number;
+    hanging?: number;
+    firstLine?: number;
+    start?: number;
+    end?: number;
+}
+
+class IndentAttributes extends XmlAttributeComponent<IIndentAttributesProperties> {
+    protected xmlKeys = {
+        left: "w:left",
+        hanging: "w:hanging",
+        firstLine: "w:firstLine",
+        start: "w:start",
+        end: "w:end",
+    };
+}
+
+export class Indent extends XmlComponent {
+
+    constructor(attrs: object) {
+        super("w:ind");
+        this.root.push(new IndentAttributes(attrs));
+    }
+}

src/docx/paragraph/formatting/index.ts

@@ -0,0 +1,9 @@
+export * from "./alignment";
+export * from "./border";
+export * from "./indent";
+export * from "./keep";
+export * from "./page-break";
+export * from "./spacing";
+export * from "./style";
+export * from "./tab-stop";
+export * from "./unordered-list";

src/docx/paragraph/formatting/keep.ts

@@ -0,0 +1,13 @@
+import { XmlComponent } from "../../xml-components";
+
+export class KeepLines extends XmlComponent {
+    constructor() {
+        super("w:keepLines");
+    }
+}
+
+export class KeepNext extends XmlComponent {
+    constructor() {
+        super("w:keepNext");
+    }
+}

src/docx/paragraph/formatting/page-break.spec.ts

@@ -0,0 +1,32 @@
+import { assert } from "chai";
+
+import { Utility } from "../../../tests/utility";
+import { PageBreak } from "./page-break";
+
+describe("PageBreak", () => {
+    let pageBreak: PageBreak;
+
+    beforeEach(() => {
+        pageBreak = new PageBreak();
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Page Break with correct attributes", () => {
+            const newJson = Utility.jsonify(pageBreak);
+            const attributes = {
+                type: "page",
+            };
+            assert.equal(JSON.stringify(newJson.root[1].root[0].root), JSON.stringify(attributes));
+        });
+
+        it("should create a Page Break with w:r", () => {
+            const newJson = Utility.jsonify(pageBreak);
+            assert.equal(newJson.rootKey, "w:r");
+        });
+
+        it("should create a Page Break with a Break inside", () => {
+            const newJson = Utility.jsonify(pageBreak);
+            assert.equal(newJson.root[1].rootKey, "w:br");
+        });
+    });
+});

src/docx/paragraph/formatting/page-break.ts

@@ -0,0 +1,21 @@
+// http://officeopenxml.com/WPtextSpecialContent-break.php
+import { Run } from "../../run";
+import { Attributes, XmlComponent } from "../../xml-components";
+
+class Break extends XmlComponent {
+
+    constructor() {
+        super("w:br");
+        this.root.push(new Attributes({
+            type: "page",
+        }));
+    }
+}
+
+export class PageBreak extends Run {
+
+    constructor() {
+        super();
+        this.root.push(new Break());
+    }
+}

src/docx/paragraph/formatting/spacing.spec.ts

@@ -0,0 +1,24 @@
+import { expect } from "chai";
+
+import { Formatter } from "../../../export/formatter";
+import { Spacing } from "./spacing";
+
+describe("Spacing", () => {
+    describe("#constructor", () => {
+        it("should set the properties given", () => {
+            const spacing = new Spacing({before: 100, after: 120, line: 150});
+            const tree = new Formatter().format(spacing);
+            expect(tree).to.deep.equal({
+                "w:spacing": [{_attr: {"w:after": 120, "w:before": 100, "w:line": 150}}],
+            });
+        });
+
+        it("should only set the given properties", () => {
+            const spacing = new Spacing({before: 100});
+            const tree = new Formatter().format(spacing);
+            expect(tree).to.deep.equal({
+                "w:spacing": [{_attr: {"w:before": 100}}],
+            });
+        });
+    });
+});

src/docx/paragraph/formatting/spacing.ts

@@ -0,0 +1,23 @@
+// http://officeopenxml.com/WPspacing.php
+import { XmlAttributeComponent, XmlComponent } from "../../xml-components";
+
+export interface ISpacingProperties {
+    after?: number;
+    before?: number;
+    line?: number;
+}
+
+class SpacingAttributes extends XmlAttributeComponent<ISpacingProperties> {
+    protected xmlKeys = {
+        after: "w:after",
+        before: "w:before",
+        line: "w:line",
+    };
+}
+
+export class Spacing extends XmlComponent {
+    constructor(opts: ISpacingProperties) {
+        super("w:spacing");
+        this.root.push(new SpacingAttributes(opts));
+    }
+}

src/docx/paragraph/formatting/style.spec.ts

@@ -0,0 +1,22 @@
+import { assert } from "chai";
+
+import { Utility } from "../../../tests/utility";
+import { Style } from "./style";
+
+describe("ParagraphStyle", () => {
+    let style: Style;
+
+    describe("#constructor()", () => {
+        it("should create a style with given value", () => {
+            style = new Style("test");
+            const newJson = Utility.jsonify(style);
+            assert.equal(newJson.root[0].root.val, "test");
+        });
+
+        it("should create a style with blank val", () => {
+            style = new Style("");
+            const newJson = Utility.jsonify(style);
+            assert.equal(newJson.root[0].root.val, "");
+        });
+    });
+});

src/docx/paragraph/formatting/style.ts

@@ -0,0 +1,11 @@
+import { Attributes, XmlComponent } from "../../xml-components";
+
+export class Style extends XmlComponent {
+
+    constructor(type: string) {
+        super("w:pStyle");
+        this.root.push(new Attributes({
+            val: type,
+        }));
+    }
+}

src/docx/paragraph/formatting/tab-stop.spec.ts

@@ -0,0 +1,57 @@
+import { assert } from "chai";
+
+import { Utility } from "../../../tests/utility";
+import { LeftTabStop, MaxRightTabStop } from "./tab-stop";
+
+describe("LeftTabStop", () => {
+    let tabStop: LeftTabStop;
+
+    beforeEach(() => {
+        tabStop = new LeftTabStop(100);
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Tab Stop with correct attributes", () => {
+            const newJson = Utility.jsonify(tabStop);
+            const attributes = {
+                val: "left",
+                pos: 100,
+            };
+            assert.equal(JSON.stringify(newJson.root[0].root[0].root), JSON.stringify(attributes));
+        });
+
+        it("should create a Tab Stop with w:tab", () => {
+            const newJson = Utility.jsonify(tabStop);
+            assert.equal(newJson.root[0].rootKey, "w:tab");
+        });
+    });
+});
+
+describe("RightTabStop", () => {
+    // TODO
+});
+
+describe("MaxRightTabStop", () => {
+    let tabStop: MaxRightTabStop;
+
+    beforeEach(() => {
+        tabStop = new MaxRightTabStop();
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Tab Stop with correct attributes", () => {
+            const newJson = Utility.jsonify(tabStop);
+
+            const attributes = {
+                val: "right",
+                pos: 9026,
+            };
+            assert.equal(JSON.stringify(newJson.root[0].root[0].root), JSON.stringify(attributes));
+        });
+
+        it("should create a Tab Stop with w:tab", () => {
+            const newJson = Utility.jsonify(tabStop);
+            assert.equal(newJson.root[0].rootKey, "w:tab");
+        });
+    });
+});

src/docx/paragraph/formatting/tab-stop.ts

@@ -0,0 +1,51 @@
+// http://officeopenxml.com/WPtab.php
+import { XmlAttributeComponent, XmlComponent } from "../../xml-components";
+
+export class TabStop extends XmlComponent {
+
+    constructor(tab: Tab) {
+        super("w:tabs");
+        this.root.push(tab);
+    }
+}
+
+export type TabValue = "left" | "right" | "center" | "bar" | "clear" | "decimal" | "end" | "num" | "start";
+
+export class TabAttributes extends XmlAttributeComponent<{val: TabValue, pos: string | number}> {
+    protected xmlKeys = {val: "w:val", pos: "w:pos"};
+}
+
+export class Tab extends XmlComponent {
+
+    constructor(value: TabValue, position: string | number) {
+        super("w:tab");
+        this.root.push(new TabAttributes({
+            val: value,
+            pos: position,
+        }));
+    }
+}
+
+export class MaxRightTabStop extends TabStop {
+    constructor() {
+        super(new Tab("right", 9026));
+    }
+}
+
+export class LeftTabStop extends TabStop {
+    constructor(position: number) {
+        super(new Tab("left", position));
+    }
+}
+
+export class RightTabStop extends TabStop {
+    constructor(position: number) {
+        super(new Tab("right", position));
+    }
+}
+
+export class CenterTabStop extends TabStop {
+    constructor(position: number) {
+        super(new Tab("center", position));
+    }
+}

src/docx/paragraph/formatting/unordered-list.spec.ts

@@ -0,0 +1,31 @@
+import { assert } from "chai";
+
+import { Utility } from "../../../tests/utility";
+import { NumberProperties } from "./unordered-list";
+
+describe("NumberProperties", () => {
+    let numberProperties: NumberProperties;
+
+    beforeEach(() => {
+        numberProperties = new NumberProperties(5, 10);
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Number Properties with correct root key", () => {
+            const newJson = Utility.jsonify(numberProperties);
+            assert.equal(newJson.rootKey, "w:numPr");
+        });
+
+        it("should create a Page Break with a Indent Level inside", () => {
+            const newJson = Utility.jsonify(numberProperties);
+            assert.equal(newJson.root[0].rootKey, "w:ilvl");
+            assert.equal(newJson.root[0].root[0].root.val, 10);
+        });
+
+        it("should create a Page Break with a Number Id inside", () => {
+            const newJson = Utility.jsonify(numberProperties);
+            assert.equal(newJson.root[1].rootKey, "w:numId");
+            assert.equal(newJson.root[1].root[0].root.val, 5);
+        });
+    });
+});

src/docx/paragraph/formatting/unordered-list.ts

@@ -0,0 +1,29 @@
+import { Attributes, XmlComponent } from "../../xml-components";
+
+export class NumberProperties extends XmlComponent {
+
+    constructor(numberId: number, indentLevel: number) {
+        super("w:numPr");
+        this.root.push(new IndentLevel(indentLevel));
+        this.root.push(new NumberId(numberId));
+    }
+}
+
+class IndentLevel extends XmlComponent {
+
+    constructor(level: number) {
+        super("w:ilvl");
+        this.root.push(new Attributes({
+            val: level,
+        }));
+    }
+}
+
+class NumberId extends XmlComponent {
+    constructor(id: number) {
+        super("w:numId");
+        this.root.push(new Attributes({
+            val: id,
+        }));
+    }
+}

src/docx/paragraph/index.ts

@@ -0,0 +1,3 @@
+export * from "./formatting";
+export * from "./paragraph";
+export * from "./properties";

src/docx/paragraph/paragraph.spec.ts

@@ -0,0 +1,293 @@
+import { assert, expect } from "chai";
+
+import * as docx from "../../docx";
+import { Formatter } from "../../export/formatter";
+import { Numbering } from "../../numbering";
+
+describe("Paragraph", () => {
+    let paragraph: docx.Paragraph;
+
+    beforeEach(() => {
+        paragraph = new docx.Paragraph();
+    });
+
+    describe("#constructor()", () => {
+
+        it("should create valid JSON", () => {
+            const stringifiedJson = JSON.stringify(paragraph);
+            let newJson;
+
+            try {
+                newJson = JSON.parse(stringifiedJson);
+            } catch (e) {
+                assert.isTrue(false);
+            }
+            assert.isTrue(true);
+        });
+
+        it("should create have valid properties", () => {
+            const stringifiedJson = JSON.stringify(paragraph);
+            const newJson = JSON.parse(stringifiedJson);
+            assert.equal(newJson.root[0].rootKey, "w:pPr");
+        });
+    });
+
+    describe("#createTextRun", () => {
+        it("should add a new run to the paragraph and return it", () => {
+            const run = paragraph.createTextRun("this is a test run");
+            expect(run).to.be.instanceof(docx.TextRun);
+            const tree = new Formatter().format(paragraph)["w:p"];
+            expect(tree).to.be.an("array").which.includes({
+                "w:r": [
+                    {"w:rPr": []},
+                    {"w:t": [{_attr: {"xml:space": "preserve"}}, "this is a test run"]},
+                ],
+            });
+        });
+    });
+
+    describe("#heading1()", () => {
+        it("should add heading style to JSON", () => {
+            paragraph.heading1();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [{"w:pStyle": [{_attr: {"w:val": "Heading1"}}]}],
+                    },
+                ],
+            });
+        });
+    });
+
+    describe("#heading2()", () => {
+        it("should add heading style to JSON", () => {
+            paragraph.heading2();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [{"w:pStyle": [{_attr: {"w:val": "Heading2"}}]}],
+                    },
+                ],
+            });
+        });
+    });
+
+    describe("#heading3()", () => {
+        it("should add heading style to JSON", () => {
+            paragraph.heading3();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [{"w:pStyle": [{_attr: {"w:val": "Heading3"}}]}],
+                    },
+                ],
+            });
+        });
+    });
+
+    describe("#title()", () => {
+        it("should add title style to JSON", () => {
+            paragraph.title();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [{"w:pStyle": [{_attr: {"w:val": "Title"}}]}],
+                    },
+                ],
+            });
+        });
+    });
+
+    describe("#center()", () => {
+        it("should add center alignment to JSON", () => {
+            paragraph.center();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [{"w:jc": [{_attr: {"w:val": "center"}}]}],
+                    },
+                ],
+            });
+        });
+    });
+
+    describe("#thematicBreak()", () => {
+        it("should add thematic break to JSON", () => {
+            paragraph.thematicBreak();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [{
+                    "w:pPr": [{
+                        "w:pBdr": [{
+                            "w:bottom": [{
+                                _attr: {
+                                    "w:val": "single",
+                                    "w:color": "auto",
+                                    "w:space": "1",
+                                    "w:sz": "6",
+                                },
+                            }],
+                        }],
+                    }],
+                }],
+            });
+        });
+    });
+
+    describe("#pageBreak()", () => {
+        it("should add page break to JSON", () => {
+            paragraph.pageBreak();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [{
+                    "w:pPr": [],
+                }, {
+                    "w:r": [
+                        {"w:rPr": []},
+                        {"w:br": [{_attr: {"w:type": "page"}}]},
+                    ],
+                }],
+            });
+        });
+    });
+
+    describe("#bullet()", () => {
+        it("should add list paragraph style to JSON", () => {
+            paragraph.bullet();
+            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["w:p"][0]["w:pPr"][0]).to.deep.equal({
+                "w:pStyle": [{_attr: {"w:val": "ListParagraph"}}],
+            });
+        });
+
+        it("it should add numbered properties", () => {
+            paragraph.bullet();
+            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["w:p"][0]["w:pPr"][1]).to.deep.equal({
+                "w:numPr": [
+                    {"w:ilvl": [{_attr: {"w:val": 0}}]},
+                    {"w:numId": [{_attr: {"w:val": 1}}]},
+                ],
+            });
+        });
+    });
+
+    describe("#setNumbering", () => {
+        it("should add list paragraph style to JSON", () => {
+            const numbering = new Numbering();
+            const numberedAbstract = numbering.createAbstractNumbering();
+            numberedAbstract.createLevel(0, "lowerLetter", "%1)", "start");
+            const letterNumbering = numbering.createConcreteNumbering(numberedAbstract);
+
+            paragraph.setNumbering(letterNumbering, 0);
+            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["w:p"][0]["w:pPr"][0]).to.deep.equal({
+                "w:pStyle": [{_attr: {"w:val": "ListParagraph"}}],
+            });
+        });
+
+        it("it should add numbered properties", () => {
+            const numbering = new Numbering();
+            const numberedAbstract = numbering.createAbstractNumbering();
+            numberedAbstract.createLevel(0, "lowerLetter", "%1)", "start");
+            const letterNumbering = numbering.createConcreteNumbering(numberedAbstract);
+
+            paragraph.setNumbering(letterNumbering, 0);
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [
+                            {"w:pStyle": [{_attr: {"w:val": "ListParagraph"}}]},
+                            {
+                                "w:numPr": [
+                                    {"w:ilvl": [{_attr: {"w:val": 0}}]},
+                                    {"w:numId": [{_attr: {"w:val": letterNumbering.id}}]},
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+
+    describe("#style", () => {
+        it("should set the paragraph style to the given styleId", () => {
+            paragraph.style("myFancyStyle");
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [
+                            {"w:pStyle": [{_attr: {"w:val": "myFancyStyle"}}]},
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+
+    describe("#indent", () => {
+        it("should set the paragraph indent to the given values", () => {
+            paragraph.indent({ left: 720 });
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [
+                            {"w:ind": [{_attr: {"w:left": 720}}]},
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+
+    describe("#spacing", () => {
+        it("should set the paragraph spacing to the given values", () => {
+            paragraph.spacing({before: 90, line: 50});
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [
+                            {"w:spacing": [{_attr: {"w:before": 90, "w:line": 50}}]},
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+
+    describe("#keepLines", () => {
+        it("should set the paragraph keepLines sub-component", () => {
+            paragraph.keepLines();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [{"w:pPr": [{"w:keepLines": []}]}],
+            });
+        });
+    });
+
+    describe("#keepNext", () => {
+        it("should set the paragraph keepNext sub-component", () => {
+            paragraph.keepNext();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [{"w:pPr": [{"w:keepNext": []}]}],
+            });
+        });
+    });
+});

src/docx/paragraph/paragraph.ts

@@ -0,0 +1,165 @@
+// http://officeopenxml.com/WPparagraph.php
+import { IData } from "../../media/data";
+import { Num } from "../../numbering/num";
+import { Run } from "../run";
+import { PictureRun } from "../run/picture-run";
+import { TextRun } from "../run/text-run";
+import { XmlComponent } from "../xml-components";
+
+import { Alignment } from "./formatting/alignment";
+import { ThematicBreak } from "./formatting/border";
+import { Indent } from "./formatting/indent";
+import { KeepLines, KeepNext } from "./formatting/keep";
+import { PageBreak } from "./formatting/page-break";
+import { ISpacingProperties, Spacing } from "./formatting/spacing";
+import { Style } from "./formatting/style";
+import { CenterTabStop, LeftTabStop, MaxRightTabStop, RightTabStop } from "./formatting/tab-stop";
+import { NumberProperties } from "./formatting/unordered-list";
+import { ParagraphProperties } from "./properties";
+
+export class Paragraph extends XmlComponent {
+    private properties: ParagraphProperties;
+
+    constructor(text?: string) {
+        super("w:p");
+        this.properties = new ParagraphProperties();
+        this.root.push(this.properties);
+        if (text !== undefined) {
+            this.root.push(new TextRun(text));
+        }
+    }
+
+    public addRun(run: Run): Paragraph {
+        this.root.push(run);
+        return this;
+    }
+
+    public createTextRun(text: string): TextRun {
+        const run = new TextRun(text);
+        this.addRun(run);
+        return run;
+    }
+
+    public createPictureRun(imageData: IData): PictureRun {
+        const run = new PictureRun(imageData);
+        this.addRun(run);
+        return run;
+    }
+
+    public heading1(): Paragraph {
+        this.properties.push(new Style("Heading1"));
+        return this;
+    }
+
+    public heading2(): Paragraph {
+        this.properties.push(new Style("Heading2"));
+        return this;
+    }
+
+    public heading3(): Paragraph {
+        this.properties.push(new Style("Heading3"));
+        return this;
+    }
+
+    public heading4(): Paragraph {
+        this.properties.push(new Style("Heading4"));
+        return this;
+    }
+
+    public heading5(): Paragraph {
+        this.properties.push(new Style("Heading5"));
+        return this;
+    }
+
+    public title(): Paragraph {
+        this.properties.push(new Style("Title"));
+        return this;
+    }
+
+    public center(): Paragraph {
+        this.properties.push(new Alignment("center"));
+        return this;
+    }
+
+    public left(): Paragraph {
+        this.properties.push(new Alignment("left"));
+        return this;
+    }
+
+    public right(): Paragraph {
+        this.properties.push(new Alignment("right"));
+        return this;
+    }
+
+    public justified(): Paragraph {
+        this.properties.push(new Alignment("both"));
+        return this;
+    }
+
+    public thematicBreak(): Paragraph {
+        this.properties.push(new ThematicBreak());
+        return this;
+    }
+
+    public pageBreak(): Paragraph {
+        this.root.push(new PageBreak());
+        return this;
+    }
+
+    public maxRightTabStop(): Paragraph {
+        this.properties.push(new MaxRightTabStop());
+        return this;
+    }
+
+    public leftTabStop(position: number): Paragraph {
+        this.properties.push(new LeftTabStop(position));
+        return this;
+    }
+
+    public rightTabStop(position: number): Paragraph {
+        this.properties.push(new RightTabStop(position));
+        return this;
+    }
+
+    public centerTabStop(position: number): Paragraph {
+        this.properties.push(new CenterTabStop(position));
+        return this;
+    }
+
+    public bullet(): Paragraph {
+        this.properties.push(new Style("ListParagraph"));
+        this.properties.push(new NumberProperties(1, 0));
+        return this;
+    }
+
+    public setNumbering(numbering: Num, indentLevel: number): Paragraph {
+        this.properties.push(new Style("ListParagraph"));
+        this.properties.push(new NumberProperties(numbering.id, indentLevel));
+        return this;
+    }
+
+    public style(styleId: string): Paragraph {
+        this.properties.push(new Style(styleId));
+        return this;
+    }
+
+    public indent(attrs: object): Paragraph {
+        this.properties.push(new Indent(attrs));
+        return this;
+    }
+
+    public spacing(params: ISpacingProperties): Paragraph {
+        this.properties.push(new Spacing(params));
+        return this;
+    }
+
+    public keepNext(): Paragraph {
+        this.properties.push(new KeepNext());
+        return this;
+    }
+
+    public keepLines(): Paragraph {
+        this.properties.push(new KeepLines());
+        return this;
+    }
+}

src/docx/paragraph/properties.ts

@@ -0,0 +1,13 @@
+// http://officeopenxml.com/WPparagraphProperties.php
+import { XmlComponent } from "../xml-components";
+
+export class ParagraphProperties extends XmlComponent {
+
+    constructor() {
+        super("w:pPr");
+    }
+
+    public push(item: XmlComponent): void {
+        this.root.push(item);
+    }
+}

src/docx/run/break.spec.ts

@@ -0,0 +1,19 @@
+import { assert } from "chai";
+
+import { Utility } from "../../tests/utility";
+import { Break } from "./break";
+
+describe("Break", () => {
+    let currentBreak: Break;
+
+    beforeEach(() => {
+        currentBreak = new Break();
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Break with correct root key", () => {
+            const newJson = Utility.jsonify(currentBreak);
+            assert.equal(newJson.rootKey, "w:br");
+        });
+    });
+});

src/docx/run/break.ts

@@ -0,0 +1,9 @@
+// http://officeopenxml.com/WPtextSpecialContent-break.php
+import { XmlComponent } from "../xml-components";
+
+export class Break extends XmlComponent {
+
+    constructor() {
+        super("w:br");
+    }
+}

src/docx/run/caps.ts

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

src/docx/run/formatting.ts

@@ -0,0 +1,114 @@
+import { Attributes, XmlComponent } from "../xml-components";
+export { Underline } from "./underline";
+export { SubScript, SuperScript } from "./script";
+export { RunFonts } from "./run-fonts";
+
+export class Bold extends XmlComponent {
+
+    constructor() {
+        super("w:b");
+        this.root.push(new Attributes({
+            val: true,
+        }));
+    }
+}
+
+export class Italics extends XmlComponent {
+
+    constructor() {
+        super("w:i");
+        this.root.push(new Attributes({
+            val: true,
+        }));
+    }
+}
+
+export class Caps extends XmlComponent {
+
+    constructor() {
+        super("w:caps");
+        this.root.push(new Attributes({
+            val: true,
+        }));
+    }
+}
+
+export class Color extends XmlComponent {
+
+    constructor(color: string) {
+        super("w:color");
+        this.root.push(new Attributes({
+            val: color,
+        }));
+    }
+}
+
+export class DoubleStrike extends XmlComponent {
+
+    constructor() {
+        super("w:dstrike");
+        this.root.push(new Attributes({
+            val: true,
+        }));
+    }
+}
+
+export class Emboss extends XmlComponent {
+
+    constructor() {
+        super("w:emboss");
+        this.root.push(new Attributes({
+            val: true,
+        }));
+    }
+}
+
+export class Imprint extends XmlComponent {
+
+    constructor() {
+        super("w:imprint");
+        this.root.push(new Attributes({
+            val: true,
+        }));
+    }
+}
+
+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");
+        this.root.push(new Attributes({
+            val: true,
+        }));
+    }
+}
+
+export class Strike extends XmlComponent {
+
+    constructor() {
+        super("w:strike");
+        this.root.push(new Attributes({
+            val: true,
+        }));
+    }
+}
+
+export class Size extends XmlComponent {
+
+    constructor(size: number) {
+        super("w:sz");
+        this.root.push(new Attributes({
+            val: size,
+        }));
+    }
+}

src/docx/run/index.ts

@@ -0,0 +1,3 @@
+export * from "./run";
+export * from "./text-run";
+export * from "./picture-run";

src/docx/run/picture-run.ts

@@ -0,0 +1,16 @@
+import { IData } from "../../media/data";
+import { Run } from "../run";
+import { Drawing } from "./run-components/drawing";
+
+export class PictureRun extends Run {
+
+    constructor(imageData: IData) {
+        super();
+
+        if (imageData === undefined) {
+            throw new Error("imageData cannot be undefined");
+        }
+
+        this.root.push(new Drawing(imageData));
+    }
+}

src/docx/run/properties.ts

@@ -0,0 +1,12 @@
+import { XmlComponent } from "../xml-components";
+
+export class RunProperties extends XmlComponent {
+
+    constructor() {
+        super("w:rPr");
+    }
+
+    public push(item: XmlComponent): void {
+        this.root.push(item);
+    }
+}

src/docx/run/run-components/drawing/drawing.spec.ts

@@ -0,0 +1,27 @@
+import { assert } from "chai";
+import * as fs from "fs";
+
+import { Utility } from "../../../../tests/utility";
+import { Drawing } from "./";
+
+describe("Drawing", () => {
+    let currentBreak: Drawing;
+
+    beforeEach(() => {
+        const path = "./demo/penguins.jpg";
+        currentBreak = new Drawing({
+            fileName: "test.jpg",
+            referenceId: 1,
+            stream: fs.createReadStream(path),
+            path: path,
+        });
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Drawing with correct root key", () => {
+            const newJson = Utility.jsonify(currentBreak);
+            assert.equal(newJson.rootKey, "w:drawing");
+            // console.log(JSON.stringify(newJson, null, 2));
+        });
+    });
+});

src/docx/run/run-components/drawing/index.ts

@@ -0,0 +1,16 @@
+import { IData } from "../../../../media/data";
+import { XmlComponent } from "../../../xml-components";
+import { Inline } from "./inline";
+
+export class Drawing extends XmlComponent {
+
+    constructor(imageData: IData) {
+        super("w:drawing");
+
+        if (imageData === undefined) {
+            throw new Error("imageData cannot be undefined");
+        }
+
+        this.root.push(new Inline(imageData.referenceId));
+    }
+}

src/docx/run/run-components/drawing/inline/graphic/graphic-data/index.ts

@@ -0,0 +1,10 @@
+import { XmlComponent } from "../../../../../../xml-components";
+import { Pic } from "./pic";
+
+export class GraphicData extends XmlComponent {
+
+    constructor(referenceId: number) {
+        super("a:graphicData");
+        this.root.push(new Pic(referenceId));
+    }
+}

src/docx/run/run-components/drawing/inline/graphic/graphic-data/pic/blip/blip-fill.ts

@@ -0,0 +1,14 @@
+import { XmlComponent } from "../../../../../../../../xml-components";
+import { Blip } from "./blip";
+import { SourceRectangle } from "./source-rectangle";
+import { Stretch } from "./stretch";
+
+export class BlipFill extends XmlComponent {
+
+    constructor(referenceId: number) {
+        super("pic:blipFill");
+        this.root.push(new Blip(referenceId));
+        this.root.push(new SourceRectangle());
+        this.root.push(new Stretch());
+    }
+}

src/docx/run/run-components/drawing/inline/graphic/graphic-data/pic/blip/blip.ts

@@ -0,0 +1,21 @@
+import { XmlAttributeComponent, XmlComponent } from "../../../../../../../../xml-components";
+
+interface IBlipProperties {
+    embed: string;
+}
+
+class BlipAttributes extends XmlAttributeComponent<IBlipProperties> {
+    protected xmlKeys = {
+        embed: "r:embed",
+    };
+}
+
+export class Blip extends XmlComponent {
+
+    constructor(referenceId: number) {
+        super("a:blip");
+        this.root.push(new BlipAttributes({
+            embed: `rId${referenceId}`,
+        }));
+    }
+}

src/docx/run/run-components/drawing/inline/graphic/graphic-data/pic/blip/source-rectangle.ts

@@ -0,0 +1,8 @@
+import { XmlComponent } from "../../../../../../../../xml-components";
+
+export class SourceRectangle extends XmlComponent {
+
+    constructor() {
+        super("a:srcRect");
+    }
+}

src/docx/run/run-components/drawing/inline/graphic/graphic-data/pic/blip/stretch.ts

@@ -0,0 +1,16 @@
+import { XmlComponent } from "../../../../../../../../xml-components";
+
+class FillRectangle extends XmlComponent {
+
+    constructor() {
+        super("a:fillRect");
+    }
+}
+
+export class Stretch extends XmlComponent {
+
+    constructor() {
+        super("a:stretch");
+        this.root.push(new FillRectangle());
+    }
+}

src/docx/run/run-components/drawing/inline/graphic/graphic-data/pic/index.ts

@@ -0,0 +1,10 @@
+import { XmlComponent } from "../../../../../../../xml-components";
+import { BlipFill } from "./blip/blip-fill";
+
+export class Pic extends XmlComponent {
+
+    constructor(referenceId: number) {
+        super("pic:pic");
+        this.root.push(new BlipFill(referenceId));
+    }
+}

src/docx/run/run-components/drawing/inline/graphic/index.ts

@@ -0,0 +1,23 @@
+import { XmlAttributeComponent, XmlComponent } from "../../../../../xml-components";
+import { GraphicData } from "./graphic-data";
+
+interface IGraphicProperties {
+    a: string;
+}
+
+class GraphicAttributes extends XmlAttributeComponent<IGraphicProperties> {
+    protected xmlKeys = {
+        a: "xmlns:a",
+    };
+}
+
+export class Graphic extends XmlComponent {
+
+    constructor(referenceId: number) {
+        super("a:graphic");
+        this.root.push(new GraphicAttributes({
+            a: "http://schemas.openxmlformats.org/drawingml/2006/main",
+        }));
+        this.root.push(new GraphicData(referenceId));
+    }
+}

src/docx/run/run-components/drawing/inline/index.ts

@@ -0,0 +1,10 @@
+import { XmlComponent } from "../../../../xml-components";
+import { Graphic } from "./graphic";
+
+export class Inline extends XmlComponent {
+
+    constructor(referenceId: number) {
+        super("wp:inline");
+        this.root.push(new Graphic(referenceId));
+    }
+}

src/docx/run/run-components/text.spec.ts

@@ -0,0 +1,23 @@
+import { expect } from "chai";
+
+import { Formatter } from "../../../export/formatter";
+import { Text } from "./text";
+
+describe("Text", () => {
+    describe("#constructor", () => {
+        it("creates an empty text run if no text is given", () => {
+            const t = new Text("");
+            const f = new Formatter().format(t);
+            expect(f).to.deep.equal({"w:t": [{_attr: {"xml:space": "preserve"}}]});
+        });
+
+        it("adds the passed in text to the component", () => {
+            const t = new Text(" this is\n text");
+            const f = new Formatter().format(t);
+            expect(f).to.deep.equal({"w:t": [
+                {_attr: {"xml:space": "preserve"}},
+                " this is\n text",
+            ]});
+        });
+    });
+});

src/docx/run/run-components/text.ts

@@ -0,0 +1,15 @@
+import { XmlAttributeComponent, XmlComponent } from "../../xml-components";
+
+class TextAttributes extends XmlAttributeComponent<{space: "default" | "preserve"}> {
+    protected xmlKeys = {space: "xml:space"};
+}
+
+export class Text extends XmlComponent {
+    constructor(text: string) {
+        super("w:t");
+        this.root.push(new TextAttributes({space: "preserve"}));
+        if (text) {
+            this.root.push(text);
+        }
+    }
+}

src/docx/run/run-fonts.spec.ts

@@ -0,0 +1,23 @@
+import { expect } from "chai";
+
+import { Formatter } from "../../export/formatter";
+import { RunFonts } from "./run-fonts";
+
+describe("RunFonts", () => {
+
+    describe("#constructor()", () => {
+        it("uses the font name for both ascii and hAnsi", () => {
+            const tree = new Formatter().format(new RunFonts("Times"));
+            expect(tree).to.deep.equal({
+                "w:rFonts": [{_attr: {"w:ascii": "Times", "w:hAnsi": "Times"}}],
+            });
+        });
+
+        it("uses hint if given", () => {
+            const tree = new Formatter().format(new RunFonts("Times", "default"));
+            expect(tree).to.deep.equal({
+                "w:rFonts": [{_attr: {"w:ascii": "Times", "w:hAnsi": "Times", "w:hint": "default"}}],
+            });
+        });
+    });
+});

src/docx/run/run-fonts.ts

@@ -0,0 +1,27 @@
+import { XmlAttributeComponent, XmlComponent } from "../xml-components";
+
+interface IRunFontAttributesProperties {
+    ascii: string;
+    hAnsi: string;
+    hint?: string;
+}
+
+class RunFontAttributes extends XmlAttributeComponent<IRunFontAttributesProperties> {
+    protected xmlKeys = {
+        ascii: "w:ascii",
+        hAnsi: "w:hAnsi",
+        hint: "w:hint",
+    };
+}
+
+export class RunFonts extends XmlComponent {
+
+    constructor(ascii: string, hint?: string) {
+        super("w:rFonts");
+        this.root.push(new RunFontAttributes({
+            ascii: ascii,
+            hAnsi: ascii,
+            hint: hint,
+        }));
+    }
+}

src/docx/run/run.spec.ts

@@ -0,0 +1,157 @@
+import { assert, expect } from "chai";
+
+import { Formatter } from "../../export/formatter";
+import { Utility } from "../../tests/utility";
+import { Run } from "./";
+
+describe("Run", () => {
+    let run: Run;
+
+    beforeEach(() => {
+        run = new Run();
+    });
+
+    describe("#bold()", () => {
+        it("it should add bold to the properties", () => {
+            run.bold();
+            const newJson = Utility.jsonify(run);
+            assert.equal(newJson.root[0].root[0].rootKey, "w:b");
+        });
+    });
+
+    describe("#italic()", () => {
+        it("it should add italics to the properties", () => {
+            run.italic();
+            const newJson = Utility.jsonify(run);
+            assert.equal(newJson.root[0].root[0].rootKey, "w:i");
+        });
+    });
+
+    describe("#underline()", () => {
+        it("it should add underline to the properties", () => {
+            run.underline();
+            const newJson = Utility.jsonify(run);
+            assert.equal(newJson.root[0].root[0].rootKey, "w:u");
+        });
+
+        it("should default to 'single' and no color", () => {
+            run.underline();
+            const tree = new Formatter().format(run);
+            expect(tree).to.deep.equal({
+                "w:r": [
+                    {"w:rPr": [{"w:u": [{_attr: {"w:val": "single"}}]}]},
+                ],
+            });
+        });
+
+        it("should set the style type and color if given", () => {
+            run.underline("double", "990011");
+            const tree = new Formatter().format(run);
+            expect(tree).to.deep.equal({
+                "w:r": [
+                    {"w:rPr": [{"w:u": [{_attr: {"w:val": "double", "w:color": "990011"}}]}]},
+                ],
+            });
+        });
+    });
+
+    describe("#smallCaps()", () => {
+        it("it should add smallCaps to the properties", () => {
+            run.smallCaps();
+            const newJson = Utility.jsonify(run);
+            assert.equal(newJson.root[0].root[0].rootKey, "w:smallCaps");
+        });
+    });
+
+    describe("#caps()", () => {
+        it("it should add caps to the properties", () => {
+            run.allCaps();
+            const newJson = Utility.jsonify(run);
+            assert.equal(newJson.root[0].root[0].rootKey, "w:caps");
+        });
+    });
+
+    describe("#strike()", () => {
+        it("it should add strike to the properties", () => {
+            run.strike();
+            const newJson = Utility.jsonify(run);
+            assert.equal(newJson.root[0].root[0].rootKey, "w:strike");
+        });
+    });
+
+    describe("#doubleStrike()", () => {
+        it("it should add caps to the properties", () => {
+            run.doubleStrike();
+            const newJson = Utility.jsonify(run);
+            assert.equal(newJson.root[0].root[0].rootKey, "w:dstrike");
+        });
+    });
+
+    describe("#break()", () => {
+        it("it should add break to the run", () => {
+            run.break();
+            const newJson = Utility.jsonify(run);
+            assert.equal(newJson.root[1].rootKey, "w:br");
+        });
+    });
+
+    describe("#tab()", () => {
+        it("it should add break to the run", () => {
+            run.tab();
+            const newJson = Utility.jsonify(run);
+            assert.equal(newJson.root[1].rootKey, "w:tab");
+        });
+    });
+
+    describe("#font()", () => {
+        it("should allow chaining calls", () => {
+            expect(run.font("Times")).to.equal(run);
+        });
+
+        it("should set the font as named", () => {
+            run.font("Times");
+            const tree = new Formatter().format(run);
+            expect(tree).to.deep.equal({
+                "w:r": [
+                    {"w:rPr": [{"w:rFonts": [{_attr: {"w:ascii": "Times", "w:hAnsi": "Times"}}]}]},
+                ],
+            });
+        });
+    });
+
+    describe("#color", () => {
+        it("should set the run to the color given", () => {
+            run.color("001122");
+            const tree = new Formatter().format(run);
+            expect(tree).to.deep.equal({
+                "w:r": [
+                    {"w:rPr": [{"w:color": [{_attr: {"w:val": "001122"}}]}]},
+                ],
+            });
+        });
+    });
+
+    describe("#size", () => {
+        it("should set the run to the given size", () => {
+            run.size(24);
+            const tree = new Formatter().format(run);
+            expect(tree).to.deep.equal({
+                "w:r": [
+                    {"w:rPr": [{"w:sz": [{_attr: {"w:val": 24}}]}]},
+                ],
+            });
+        });
+    });
+
+    describe("#style", () => {
+        it("should set the style to the given styleId", () => {
+            run.style("myRunStyle");
+            const tree = new Formatter().format(run);
+            expect(tree).to.deep.equal({
+                "w:r": [
+                    {"w:rPr": [{"w:rStyle": [{_attr: {"w:val": "myRunStyle"}}]}]},
+                ],
+            });
+        });
+    });
+});

src/docx/run/run.ts

@@ -0,0 +1,97 @@
+// http://officeopenxml.com/WPtext.php
+import { Break } from "./break";
+import { Caps, SmallCaps } from "./caps";
+import { Bold, Color, DoubleStrike, Italics, Size, Strike } from "./formatting";
+import { RunProperties } from "./properties";
+import { RunFonts } from "./run-fonts";
+import { SubScript, SuperScript } from "./script";
+import { Style } from "./style";
+import { Tab } from "./tab";
+import { Underline } from "./underline";
+
+import { XmlComponent } from "../xml-components";
+
+export class Run extends XmlComponent {
+    private properties: RunProperties;
+
+    constructor() {
+        super("w:r");
+        this.properties = new RunProperties();
+        this.root.push(this.properties);
+    }
+
+    public bold(): Run {
+        this.properties.push(new Bold());
+        return this;
+    }
+
+    public italic(): Run {
+        this.properties.push(new Italics());
+        return this;
+    }
+
+    public underline(underlineType?: string, color?: string): Run {
+        this.properties.push(new Underline(underlineType, color));
+        return this;
+    }
+
+    public color(color: string): Run {
+        this.properties.push(new Color(color));
+        return this;
+    }
+
+    public size(size: number): Run {
+        this.properties.push(new Size(size));
+        return this;
+    }
+
+    public break(): Run {
+        this.root.splice(1, 0, new Break());
+        return this;
+    }
+
+    public tab(): Run {
+        this.root.splice(1, 0, new Tab());
+        return this;
+    }
+
+    public smallCaps(): Run {
+        this.properties.push(new SmallCaps());
+        return this;
+    }
+
+    public allCaps(): Run {
+        this.properties.push(new Caps());
+        return this;
+    }
+
+    public strike(): Run {
+        this.properties.push(new Strike());
+        return this;
+    }
+
+    public doubleStrike(): Run {
+        this.properties.push(new DoubleStrike());
+        return this;
+    }
+
+    public subScript(): Run {
+        this.properties.push(new SubScript());
+        return this;
+    }
+
+    public superScript(): Run {
+        this.properties.push(new SuperScript());
+        return this;
+    }
+
+    public font(fontName: string): Run {
+        this.properties.push(new RunFonts(fontName));
+        return this;
+    }
+
+    public style(styleId: string): Run {
+        this.properties.push(new Style(styleId));
+        return this;
+    }
+}

src/docx/run/script.spec.ts

@@ -0,0 +1,50 @@
+import { assert } from "chai";
+
+import { Utility } from "../../tests/utility";
+import { SubScript, SuperScript } from "./script";
+
+describe("SubScript", () => {
+    let subScript: SubScript;
+
+    beforeEach(() => {
+        subScript = new SubScript();
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Sub Script with correct attributes", () => {
+            const newJson = Utility.jsonify(subScript);
+            const attributes = {
+                val: "subscript",
+            };
+            assert.equal(JSON.stringify(newJson.root[0].root), JSON.stringify(attributes));
+        });
+
+        it("should create a Sub Script with correct root key", () => {
+            const newJson = Utility.jsonify(subScript);
+            assert.equal(newJson.rootKey, "w:vertAlign");
+        });
+    });
+});
+
+describe("SuperScript", () => {
+    let superScript: SuperScript;
+
+    beforeEach(() => {
+        superScript = new SuperScript();
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Super Script with correct attributes", () => {
+            const newJson = Utility.jsonify(superScript);
+            const attributes = {
+                val: "superscript",
+            };
+            assert.equal(JSON.stringify(newJson.root[0].root), JSON.stringify(attributes));
+        });
+
+        it("should create a Super Script with correct root key", () => {
+            const newJson = Utility.jsonify(superScript);
+            assert.equal(newJson.rootKey, "w:vertAlign");
+        });
+    });
+});

src/docx/run/script.ts

@@ -0,0 +1,25 @@
+import { Attributes, XmlComponent } from "../xml-components";
+
+export abstract class VerticalAlign extends XmlComponent {
+
+    constructor(type: string) {
+        super("w:vertAlign");
+        this.root.push(new Attributes({
+            val: type,
+        }));
+    }
+}
+
+export class SuperScript extends VerticalAlign {
+
+    constructor() {
+        super("superscript");
+    }
+}
+
+export class SubScript extends VerticalAlign {
+
+    constructor() {
+        super("subscript");
+    }
+}

src/docx/run/strike.spec.ts

@@ -0,0 +1,34 @@
+import { assert } from "chai";
+
+import { Utility } from "../../tests/utility";
+import { DoubleStrike, Strike } from "./formatting";
+
+describe("Strike", () => {
+    let strike: Strike;
+
+    beforeEach(() => {
+        strike = new Strike();
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Strike with correct root key", () => {
+            const newJson = Utility.jsonify(strike);
+            assert.equal(newJson.rootKey, "w:strike");
+        });
+    });
+});
+
+describe("DoubleStrike", () => {
+    let strike: DoubleStrike;
+
+    beforeEach(() => {
+        strike = new DoubleStrike();
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Double Strike with correct root key", () => {
+            const newJson = Utility.jsonify(strike);
+            assert.equal(newJson.rootKey, "w:dstrike");
+        });
+    });
+});

src/docx/run/style.ts

@@ -0,0 +1,13 @@
+import { XmlAttributeComponent, XmlComponent } from "../xml-components";
+
+class StyleAttributes extends XmlAttributeComponent<{val: string}> {
+    protected xmlKeys = {val: "w:val"};
+}
+
+export class Style extends XmlComponent {
+
+    constructor(styleId: string) {
+        super("w:rStyle");
+        this.root.push(new StyleAttributes({val: styleId}));
+    }
+}

src/docx/run/tab.spec.ts

@@ -0,0 +1,19 @@
+import { assert } from "chai";
+
+import { Utility } from "../../tests/utility";
+import { Tab } from "./tab";
+
+describe("Tab", () => {
+    let tab: Tab;
+
+    beforeEach(() => {
+        tab = new Tab();
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Tab with correct root key", () => {
+            const newJson = Utility.jsonify(tab);
+            assert.equal(newJson.rootKey, "w:tab");
+        });
+    });
+});

src/docx/run/tab.ts

@@ -0,0 +1,8 @@
+import { XmlComponent } from "../xml-components";
+
+export class Tab extends XmlComponent {
+
+    constructor() {
+        super("w:tab");
+    }
+}

src/docx/run/text-run.spec.ts

@@ -0,0 +1,20 @@
+import { expect } from "chai";
+
+import { Formatter } from "../../export/formatter";
+import { TextRun } from "./text-run";
+
+describe("TextRun", () => {
+    let run: TextRun;
+
+    describe("#constructor()", () => {
+
+        it("should add text into run", () => {
+            run = new TextRun("test");
+            const f = new Formatter().format(run);
+            expect(f).to.deep.equal({"w:r": [
+                {"w:rPr": []},
+                {"w:t": [{_attr: {"xml:space": "preserve"}}, "test"]},
+            ]});
+        });
+    });
+});

src/docx/run/text-run.ts

@@ -0,0 +1,10 @@
+import { Run } from "../run";
+import { Text } from "./run-components/text";
+
+export class TextRun extends Run {
+
+    constructor(text: string) {
+        super();
+        this.root.push(new Text(text));
+    }
+}

src/docx/run/underline.spec.ts

@@ -0,0 +1,215 @@
+import { assert, expect } from "chai";
+
+import { Formatter } from "../../export/formatter";
+import { Utility } from "../../tests/utility";
+import * as u from "./underline";
+
+describe("Underline", () => {
+
+    describe("#constructor()", () => {
+
+        it("should create a new Underline object with u:u as the rootKey", () => {
+            const underline = new u.Underline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.rootKey, "w:u");
+        });
+
+        it("should default to 'single' and no color", () => {
+            const underline = new u.Underline();
+            const tree = new Formatter().format(underline);
+            expect(tree).to.deep.equal({
+                "w:u": [{_attr: {"w:val": "single"}}],
+            });
+        });
+
+        it("should use the given style type and color", () => {
+            const underline = new u.Underline("double", "FF00CC");
+            const tree = new Formatter().format(underline);
+            expect(tree).to.deep.equal({
+                "w:u": [{_attr: {"w:val": "double", "w:color": "FF00CC"}}],
+            });
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should have u:u as the rootKey", () => {
+            const underline = new u.DashDotDotHeavyUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.rootKey, "w:u");
+        });
+
+        it("should put value in attribute", () => {
+            const underline = new u.DashDotDotHeavyUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "dashDotDotHeavy");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.DashDotHeavyUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "dashDotHeavy");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.DashLongHeavyUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "dashLongHeavy");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.DashLongUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "dashLong");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.DashUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "dash");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.DotDashUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "dotDash");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.DotDotDashUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "dotDotDash");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.DottedHeavyUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "dottedHeavy");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.DottedUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "dotted");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.DoubleUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "double");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.SingleUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "single");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.ThickUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "thick");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.WaveUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "wave");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.WavyDoubleUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "wavyDouble");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.WavyHeavyUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "wavyHeavy");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.WordsUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "words");
+        });
+    });
+});

src/docx/run/underline.ts

@@ -0,0 +1,131 @@
+import { Attributes, XmlComponent } from "../xml-components";
+
+export abstract class BaseUnderline extends XmlComponent {
+
+    constructor(underlineType: string, color?: string) {
+        super("w:u");
+        this.root.push(new Attributes({
+            val: underlineType,
+            color: color,
+        }));
+    }
+}
+
+export class Underline extends BaseUnderline {
+
+    constructor(underlineType: string = "single", color?: string) {
+        super(underlineType, color);
+    }
+}
+
+export class DashUnderline extends BaseUnderline {
+
+    constructor() {
+        super("dash");
+    }
+}
+
+export class DashDotDotHeavyUnderline extends BaseUnderline {
+
+    constructor() {
+        super("dashDotDotHeavy");
+    }
+}
+
+export class DashDotHeavyUnderline extends BaseUnderline {
+
+    constructor() {
+        super("dashDotHeavy");
+    }
+}
+
+export class DashLongUnderline extends BaseUnderline {
+
+    constructor() {
+        super("dashLong");
+    }
+}
+
+export class DashLongHeavyUnderline extends BaseUnderline {
+
+    constructor() {
+        super("dashLongHeavy");
+    }
+}
+
+export class DotDashUnderline extends BaseUnderline {
+
+    constructor() {
+        super("dotDash");
+    }
+}
+
+export class DotDotDashUnderline extends BaseUnderline {
+
+    constructor() {
+        super("dotDotDash");
+    }
+}
+
+export class DottedUnderline extends BaseUnderline {
+
+    constructor() {
+        super("dotted");
+    }
+}
+
+export class DottedHeavyUnderline extends BaseUnderline {
+
+    constructor() {
+        super("dottedHeavy");
+    }
+}
+
+export class DoubleUnderline extends BaseUnderline {
+
+    constructor() {
+        super("double");
+    }
+}
+
+export class SingleUnderline extends BaseUnderline {
+
+    constructor() {
+        super("single");
+    }
+}
+
+export class ThickUnderline extends BaseUnderline {
+
+    constructor() {
+        super("thick");
+    }
+}
+
+export class WaveUnderline extends BaseUnderline {
+
+    constructor() {
+        super("wave");
+    }
+}
+
+export class WavyDoubleUnderline extends BaseUnderline {
+
+    constructor() {
+        super("wavyDouble");
+    }
+}
+
+export class WavyHeavyUnderline extends BaseUnderline {
+
+    constructor() {
+        super("wavyHeavy");
+    }
+}
+
+export class WordsUnderline extends BaseUnderline {
+
+    constructor() {
+        super("words");
+    }
+}

src/docx/table/grid.spec.ts

@@ -0,0 +1,38 @@
+import { expect } from "chai";
+
+import { Formatter } from "../../export/formatter";
+import { GridCol, TableGrid } from "./grid";
+
+describe("GridCol", () => {
+    describe("#constructor", () => {
+        it("sets the width attribute to the value given", () => {
+            const grid = new GridCol(1234);
+            const tree = new Formatter().format(grid);
+            expect(tree).to.deep.equal({
+                "w:gridCol": [{_attr: {"w:w": 1234}}],
+            });
+        });
+
+        it("does not set a width attribute if not given", () => {
+            const grid = new GridCol();
+            const tree = new Formatter().format(grid);
+            expect(tree).to.deep.equal({"w:gridCol": []});
+        });
+    });
+});
+
+describe("TableGrid", () => {
+    describe("#constructor", () => {
+        it("creates a column for each width given", () => {
+            const grid = new TableGrid([1234, 321, 123]);
+            const tree = new Formatter().format(grid);
+            expect(tree).to.deep.equal({
+                "w:tblGrid": [
+                    {"w:gridCol": [{_attr: {"w:w": 1234}}]},
+                    {"w:gridCol": [{_attr: {"w:w": 321}}]},
+                    {"w:gridCol": [{_attr: {"w:w": 123}}]},
+                ],
+            });
+        });
+    });
+});

src/docx/table/grid.ts

@@ -0,0 +1,21 @@
+import { XmlAttributeComponent, XmlComponent } from "../xml-components";
+
+export class TableGrid extends XmlComponent {
+    constructor(cols: number[]) {
+        super("w:tblGrid");
+        cols.forEach((col) => this.root.push(new GridCol(col)));
+    }
+}
+
+class GridColAttributes extends XmlAttributeComponent<{w: number}> {
+    protected xmlKeys = {w: "w:w"};
+}
+
+export class GridCol extends XmlComponent {
+    constructor(width?: number) {
+        super("w:gridCol");
+        if (width !== undefined) {
+            this.root.push(new GridColAttributes({w: width}));
+        }
+    }
+}

src/docx/table/index.ts

@@ -0,0 +1 @@
+export * from "./table";

src/docx/table/properties.spec.ts

@@ -0,0 +1,38 @@
+import { expect } from "chai";
+
+import { Formatter } from "../../export/formatter";
+import { TableProperties } from "./properties";
+
+describe("TableProperties", () => {
+    describe("#constructor", () => {
+        it("creates an initially empty property object", () => {
+            const tp = new TableProperties();
+            const tree = new Formatter().format(tp);
+            expect(tree).to.deep.equal({"w:tblPr": []});
+        });
+    });
+
+    describe("#setWidth", () => {
+        it("adds a table width property", () => {
+            const tp = new TableProperties().setWidth("dxa", 1234);
+            const tree = new Formatter().format(tp);
+            expect(tree).to.deep.equal({
+                "w:tblPr": [
+                    {"w:tblW": [{_attr: {"w:type": "dxa", "w:w": 1234}}]},
+                ],
+            });
+        });
+    });
+
+    describe("#fixedWidthLayout", () => {
+        it("sets the table to fixed width layout", () => {
+            const tp = new TableProperties().fixedWidthLayout();
+            const tree = new Formatter().format(tp);
+            expect(tree).to.deep.equal({
+                "w:tblPr": [
+                    {"w:tblLayout": [{_attr: {"w:type": "fixed"}}]},
+                ],
+            });
+        });
+    });
+});

src/docx/table/properties.ts

@@ -0,0 +1,48 @@
+import { XmlAttributeComponent, XmlComponent } from "../xml-components";
+
+export type WidthTypes = "dxa" | "pct" | "nil" | "auto";
+
+export class TableProperties extends XmlComponent {
+    constructor() {
+        super("w:tblPr");
+    }
+
+    public setWidth(type: WidthTypes, w: number | string): TableProperties {
+        this.root.push(new PreferredTableWidth(type, w));
+        return this;
+    }
+
+    public fixedWidthLayout(): TableProperties {
+        this.root.push(new TableLayout("fixed"));
+        return this;
+    }
+}
+
+interface ITableWidth {
+    type: WidthTypes;
+    w: number | string;
+}
+
+class TableWidthAttributes extends XmlAttributeComponent<ITableWidth> {
+    protected xmlKeys = {type: "w:type", w: "w:w"};
+}
+
+class PreferredTableWidth extends XmlComponent {
+    constructor(type: WidthTypes, w: number | string) {
+        super("w:tblW");
+        this.root.push(new TableWidthAttributes({type, w}));
+    }
+}
+
+type TableLayoutOptions = "autofit" | "fixed";
+
+class TableLayoutAttributes extends XmlAttributeComponent<{type: TableLayoutOptions}> {
+    protected xmlKeys = {type: "w:type"};
+}
+
+class TableLayout extends XmlComponent {
+    constructor(type: TableLayoutOptions) {
+        super("w:tblLayout");
+        this.root.push(new TableLayoutAttributes({type}));
+    }
+}

src/docx/table/table.spec.ts

@@ -0,0 +1,190 @@
+/* tslint:disable:no-unused-expression */
+import { expect } from "chai";
+
+import { Formatter } from "../../export/formatter";
+import { Paragraph } from "../paragraph";
+import { Table } from "./";
+
+describe("Table", () => {
+    describe("#constructor", () => {
+        it("creates a table with the correct number of rows and columns", () => {
+            const table = new Table(3, 2);
+            const tree = new Formatter().format(table);
+            const cell = {"w:tc": [{"w:tcPr": []}, {"w:p": [{"w:pPr": []}]}]};
+            expect(tree).to.deep.equal({
+                "w:tbl": [
+                    {"w:tblPr": []},
+                    {"w:tblGrid": [
+                        {"w:gridCol": [{_attr: {"w:w": 1}}]},
+                        {"w:gridCol": [{_attr: {"w:w": 1}}]},
+                    ]},
+                    {"w:tr": [{"w:trPr": []}, cell, cell]},
+                    {"w:tr": [{"w:trPr": []}, cell, cell]},
+                    {"w:tr": [{"w:trPr": []}, cell, cell]},
+                ],
+            });
+        });
+    });
+
+    describe("#getRow and Row#getCell", () => {
+        it("returns the correct row", () => {
+            const table = new Table(2, 2);
+            table.getRow(0).getCell(0).addContent(new Paragraph("A1"));
+            table.getRow(0).getCell(1).addContent(new Paragraph("B1"));
+            table.getRow(1).getCell(0).addContent(new Paragraph("A2"));
+            table.getRow(1).getCell(1).addContent(new Paragraph("B2"));
+            const tree = new Formatter().format(table);
+            const cell = (c) => ({"w:tc": [
+                {"w:tcPr": []},
+                {"w:p": [
+                    {"w:pPr": []},
+                    {"w:r": [{"w:rPr": []}, {"w:t": [{_attr: {"xml:space": "preserve"}}, c]}]},
+                ]},
+            ]});
+            expect(tree).to.deep.equal({
+                "w:tbl": [
+                    {"w:tblPr": []},
+                    {"w:tblGrid": [
+                        {"w:gridCol": [{_attr: {"w:w": 1}}]},
+                        {"w:gridCol": [{_attr: {"w:w": 1}}]},
+                    ]},
+                    {"w:tr": [{"w:trPr": []}, cell("A1"), cell("B1")]},
+                    {"w:tr": [{"w:trPr": []}, cell("A2"), cell("B2")]},
+                ],
+            });
+        });
+    });
+
+    describe("#getCell", () => {
+        it("returns the correct cell", () => {
+            const table = new Table(2, 2);
+            table.getCell(0, 0).addContent(new Paragraph("A1"));
+            table.getCell(0, 1).addContent(new Paragraph("B1"));
+            table.getCell(1, 0).addContent(new Paragraph("A2"));
+            table.getCell(1, 1).addContent(new Paragraph("B2"));
+            const tree = new Formatter().format(table);
+            const cell = (c) => ({"w:tc": [
+                {"w:tcPr": []},
+                {"w:p": [
+                    {"w:pPr": []},
+                    {"w:r": [{"w:rPr": []}, {"w:t": [{_attr: {"xml:space": "preserve"}}, c]}]},
+                ]},
+            ]});
+            expect(tree).to.deep.equal({
+                "w:tbl": [
+                    {"w:tblPr": []},
+                    {"w:tblGrid": [
+                        {"w:gridCol": [{_attr: {"w:w": 1}}]},
+                        {"w:gridCol": [{_attr: {"w:w": 1}}]},
+                    ]},
+                    {"w:tr": [{"w:trPr": []}, cell("A1"), cell("B1")]},
+                    {"w:tr": [{"w:trPr": []}, cell("A2"), cell("B2")]},
+                ],
+            });
+        });
+    });
+
+    describe("#setWidth", () => {
+        it("sets the preferred width on the table", () => {
+            const table = new Table(2, 2).setWidth("pct", 1000);
+            const tree = new Formatter().format(table);
+            expect(tree).to.have.property("w:tbl").which.is.an("array").with.has.length.at.least(1);
+            expect(tree["w:tbl"][0]).to.deep.equal({
+                "w:tblPr": [
+                    {"w:tblW": [{_attr: {"w:type": "pct", "w:w": 1000}}]},
+                ],
+            });
+        });
+    });
+
+    describe("#fixedWidthLayout", () => {
+        it("sets the table to fixed width layout", () => {
+            const table = new Table(2, 2).fixedWidthLayout();
+            const tree = new Formatter().format(table);
+            expect(tree).to.have.property("w:tbl").which.is.an("array").with.has.length.at.least(1);
+            expect(tree["w:tbl"][0]).to.deep.equal({
+                "w:tblPr": [
+                    {"w:tblLayout": [{_attr: {"w:type": "fixed"}}]},
+                ],
+            });
+        });
+    });
+
+    describe("Cell", () => {
+        describe("#prepForXml", () => {
+            it("inserts a paragraph at the end of the cell if it is empty", () => {
+                const table = new Table(1, 1);
+                const tree = new Formatter().format(table);
+                expect(tree).to.have.property("w:tbl").which.is.an("array");
+                const row = tree["w:tbl"].find((x) => x["w:tr"]);
+                expect(row).not.to.be.undefined;
+                expect(row["w:tr"]).to.be.an("array").which.has.length.at.least(1);
+                expect(row["w:tr"].find((x) => x["w:tc"])).to.deep.equal({
+                    "w:tc": [
+                        {"w:tcPr": []},
+                        {"w:p": [{"w:pPr": []}]},
+                    ],
+                });
+            });
+
+            it("inserts a paragraph at the end of the cell even if it has a child table", () => {
+                const parentTable = new Table(1, 1);
+                parentTable.getCell(0, 0).addContent(new Table(1, 1));
+                const tree = new Formatter().format(parentTable);
+                expect(tree).to.have.property("w:tbl").which.is.an("array");
+                const row = tree["w:tbl"].find((x) => x["w:tr"]);
+                expect(row).not.to.be.undefined;
+                expect(row["w:tr"]).to.be.an("array").which.has.length.at.least(1);
+                const cell = row["w:tr"].find((x) => x["w:tc"]);
+                expect(cell).not.to.be.undefined;
+                expect(cell["w:tc"][cell["w:tc"].length - 1]).to.deep.equal({
+                    "w:p": [{"w:pPr": []}],
+                });
+            });
+
+            it("does not insert a paragraph if it already ends with one", () => {
+                const parentTable = new Table(1, 1);
+                parentTable.getCell(0, 0).addContent(new Paragraph("Hello"));
+                const tree = new Formatter().format(parentTable);
+                expect(tree).to.have.property("w:tbl").which.is.an("array");
+                const row = tree["w:tbl"].find((x) => x["w:tr"]);
+                expect(row).not.to.be.undefined;
+                expect(row["w:tr"]).to.be.an("array").which.has.length.at.least(1);
+                expect(row["w:tr"].find((x) => x["w:tc"])).to.deep.equal({
+                    "w:tc": [
+                        {"w:tcPr": []},
+                        {"w:p": [
+                            {"w:pPr": []},
+                            {"w:r": [{"w:rPr": []}, {"w:t": [{_attr: {"xml:space": "preserve"}}, "Hello"]}]},
+                        ]},
+                    ],
+                });
+            });
+        });
+
+        describe("#createParagraph", () => {
+            it("inserts a new paragraph in the cell", () => {
+                const table = new Table(1, 1);
+                const para = table.getCell(0, 0).createParagraph("Test paragraph");
+                expect(para).to.be.an.instanceof(Paragraph);
+                const tree = new Formatter().format(table);
+                expect(tree).to.have.property("w:tbl").which.is.an("array");
+                const row = tree["w:tbl"].find((x) => x["w:tr"]);
+                expect(row).not.to.be.undefined;
+                expect(row["w:tr"]).to.be.an("array").which.has.length.at.least(1);
+                expect(row["w:tr"].find((x) => x["w:tc"])).to.deep.equal({
+                    "w:tc": [
+                        {"w:tcPr": []},
+                        {"w:p": [
+                            {"w:pPr": []},
+                            {"w:r": [
+                                {"w:rPr": []},
+                                {"w:t": [{_attr: {"xml:space": "preserve"}}, "Test paragraph"]},
+                            ]},
+                        ]},
+                    ],
+                });
+            });
+        });
+    });
+});

src/docx/table/table.ts

@@ -0,0 +1,123 @@
+import { Paragraph } from "../paragraph";
+import { XmlComponent } from "../xml-components";
+import { IXmlableObject } from "../xml-components/xmlable-object";
+import { TableGrid } from "./grid";
+import { TableProperties, WidthTypes } from "./properties";
+
+export class Table extends XmlComponent {
+    private properties: TableProperties;
+    private rows: TableRow[];
+    private grid: TableGrid;
+
+    constructor(rows: number, cols: number) {
+        super("w:tbl");
+        this.properties = new TableProperties();
+        this.root.push(this.properties);
+
+        const gridCols: number[] = [];
+        for (let i = 0; i < cols; i++) {
+            /*
+              0-width columns don't get rendered correctly, so we need
+              to give them some value. A reasonable default would be
+              ~6in / numCols, but if we do that it becomes very hard
+              to resize the table using setWidth, unless the layout
+              algorithm is set to 'fixed'. Instead, the approach here
+              means even in 'auto' layout, setting a width on the
+              table will make it look reasonable, as the layout
+              algorithm will expand columns to fit its content
+             */
+            gridCols.push(1);
+        }
+        this.grid = new TableGrid(gridCols);
+        this.root.push(this.grid);
+
+        this.rows = [];
+        for (let i = 0; i < rows; i++) {
+            const cells: TableCell[] = [];
+            for (let j = 0; j < cols; j++) {
+                cells.push(new TableCell());
+            }
+            const row = new TableRow(cells);
+            this.rows.push(row);
+            this.root.push(row);
+        }
+    }
+
+    public getRow(ix: number): TableRow {
+        return this.rows[ix];
+    }
+
+    public getCell(row: number, col: number): TableCell {
+        return this.getRow(row).getCell(col);
+    }
+
+    public setWidth(type: WidthTypes, width: number | string): Table {
+        this.properties.setWidth(type, width);
+        return this;
+    }
+
+    public fixedWidthLayout(): Table {
+        this.properties.fixedWidthLayout();
+        return this;
+    }
+}
+
+export class TableRow extends XmlComponent {
+    private properties: TableRowProperties;
+    private cells: TableCell[];
+
+    constructor(cells: TableCell[]) {
+        super("w:tr");
+        this.properties = new TableRowProperties();
+        this.root.push(this.properties);
+        this.cells = cells;
+        cells.forEach((c) => this.root.push(c));
+    }
+
+    public getCell(ix: number): TableCell {
+        return this.cells[ix];
+    }
+}
+
+export class TableRowProperties extends XmlComponent {
+    constructor() {
+        super("w:trPr");
+    }
+}
+
+export class TableCell extends XmlComponent {
+    private properties: TableCellProperties;
+
+    constructor() {
+        super("w:tc");
+        this.properties = new TableCellProperties();
+        this.root.push(this.properties);
+    }
+
+    public addContent(content: Paragraph | Table): TableCell {
+        this.root.push(content);
+        return this;
+    }
+
+    public prepForXml(): IXmlableObject {
+        // Cells must end with a paragraph
+        const retval = super.prepForXml();
+        const content = retval["w:tc"];
+        if (!content[content.length - 1]["w:p"]) {
+            content.push(new Paragraph().prepForXml());
+        }
+        return retval;
+    }
+
+    public createParagraph(text?: string): Paragraph {
+        const para = new Paragraph(text);
+        this.addContent(para);
+        return para;
+    }
+}
+
+export class TableCellProperties extends XmlComponent {
+    constructor() {
+        super("w:tcPr");
+    }
+}

src/docx/xml-components/attribute.spec.ts

@@ -0,0 +1,26 @@
+import { assert } from "chai";
+
+import { Attributes } from "./";
+
+describe("Attribute", () => {
+    describe("#constructor()", () => {
+
+        it("should have val as defined with populated constructor", () => {
+            const newAttrs = new Attributes({
+                val: "test",
+            });
+            const stringifiedJson = JSON.stringify(newAttrs);
+            const newJson = JSON.parse(stringifiedJson);
+            assert.equal(newJson.root.val, "test");
+        });
+
+        it("should have space value as defined with populated constructor", () => {
+            const newAttrs = new Attributes({
+                space: "spaceTest",
+            });
+            const stringifiedJson = JSON.stringify(newAttrs);
+            const newJson = JSON.parse(stringifiedJson);
+            assert.equal(newJson.root.space, "spaceTest");
+        });
+    });
+});

src/docx/xml-components/attributes.ts

@@ -0,0 +1,47 @@
+import { XmlAttributeComponent } from "./default-attributes";
+
+export interface IAttributesProperties {
+    val?: string | number | boolean;
+    color?: string;
+    space?: string;
+    sz?: string;
+    type?: string;
+    rsidR?: string;
+    rsidRPr?: string;
+    rsidSect?: string;
+    w?: string;
+    h?: string;
+    top?: string;
+    right?: string;
+    bottom?: string;
+    left?: string;
+    header?: string;
+    footer?: string;
+    gutter?: string;
+    linePitch?: string;
+    pos?: string | number; // Little strange. Perhaps it is normal. Need to clarify in the spec.
+}
+
+export class Attributes extends XmlAttributeComponent<IAttributesProperties> {
+    protected xmlKeys = {
+        val: "w:val",
+        color: "w:color",
+        space: "w:space",
+        sz: "w:sz",
+        type: "w:type",
+        rsidR: "w:rsidR",
+        rsidRPr: "w:rsidRPr",
+        rsidSect: "w:rsidSect",
+        w: "w:w",
+        h: "w:h",
+        top: "w:top",
+        right: "w:right",
+        bottom: "w:bottom",
+        left: "w:left",
+        header: "w:header",
+        footer: "w:footer",
+        gutter: "w:gutter",
+        linePitch: "w:linePitch",
+        pos: "w:pos",
+    };
+}

src/docx/xml-components/base.ts

@@ -0,0 +1,11 @@
+import { IXmlableObject } from "./xmlable-object";
+
+export abstract class BaseXmlComponent {
+    protected rootKey: string;
+
+    constructor(rootKey: string) {
+        this.rootKey = rootKey;
+    }
+
+    public abstract prepForXml(): IXmlableObject;
+}

src/docx/xml-components/default-attributes.ts

@@ -0,0 +1,26 @@
+import { BaseXmlComponent } from "./base";
+import { IXmlableObject } from "./xmlable-object";
+
+export type AttributeMap<T> = {[P in keyof T]: string};
+
+export abstract class XmlAttributeComponent<T> extends BaseXmlComponent {
+    protected root: T;
+    protected xmlKeys: AttributeMap<T>;
+
+    constructor(properties: T) {
+        super("_attr");
+        this.root = properties;
+    }
+
+    public prepForXml(): IXmlableObject {
+        const attrs = {};
+        Object.keys(this.root).forEach((key) => {
+            const value = this.root[key];
+            if (value !== undefined) {
+                const newKey = this.xmlKeys[key];
+                attrs[newKey] = value;
+            }
+        });
+        return {_attr: attrs};
+    }
+}

src/docx/xml-components/index.ts

@@ -0,0 +1,3 @@
+export * from "./xml-component";
+export * from "./attributes";
+export * from "./default-attributes";

src/docx/xml-components/xml-component.spec.ts

@@ -0,0 +1,24 @@
+import { assert } from "chai";
+
+import { Utility } from "../../tests/utility";
+import { XmlComponent } from "./";
+
+class TestComponent extends XmlComponent {
+
+}
+
+describe("XmlComponent", () => {
+    let xmlComponent: TestComponent;
+
+    beforeEach(() => {
+        xmlComponent = new TestComponent("w:test");
+    });
+
+    describe("#constructor()", () => {
+
+        it("should create an Xml Component which has the correct rootKey", () => {
+            const newJson = Utility.jsonify(xmlComponent);
+            assert.equal(newJson.rootKey, "w:test");
+        });
+    });
+});

src/docx/xml-components/xml-component.ts

@@ -0,0 +1,24 @@
+import { BaseXmlComponent } from "./base";
+import { IXmlableObject } from "./xmlable-object";
+export { BaseXmlComponent };
+
+export abstract class XmlComponent extends BaseXmlComponent {
+    protected root: Array<BaseXmlComponent | string>;
+
+    constructor(rootKey: string) {
+        super(rootKey);
+        this.root = new Array<BaseXmlComponent>();
+    }
+
+    public prepForXml(): IXmlableObject {
+        const children = this.root.map((comp) => {
+            if (comp instanceof BaseXmlComponent) {
+                return comp.prepForXml();
+            }
+            return comp;
+        }).filter((comp) => comp); // Exclude null, undefined, and empty strings
+        return {
+            [this.rootKey]: children,
+        };
+    }
+}

src/docx/xml-components/xmlable-object.ts

@@ -0,0 +1,3 @@
+export interface IXmlableObject extends Object {
+    _attr?: { [key: string]: (string | number | boolean) };
+}

src/export/formatter.spec.ts

@@ -0,0 +1,78 @@
+import { assert } from "chai";
+
+import * as docx from "../docx";
+import { Attributes } from "../docx/xml-components";
+import { Formatter } from "../export/formatter";
+import { Properties } from "../properties";
+import { Utility } from "../tests/utility";
+
+describe("Formatter", () => {
+    let formatter: Formatter;
+
+    beforeEach(() => {
+        formatter = new Formatter();
+    });
+
+    describe("#format()", () => {
+        it("should format simple paragraph", () => {
+            const paragraph = new docx.Paragraph();
+            const newJson = formatter.format(paragraph);
+            assert.isDefined(newJson["w:p"]);
+        });
+
+        it("should remove xmlKeys", () => {
+            const paragraph = new docx.Paragraph();
+            const newJson = formatter.format(paragraph);
+            const stringifiedJson = JSON.stringify(newJson);
+            assert(stringifiedJson.indexOf("xmlKeys") < 0);
+        });
+
+        it("should format simple paragraph with bold text", () => {
+            const paragraph = new docx.Paragraph();
+            paragraph.addRun(new docx.TextRun("test").bold());
+            const newJson = formatter.format(paragraph);
+            assert.isDefined(newJson["w:p"][1]["w:r"][0]["w:rPr"][0]["w:b"][0]._attr["w:val"]);
+        });
+
+        it("should format attributes (rsidSect)", () => {
+            const attributes = new Attributes({
+                rsidSect: "test2",
+            });
+            let newJson = formatter.format(attributes);
+            newJson = Utility.jsonify(newJson);
+            if (newJson._attr === undefined) {
+                assert.fail();
+                return;
+            }
+            assert.isDefined(newJson._attr["w:rsidSect"]);
+        });
+
+        it("should format attributes (val)", () => {
+            const attributes = new Attributes({
+                val: "test",
+            });
+            let newJson = formatter.format(attributes);
+            newJson = Utility.jsonify(newJson);
+            if (newJson._attr === undefined) {
+                assert.fail();
+                return;
+            }
+            assert.isDefined(newJson._attr["w:val"]);
+        });
+
+        it("should should change 'p' tag into 'w:p' tag", () => {
+            const paragraph = new docx.Paragraph();
+            const newJson = formatter.format(paragraph);
+            assert.isDefined(newJson["w:p"]);
+        });
+
+        it("should format Properties object correctly", () => {
+            const properties = new Properties({
+                title: "test document",
+                creator: "Dolan",
+            });
+            const newJson = formatter.format(properties);
+            assert.isDefined(newJson["cp:coreProperties"]);
+        });
+    });
+});

src/export/formatter.ts

@@ -0,0 +1,8 @@
+import { BaseXmlComponent } from "../docx/xml-components";
+import { IXmlableObject } from "../docx/xml-components/xmlable-object";
+
+export class Formatter {
+    public format(input: BaseXmlComponent): IXmlableObject {
+        return input.prepForXml();
+    }
+}

src/export/index.ts

@@ -0,0 +1,3 @@
+export * from "./packer/local";
+export * from "./packer/express";
+export * from "./packer/packer";

src/export/packer/compiler.ts

@@ -0,0 +1,99 @@
+import * as archiver from "archiver";
+import * as express from "express";
+import * as fs from "fs";
+import * as path from "path";
+import * as xml from "xml";
+
+import { Document } from "../../docx";
+import { Media } from "../../media";
+import { Numbering } from "../../numbering";
+import { Properties } from "../../properties";
+import { Styles } from "../../styles";
+import { DefaultStylesFactory } from "../../styles/factory";
+import { Formatter } from "../formatter";
+
+const TEMPLATE_PATH = path.resolve(__dirname, "../../../template");
+
+export class Compiler {
+    protected archive: archiver.Archiver;
+    private formatter: Formatter;
+    private style: Styles;
+
+    constructor(
+        protected document: Document,
+        style?: Styles,
+        private properties: Properties = new Properties({
+            creator: "Un-named",
+            revision: "1",
+            lastModifiedBy: "Un-named",
+        }),
+        private numbering: Numbering = new Numbering(),
+        private media: Media = new Media(),
+    ) {
+        this.formatter = new Formatter();
+        this.archive = archiver.create("zip", {});
+
+        if (style) {
+            this.style = style;
+        } else {
+            const stylesFactory = new DefaultStylesFactory();
+            this.style = stylesFactory.newInstance();
+        }
+
+        this.archive.on("error", (err) => {
+            throw err;
+        });
+    }
+
+    public async compile(output: fs.WriteStream | express.Response): Promise<void> {
+        this.archive.pipe(output);
+        this.archive.glob("**", {
+            cwd: TEMPLATE_PATH,
+        });
+
+        this.archive.glob("**/.rels", {
+            cwd: TEMPLATE_PATH,
+        });
+
+        const xmlDocument = xml(this.formatter.format(this.document));
+        const xmlStyles = xml(this.formatter.format(this.style));
+        const xmlProperties = xml(this.formatter.format(this.properties), {
+            declaration: {
+                standalone: "yes",
+                encoding: "UTF-8",
+            },
+        });
+        const xmlNumbering = xml(this.formatter.format(this.numbering));
+
+        this.archive.append(xmlDocument, {
+            name: "word/document.xml",
+        });
+
+        this.archive.append(xmlStyles, {
+            name: "word/styles.xml",
+        });
+
+        this.archive.append(xmlProperties, {
+            name: "docProps/core.xml",
+        });
+
+        this.archive.append(xmlNumbering, {
+            name: "word/numbering.xml",
+        });
+
+        for (const data of this.media.array) {
+            this.archive.append(data.stream, {
+                name: `media/${data.fileName}`,
+            });
+        }
+
+        this.archive.finalize();
+
+        return new Promise<void>((resolve) => {
+            output.on("close", () => {
+                resolve();
+            });
+        });
+
+    }
+}

src/export/packer/express.ts

@@ -0,0 +1,31 @@
+import * as express from "express";
+
+import { Document } from "../../docx/document";
+import { Media } from "../../media";
+import { Numbering } from "../../numbering";
+import { Properties } from "../../properties";
+import { Styles } from "../../styles";
+import { Compiler } from "./compiler";
+import { IPacker } from "./packer";
+
+export class ExpressPacker implements IPacker {
+    private res: express.Response;
+    private packer: Compiler;
+
+    constructor(document: Document, res: express.Response, styles?: Styles, properties?: Properties, numbering?: Numbering, media?: Media) {
+        this.packer = new Compiler(document, styles, properties, numbering, media);
+
+        this.res = res;
+
+        this.res.on("close", () => {
+            return res.status(200).send("OK").end();
+        });
+    }
+
+    public async pack(name: string): Promise<void> {
+        name = name.replace(/.docx$/, "");
+
+        this.res.attachment(`${name}.docx`);
+        await this.packer.compile(this.res);
+    }
+}

src/export/packer/local.spec.ts

@@ -0,0 +1,47 @@
+/* tslint:disable:typedef space-before-function-paren */
+import * as fs from "fs";
+
+import { Document } from "../../docx/document";
+import { Paragraph } from "../../docx/paragraph";
+import { LocalPacker } from "../../export/packer/local";
+import { Properties } from "../../properties";
+import { DefaultStylesFactory } from "../../styles/factory";
+
+describe("LocalPacker", () => {
+    let packer: LocalPacker;
+    let stylesFactory: DefaultStylesFactory;
+
+    beforeEach(() => {
+        const document = new Document();
+        const paragraph = new Paragraph("test text");
+        const heading = new Paragraph("Hello world").heading1();
+        document.addParagraph(new Paragraph("title").title());
+        document.addParagraph(heading);
+        document.addParagraph(new Paragraph("heading 2").heading2());
+        document.addParagraph(paragraph);
+        const properties = new Properties({
+            creator: "Dolan Miu",
+            revision: "1",
+            lastModifiedBy: "Dolan Miu",
+        });
+        stylesFactory = new DefaultStylesFactory();
+        packer = new LocalPacker(document, stylesFactory.newInstance(), properties);
+    });
+
+    describe("#pack()", () => {
+        it("should create a standard docx file", async function () {
+            this.timeout(99999999);
+            await packer.pack("build-tests/tests/test");
+            fs.statSync("build-tests/tests/test.docx");
+        });
+    });
+
+    describe("#packPdf", () => {
+        it("should create a standard PDF file", async function () {
+            this.timeout(99999999);
+
+            await packer.packPdf("build-tests/tests/pdf-test");
+            fs.statSync("build-tests/tests/pdf-test.pdf");
+        });
+    });
+});

src/export/packer/local.ts

@@ -0,0 +1,52 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+import { Document } from "../../docx/document";
+import { Media } from "../../media";
+import { Numbering } from "../../numbering";
+import { Properties } from "../../properties";
+import { Styles } from "../../styles";
+import { Compiler } from "./compiler";
+import { IPacker } from "./packer";
+import { PdfConvertWrapper } from "./pdf-convert-wrapper";
+
+export class LocalPacker implements IPacker {
+    private stream: fs.WriteStream;
+    private pdfConverter: PdfConvertWrapper;
+    private packer: Compiler;
+
+    constructor(document: Document, styles?: Styles, properties?: Properties, numbering?: Numbering, media?: Media) {
+        this.pdfConverter = new PdfConvertWrapper();
+        this.packer = new Compiler(document, styles, properties, numbering, media);
+    }
+
+    public async pack(filePath: string): Promise<void> {
+        filePath = filePath.replace(/.docx$/, "");
+
+        this.stream = fs.createWriteStream(`${filePath}.docx`);
+        await this.packer.compile(this.stream);
+    }
+
+    public async packPdf(filePath: string): Promise<void> {
+        filePath = filePath.replace(/.pdf$/, "");
+
+        const fileName = path.basename(filePath, path.extname(filePath));
+        const tempPath = path.join(os.tmpdir(), `${fileName}.docx`);
+        this.stream = fs.createWriteStream(tempPath);
+        await this.packer.compile(this.stream);
+        const text = await this.pdfConverter.convert(tempPath);
+        // const writeFile = util.promisify(fs.writeFile); --use this in future, in 3 years time. Only in node 8
+        // return writeFile(`${filePath}.pdf`, text);
+        return new Promise<void>((resolve, reject) => {
+            fs.writeFile(`${filePath}.pdf`, text, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+            });
+        });
+
+    }
+}

src/export/packer/packer.ts

@@ -0,0 +1,3 @@
+export interface IPacker {
+    pack(path: string): void;
+}

src/export/packer/pdf-convert-wrapper.ts

@@ -0,0 +1,34 @@
+/* tslint:disable:object-literal-key-quotes */
+// This tslint disable is needed, or it simply won't work
+import * as fs from "fs";
+import * as request from "request-promise";
+
+export interface IConvertOutput {
+    data: string;
+}
+
+export class PdfConvertWrapper {
+    public convert(filePath: string): request.RequestPromise {
+        return request.post({
+            url: "http://mirror1.convertonlinefree.com",
+            encoding: null,
+            headers: {
+                "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/37.0.2062.94 Safari/537.36",
+            },
+            formData: {
+                "__EVENTTARGET": "",
+                "__EVENTARGUMENT": "",
+                "__VIEWSTATE": "",
+                "ctl00$MainContent$fu": {
+                    value: fs.readFileSync(filePath),
+                    options: {
+                        filename: "output.docx",
+                        contentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+                    },
+                },
+                "ctl00$MainContent$btnConvert": "Convert",
+                "ctl00$MainContent$fuZip": "",
+            },
+        });
+    }
+}

src/index.ts

@@ -0,0 +1,6 @@
+export * from "./docx";
+export * from "./export";
+export { Numbering } from "./numbering";
+export { Styles } from "./styles";
+export { Media } from "./media";
+export * from "./export";

src/media/data.ts

@@ -0,0 +1,8 @@
+import * as fs from "fs";
+
+export interface IData {
+    referenceId: number;
+    stream: fs.ReadStream;
+    path: string;
+    fileName: string;
+}

src/media/index.ts

@@ -0,0 +1,40 @@
+import * as fs from "fs";
+import * as path from "path";
+import { IData } from "./data";
+
+export class Media {
+    private map: Map<string, IData>;
+
+    constructor() {
+        this.map = new Map<string, IData>();
+    }
+
+    public getMedia(key: string): IData {
+        const data = this.map.get(key);
+
+        if (data === undefined) {
+            throw new Error(`Cannot find image with the key ${key}`);
+        }
+
+        return data;
+    }
+
+    public addMedia(key: string, filePath: string): void {
+        this.map.set(key, {
+            referenceId: this.map.values.length,
+            stream: fs.createReadStream(filePath),
+            path: filePath,
+            fileName: path.basename(filePath),
+        });
+    }
+
+    public get array(): IData[] {
+        const array = new Array<IData>();
+
+        this.map.forEach((data) => {
+            array.push(data);
+        });
+
+        return array;
+    }
+}

src/numbering/abstract-numbering.ts

@@ -0,0 +1,39 @@
+import { XmlAttributeComponent, XmlComponent } from "../docx/xml-components";
+import { Level } from "./level";
+import { MultiLevelType } from "./multi-level-type";
+
+interface IAbstractNumberingAttributesProperties {
+    abstractNumId?: number;
+    restartNumberingAfterBreak?: number;
+}
+
+class AbstractNumberingAttributes extends XmlAttributeComponent<IAbstractNumberingAttributesProperties> {
+    protected xmlKeys = {
+        abstractNumId: "w:abstractNumId",
+        restartNumberingAfterBreak: "w15:restartNumberingAfterBreak",
+    };
+}
+
+export class AbstractNumbering extends XmlComponent {
+    public id: number;
+
+    constructor(id: number) {
+        super("w:abstractNum");
+        this.root.push(new AbstractNumberingAttributes({
+            abstractNumId: id,
+            restartNumberingAfterBreak: 0,
+        }));
+        this.root.push(new MultiLevelType("hybridMultilevel"));
+        this.id = id;
+    }
+
+    public addLevel(level: Level): void {
+        this.root.push(level);
+    }
+
+    public createLevel(num: number, format: string, text: string, align: string = "start"): Level {
+        const level = new Level(num, format, text, align);
+        this.addLevel(level);
+        return level;
+    }
+}

src/numbering/index.ts

@@ -0,0 +1 @@
+export * from "./numbering";

src/numbering/level.ts

@@ -0,0 +1,228 @@
+import * as paragraph from "../docx/paragraph/formatting";
+import { ParagraphProperties } from "../docx/paragraph/properties";
+import * as formatting from "../docx/run/formatting";
+import { RunProperties } from "../docx/run/properties";
+import { Attributes, XmlAttributeComponent, XmlComponent } from "../docx/xml-components";
+
+interface ILevelAttributesProperties {
+    ilvl?: number;
+    tentative?: number;
+}
+
+class LevelAttributes extends XmlAttributeComponent<ILevelAttributesProperties> {
+    protected xmlKeys = {
+        ilvl: "w:ilvl",
+        tentative: "w15:tentative",
+    };
+}
+
+class Start extends XmlComponent {
+
+    constructor(value: number) {
+        super("w:start");
+        this.root.push(new Attributes({
+            val: value,
+        }));
+    }
+}
+
+class NumberFormat extends XmlComponent {
+
+    constructor(value: string) {
+        super("w:numFmt");
+        this.root.push(new Attributes({
+            val: value,
+        }));
+    }
+}
+
+class LevelText extends XmlComponent {
+
+    constructor(value: string) {
+        super("w:lvlText");
+        this.root.push(new Attributes({
+            val: value,
+        }));
+    }
+}
+
+class LevelJc extends XmlComponent {
+
+    constructor(value: string) {
+        super("w:lvlJc");
+        this.root.push(new Attributes({
+            val: value,
+        }));
+    }
+}
+
+export class LevelBase extends XmlComponent {
+    private paragraphProperties: ParagraphProperties;
+    private runProperties: RunProperties;
+
+    constructor(level: number, start?: number, numberFormat?: string, levelText?: string, lvlJc?: string) {
+        super("w:lvl");
+        this.root.push(new LevelAttributes({
+            ilvl: level,
+            tentative: 1,
+        }));
+
+        if (start !== undefined) {
+            this.root.push(new Start(start));
+        }
+        if (numberFormat !== undefined) {
+            this.root.push(new NumberFormat(numberFormat));
+        }
+        if (levelText !== undefined) {
+            this.root.push(new LevelText(levelText));
+        }
+        if (lvlJc !== undefined) {
+            this.root.push(new LevelJc(lvlJc));
+        }
+
+        this.paragraphProperties = new ParagraphProperties();
+        this.runProperties = new RunProperties();
+
+        this.root.push(this.paragraphProperties);
+        this.root.push(this.runProperties);
+    }
+
+    public addParagraphProperty(property: XmlComponent): Level {
+        this.paragraphProperties.push(property);
+        return this;
+    }
+
+    public addRunProperty(property: XmlComponent): Level {
+        this.runProperties.push(property);
+        return this;
+    }
+
+    // ----------  Run formatting ---------------------- //
+
+    public size(twips: number): Level {
+        this.addRunProperty(new formatting.Size(twips));
+        return this;
+    }
+
+    public bold(): Level {
+        this.addRunProperty(new formatting.Bold());
+        return this;
+    }
+
+    public italics(): Level {
+        this.addRunProperty(new formatting.Italics());
+        return this;
+    }
+
+    public smallCaps(): Level {
+        this.addRunProperty(new formatting.SmallCaps());
+        return this;
+    }
+
+    public allCaps(): Level {
+        this.addRunProperty(new formatting.Caps());
+        return this;
+    }
+
+    public strike(): Level {
+        this.addRunProperty(new formatting.Strike());
+        return this;
+    }
+
+    public doubleStrike(): Level {
+        this.addRunProperty(new formatting.DoubleStrike());
+        return this;
+    }
+
+    public subScript(): Level {
+        this.addRunProperty(new formatting.SubScript());
+        return this;
+    }
+
+    public superScript(): Level {
+        this.addRunProperty(new formatting.SuperScript());
+        return this;
+    }
+
+    public underline(underlineType?: string, color?: string): Level {
+        this.addRunProperty(new formatting.Underline(underlineType, color));
+        return this;
+    }
+
+    public color(color: string): Level {
+        this.addRunProperty(new formatting.Color(color));
+        return this;
+    }
+
+    public font(fontName: string): Level {
+        this.addRunProperty(new formatting.RunFonts(fontName));
+        return this;
+    }
+
+    // --------------------- Paragraph formatting ------------------------ //
+
+    public center(): Level {
+        this.addParagraphProperty(new paragraph.Alignment("center"));
+        return this;
+    }
+
+    public left(): Level {
+        this.addParagraphProperty(new paragraph.Alignment("left"));
+        return this;
+    }
+
+    public right(): Level {
+        this.addParagraphProperty(new paragraph.Alignment("right"));
+        return this;
+    }
+
+    public justified(): Level {
+        this.addParagraphProperty(new paragraph.Alignment("both"));
+        return this;
+    }
+
+    public thematicBreak(): Level {
+        this.addParagraphProperty(new paragraph.ThematicBreak());
+        return this;
+    }
+
+    public maxRightTabStop(): Level {
+        this.addParagraphProperty(new paragraph.MaxRightTabStop());
+        return this;
+    }
+
+    public leftTabStop(position: number): Level {
+        this.addParagraphProperty(new paragraph.LeftTabStop(position));
+        return this;
+    }
+
+    public indent(attrs: object): Level {
+        this.addParagraphProperty(new paragraph.Indent(attrs));
+        return this;
+    }
+
+    public spacing(params: paragraph.ISpacingProperties): Level {
+        this.addParagraphProperty(new paragraph.Spacing(params));
+        return this;
+    }
+
+    public keepNext(): Level {
+        this.addParagraphProperty(new paragraph.KeepNext());
+        return this;
+    }
+
+    public keepLines(): Level {
+        this.addParagraphProperty(new paragraph.KeepLines());
+        return this;
+    }
+}
+
+export class Level extends LevelBase {
+    // This is the level that sits under abstractNum. We make a
+    // handful of properties required
+    constructor(level: number, numberFormat: string, levelText: string, lvlJc: string) {
+        super(level, 1, numberFormat, levelText, lvlJc);
+    }
+}
+
+export class LevelForOverride extends LevelBase {}

src/numbering/multi-level-type.ts

@@ -0,0 +1,11 @@
+import { Attributes, XmlComponent } from "../docx/xml-components";
+
+export class MultiLevelType extends XmlComponent {
+
+    constructor(value: string) {
+        super("w:multiLevelType");
+        this.root.push(new Attributes({
+            val: value,
+        }));
+    }
+}

src/numbering/num.ts

@@ -0,0 +1,80 @@
+import { Attributes, XmlAttributeComponent, XmlComponent } from "../docx/xml-components";
+import { LevelForOverride } from "./level";
+
+class AbstractNumId extends XmlComponent {
+
+    constructor(value: number) {
+        super("w:abstractNumId");
+        this.root.push(new Attributes({
+            val: value,
+        }));
+    }
+}
+
+interface INumAttributesProperties {
+    numId: number;
+}
+
+class NumAttributes extends XmlAttributeComponent<INumAttributesProperties> {
+    protected xmlKeys = {numId: "w:numId"};
+}
+
+export class Num extends XmlComponent {
+    public id: number;
+
+    constructor(numId: number, abstractNumId: number) {
+        super("w:num");
+        this.root.push(new NumAttributes({
+            numId: numId,
+        }));
+        this.root.push(new AbstractNumId(abstractNumId));
+        this.id = numId;
+    }
+
+    public overrideLevel(num: number, start?: number): LevelOverride {
+        const olvl = new LevelOverride(num, start);
+        this.root.push(olvl);
+        return olvl;
+    }
+}
+
+class LevelOverrideAttributes extends XmlAttributeComponent<{ilvl: number}> {
+    protected xmlKeys = {ilvl: "w:ilvl"};
+}
+
+export class LevelOverride extends XmlComponent {
+    private levelNum: number;
+    private lvl?: LevelForOverride;
+
+    constructor(levelNum: number, start?: number) {
+        super("w:lvlOverride");
+        this.root.push(new LevelOverrideAttributes({ilvl: levelNum}));
+        if (start !== undefined) {
+            this.root.push(new StartOverride(start));
+        }
+        this.levelNum = levelNum;
+    }
+
+    get level(): LevelForOverride {
+        let lvl: LevelForOverride;
+        if (!this.lvl) {
+            lvl = new LevelForOverride(this.levelNum);
+            this.root.push(lvl);
+            this.lvl = lvl;
+        } else {
+            lvl = this.lvl;
+        }
+        return lvl;
+    }
+}
+
+class StartOverrideAttributes extends XmlAttributeComponent<{val: number}> {
+    protected xmlKeys = {val: "w:val"};
+}
+
+class StartOverride extends XmlComponent {
+    constructor(start: number) {
+        super("w:startOverride");
+        this.root.push(new StartOverrideAttributes({val: start}));
+    }
+}

src/numbering/numbering.spec.ts

@@ -0,0 +1,464 @@
+import { expect } from "chai";
+import { Formatter } from "../export/formatter";
+import { Numbering } from "./";
+import { AbstractNumbering } from "./abstract-numbering";
+import { LevelForOverride } from "./level";
+import { Num } from "./num";
+
+describe("Numbering", () => {
+
+    let numbering: Numbering;
+
+    beforeEach(() => {
+        numbering = new Numbering();
+    });
+
+    describe("#constructor", () => {
+        it("creates a default numbering with one abstract and one concrete instance", () => {
+            const tree = new Formatter().format(numbering);
+            expect(Object.keys(tree)).to.deep.equal(["w:numbering"]);
+            const abstractNums = tree["w:numbering"].filter((el) => el["w:abstractNum"]);
+            expect(abstractNums).to.have.lengthOf(1);
+            expect(abstractNums[0]["w:abstractNum"]).to.deep.include.members([
+                { _attr: { "w:abstractNumId": 0, "w15:restartNumberingAfterBreak": 0 } },
+                { "w:multiLevelType": [{ _attr: { "w:val": "hybridMultilevel" } }] },
+            ]);
+
+            abstractNums.filter((el) => el["w:lvl"]).forEach((el, ix) => {
+                expect(Object.keys(el)).to.have.lengthOf(1);
+                expect(Object.keys(el["w:lvl"]).sort()).to.deep.equal([
+                    "_attr", "w:start", "w:lvlJc", "w:numFmt", "w:pPr", "w:rPr",
+                ]);
+                expect(el["w:lvl"]).to.have.deep.members([
+                    { _attr: { "w:ilvl": ix, "w15:tentative": 1 } },
+                    { "w:start": [{ _attr: { "w:val": 1 } }] },
+                    { "w:lvlJc": [{ _attr: { "w:val": "left" } }] },
+                    { "w:numFmt": [{ _attr: { "w:val": "bullet" } }] },
+                ]);
+                // Once chai 4.0.0 lands and #644 is resolved, we can add the following to the test:
+                // {"w:lvlText": [{"_attr": {"w:val": "•"}}]},
+                // {"w:rPr": [{"w:rFonts": [{"_attr": {"w:ascii": "Symbol", "w:hAnsi": "Symbol", "w:hint": "default"}}]}]},
+                // {"w:pPr": [{"_attr": {}},
+                //            {"w:ind": [{"_attr": {"w:left": 720, "w:hanging": 360}}]}]},
+            });
+        });
+    });
+
+    describe("#createAbstractNumbering", () => {
+        it("returns a new AbstractNumbering instance", () => {
+            const a2 = numbering.createAbstractNumbering();
+            expect(a2).to.be.instanceof(AbstractNumbering);
+        });
+
+        it("assigns a unique ID to each abstract numbering it creates", () => {
+            const a2 = numbering.createAbstractNumbering();
+            const a3 = numbering.createAbstractNumbering();
+            expect(a2.id).not.to.equal(a3.id);
+        });
+    });
+
+    describe("#createConcreteNumbering", () => {
+        it("returns a new Num instance with its abstract ID set to the AbstractNumbering's ID", () => {
+            const a2 = numbering.createAbstractNumbering();
+            const n = numbering.createConcreteNumbering(a2);
+            expect(n).to.be.instanceof(Num);
+            const tree = new Formatter().format(numbering);
+            const serializedN = tree["w:numbering"].find((obj) =>
+                obj["w:num"] && obj["w:num"][0]._attr["w:numId"] === n.id,
+            );
+            expect(serializedN["w:num"][1]["w:abstractNumId"][0]._attr["w:val"]).to.equal(a2.id);
+        });
+
+        it("assigns a unique ID to each concrete numbering it creates", () => {
+            const a2 = numbering.createAbstractNumbering();
+            const n = numbering.createConcreteNumbering(a2);
+            const n2 = numbering.createConcreteNumbering(a2);
+            expect(n.id).not.to.equal(n2.id);
+        });
+    });
+});
+
+describe("AbstractNumbering", () => {
+    it("stores its ID at its .id property", () => {
+        const abstractNumbering = new AbstractNumbering(5);
+        expect(abstractNumbering.id).to.equal(5);
+    });
+
+    describe("#createLevel", () => {
+        it("creates a level with the given characteristics", () => {
+            const abstractNumbering = new AbstractNumbering(1);
+            const level = abstractNumbering.createLevel(3, "lowerLetter", "%1)", "end");
+            const tree = new Formatter().format(level);
+            expect(tree["w:lvl"]).to.include({ _attr: { "w:ilvl": 3, "w15:tentative": 1 } });
+            expect(tree["w:lvl"]).to.include({ "w:start": [{ _attr: { "w:val": 1 } }] });
+            expect(tree["w:lvl"]).to.include({ "w:lvlJc": [{ _attr: { "w:val": "end" } }] });
+            expect(tree["w:lvl"]).to.include({ "w:numFmt": [{ _attr: { "w:val": "lowerLetter" } }] });
+            expect(tree["w:lvl"]).to.include({ "w:lvlText": [{ _attr: { "w:val": "%1)" } }] });
+        });
+
+        it("uses 'start' as the default alignment", () => {
+            const abstractNumbering = new AbstractNumbering(1);
+            const level = abstractNumbering.createLevel(3, "lowerLetter", "%1)");
+            const tree = new Formatter().format(level);
+            expect(tree["w:lvl"]).to.include({ _attr: { "w:ilvl": 3, "w15:tentative": 1 } });
+            expect(tree["w:lvl"]).to.include({ "w:start": [{ _attr: { "w:val": 1 } }] });
+            expect(tree["w:lvl"]).to.include({ "w:lvlJc": [{ _attr: { "w:val": "start" } }] });
+            expect(tree["w:lvl"]).to.include({ "w:numFmt": [{ _attr: { "w:val": "lowerLetter" } }] });
+            expect(tree["w:lvl"]).to.include({ "w:lvlText": [{ _attr: { "w:val": "%1)" } }] });
+        });
+
+        describe("formatting methods: paragraph properties", () => {
+            it("#indent", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerLetter", "%0.")
+                    .indent({ left: 720 });
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [{"w:ind": [{_attr: {"w:left": 720}}]}],
+                });
+            });
+
+            it("#spacing", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerLetter", "%0.")
+                    .spacing({before: 50, after: 150});
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [
+                        {"w:spacing": [{_attr: {"w:before": 50, "w:after": 150}}]},
+                    ],
+                });
+            });
+
+            it("#center", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerLetter", "%0.")
+                    .center();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [
+                            {"w:jc": [{_attr: {"w:val": "center"}}]},
+                    ],
+                });
+            });
+
+            it("#left", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.", "left")
+                    .left();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [
+                        {"w:jc": [{_attr: {"w:val": "left"}}]},
+                    ],
+                });
+            });
+
+            it("#right", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .right();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [
+                            {"w:jc": [{_attr: {"w:val": "right"}}]},
+                    ],
+                });
+            });
+
+            it("#justified", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .justified();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [
+                        {"w:jc": [{_attr: {"w:val": "both"}}]},
+                    ],
+                });
+            });
+
+            it("#thematicBreak", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .thematicBreak();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [
+                        {"w:pBdr": [{"w:bottom": [{_attr: {
+                            "w:color": "auto",
+                            "w:space": "1",
+                            "w:val": "single",
+                            "w:sz": "6",
+                        }}]}]},
+                    ],
+                });
+            });
+
+            it("#leftTabStop", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .leftTabStop(1200);
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [
+                        {"w:tabs": [
+                            {"w:tab": [{_attr: {"w:val": "left", "w:pos": 1200}}]},
+                        ]},
+                    ],
+                });
+            });
+
+            it("#maxRightTabStop", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .maxRightTabStop();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [
+                        {"w:tabs": [
+                            {"w:tab": [{_attr: {"w:val": "right", "w:pos": 9026}}]},
+                        ]},
+                    ],
+                });
+            });
+
+            it("#keepLines", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .keepLines();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [{"w:keepLines": []}],
+                });
+            });
+
+            it("#keepNext", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .keepNext();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [{"w:keepNext": []}],
+                });
+            });
+        });
+
+        describe("formatting methods: run properties", () => {
+            it("#size", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .size(24);
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:sz": [{_attr: {"w:val": 24}}]},
+                    ],
+                });
+            });
+
+            it("#smallCaps", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .smallCaps();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:smallCaps": [{_attr: {"w:val": true}}]},
+                    ],
+                });
+            });
+
+            it("#allCaps", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .allCaps();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:caps": [{_attr: {"w:val": true}}]},
+                    ],
+                });
+            });
+
+            it("#strike", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .strike();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:strike": [{_attr: {"w:val": true}}]},
+                    ],
+                });
+            });
+
+            it("#doubleStrike", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .doubleStrike();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:dstrike": [{_attr: {"w:val": true}}]},
+                    ],
+                });
+            });
+
+            it("#subScript", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .subScript();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:vertAlign": [{_attr: {"w:val": "subscript"}}]},
+                    ],
+                });
+            });
+
+            it("#superScript", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .superScript();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:vertAlign": [{_attr: {"w:val": "superscript"}}]},
+                    ],
+                });
+            });
+
+            it("#font", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .font("Times");
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [{"w:rFonts": [{_attr: {"w:ascii": "Times", "w:hAnsi": "Times"}}]}],
+                });
+            });
+
+            it("#bold", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .bold();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:b": [{_attr: {"w:val": true}}]},
+                    ],
+                });
+            });
+
+            it("#italics", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .italics();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:i": [{_attr: {"w:val": true}}]},
+                    ],
+                });
+            });
+
+            describe("#underline", () => {
+                it("should set underline to 'single' if no arguments are given", () => {
+                    const abstractNumbering = new AbstractNumbering(1);
+                    const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                        .underline();
+                    const tree = new Formatter().format(level);
+                    expect(tree["w:lvl"]).to.include({
+                        "w:rPr": [
+                            {"w:u": [{_attr: {"w:val": "single"}}]},
+                        ],
+                    });
+                });
+
+                it("should set the style if given", () => {
+                    const abstractNumbering = new AbstractNumbering(1);
+                    const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                        .underline("double");
+                    const tree = new Formatter().format(level);
+                    expect(tree["w:lvl"]).to.include({
+                        "w:rPr": [
+                            {"w:u": [{_attr: {"w:val": "double"}}]},
+                        ],
+                    });
+                });
+
+                it("should set the style and color if given", () => {
+                    const abstractNumbering = new AbstractNumbering(1);
+                    const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                        .underline("double", "005599");
+                    const tree = new Formatter().format(level);
+                    expect(tree["w:lvl"]).to.include({
+                        "w:rPr": [
+                            {"w:u": [{_attr: {"w:val": "double", "w:color": "005599"}}]},
+                        ],
+                    });
+                });
+            });
+
+            it("#color", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .color("123456");
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:color": [{_attr: {"w:val": "123456"}}]},
+                    ],
+                });
+            });
+        });
+    });
+});
+
+describe("concrete numbering", () => {
+    describe("#overrideLevel", () => {
+        let numbering;
+        let abstractNumbering;
+        let concreteNumbering;
+        beforeEach(() => {
+            numbering = new Numbering();
+            abstractNumbering = numbering.createAbstractNumbering();
+            concreteNumbering = numbering.createConcreteNumbering(abstractNumbering);
+
+        });
+
+        it("sets a new override level for the given level number", () => {
+            concreteNumbering.overrideLevel(3);
+            const tree = new Formatter().format(concreteNumbering);
+            expect(tree["w:num"]).to.include({"w:lvlOverride": [{_attr: {"w:ilvl": 3}}]});
+        });
+
+        it("sets the startOverride element if start is given", () => {
+            concreteNumbering.overrideLevel(1, 9);
+            const tree = new Formatter().format(concreteNumbering);
+            expect(tree["w:num"]).to.include({
+                "w:lvlOverride": [
+                    {_attr: {"w:ilvl": 1}},
+                    {"w:startOverride": [{_attr: {"w:val": 9}}]},
+                ],
+            });
+        });
+
+        it("sets the lvl element if overrideLevel.level is accessed", () => {
+            const ol = concreteNumbering.overrideLevel(1);
+            expect(ol.level).to.be.instanceof(LevelForOverride);
+            const tree = new Formatter().format(concreteNumbering);
+            expect(tree["w:num"]).to.include({
+                "w:lvlOverride": [
+                    {_attr: {"w:ilvl": 1}},
+                    {"w:lvl": [
+                        {_attr: {"w15:tentative": 1, "w:ilvl": 1}},
+                        {"w:pPr": []},
+                        {"w:rPr": []},
+                    ]},
+                ],
+            });
+        });
+    });
+});

src/numbering/numbering.ts

@@ -0,0 +1,87 @@
+import { DocumentAttributes } from "../docx/document/document-attributes";
+import { Indent } from "../docx/paragraph/formatting";
+import { RunFonts } from "../docx/run/run-fonts";
+import { XmlComponent } from "../docx/xml-components";
+import { AbstractNumbering } from "./abstract-numbering";
+import { Num } from "./num";
+
+export class Numbering extends XmlComponent {
+    private nextId: number;
+
+    constructor() {
+        super("w:numbering");
+        this.root.push(new DocumentAttributes({
+            wpc: "http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas",
+            mc: "http://schemas.openxmlformats.org/markup-compatibility/2006",
+            o: "urn:schemas-microsoft-com:office:office",
+            r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+            m: "http://schemas.openxmlformats.org/officeDocument/2006/math",
+            v: "urn:schemas-microsoft-com:vml",
+            wp14: "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing",
+            wp: "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
+            w10: "urn:schemas-microsoft-com:office:word",
+            w: "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+            w14: "http://schemas.microsoft.com/office/word/2010/wordml",
+            w15: "http://schemas.microsoft.com/office/word/2012/wordml",
+            wpg: "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup",
+            wpi: "http://schemas.microsoft.com/office/word/2010/wordprocessingInk",
+            wne: "http://schemas.microsoft.com/office/word/2006/wordml",
+            wps: "http://schemas.microsoft.com/office/word/2010/wordprocessingShape",
+            Ignorable: "w14 w15 wp14",
+        }));
+
+        this.nextId = 0;
+
+        const abstractNumbering = this.createAbstractNumbering();
+
+        abstractNumbering.createLevel(0, "bullet", "•", "left")
+            .addParagraphProperty(new Indent({ left: 720, hanging: 360 }))
+            .addRunProperty(new RunFonts("Symbol", "default"));
+
+        abstractNumbering.createLevel(1, "bullet", "o", "left")
+            .addParagraphProperty(new Indent({ left: 1440, hanging: 360 }))
+            .addRunProperty(new RunFonts("Courier New", "default"));
+
+        abstractNumbering.createLevel(2, "bullet", "•", "left")
+            .addParagraphProperty(new Indent({ left: 2160, hanging: 360 }))
+            .addRunProperty(new RunFonts("Wingdings", "default"));
+
+        abstractNumbering.createLevel(3, "bullet", "•", "left")
+            .addParagraphProperty(new Indent({ left: 2880, hanging: 360 }))
+            .addRunProperty(new RunFonts("Symbol", "default"));
+
+        abstractNumbering.createLevel(4, "bullet", "o", "left")
+            .addParagraphProperty(new Indent({ left: 3600, hanging: 360 }))
+            .addRunProperty(new RunFonts("Courier New", "default"));
+
+        abstractNumbering.createLevel(5, "bullet", "•", "left")
+            .addParagraphProperty(new Indent({ left: 4320, hanging: 360 }))
+            .addRunProperty(new RunFonts("Wingdings", "default"));
+
+        abstractNumbering.createLevel(6, "bullet", "•", "left")
+            .addParagraphProperty(new Indent({ left: 5040, hanging: 360 }))
+            .addRunProperty(new RunFonts("Symbol", "default"));
+
+        abstractNumbering.createLevel(7, "bullet", "o", "left")
+            .addParagraphProperty(new Indent({ left: 5760, hanging: 360 }))
+            .addRunProperty(new RunFonts("Courier New", "default"));
+
+        abstractNumbering.createLevel(8, "bullet", "•", "left")
+            .addParagraphProperty(new Indent({ left: 6480, hanging: 360 }))
+            .addRunProperty(new RunFonts("Wingdings", "default"));
+
+        this.createConcreteNumbering(abstractNumbering);
+    }
+
+    public createAbstractNumbering(): AbstractNumbering {
+        const num = new AbstractNumbering(this.nextId++);
+        this.root.push(num);
+        return num;
+    }
+
+    public createConcreteNumbering(abstractNumbering: AbstractNumbering): Num {
+        const num = new Num(this.nextId++, abstractNumbering.id);
+        this.root.push(num);
+        return num;
+    }
+}