Version bump

Made XmlableObject non ambient typings to fix typescript problem
Updated archiver types
2017-07-08 21:37:02 +01:00 · 2017-07-08 20:45:19 +01:00 · 2017-07-08 01:24:25 +01:00 · 2017-07-07 16:51:22 +01:00 · 2017-07-07 14:36:34 +01:00 · 2017-07-07 14:34:03 +01:00
118 changed files with 3407 additions and 1414 deletions
--- a/.npmignore
+++ b/.npmignore
@ -38,3 +38,6 @@ build-tests

 # vscode
 .vscode
+
+# docs
+docs
--- a/.travis.yml
+++ b/.travis.yml
@ -1,10 +1,15 @@
 language: node_js
 node_js:
-  - "6"
-  - "node"
+  - "stable"
 install:
  - npm install
 script:
  - npm test
 after_failure: 
  - "cat /home/travis/builds/dolanmiu/docx/npm-debug.log"
+after_success:
+  - bash ./deploy-docs.sh
+env:
+  global:
+  - ENCRYPTION_LABEL: "ad385fa3b525"
+  
--- a/README.md
+++ b/README.md
@ -3,56 +3,38 @@
 </p>

 <p align="center">
-    Generate .docx files with JS/TS very easily
+    Generate .docx files with JS/TS very easily, written in TS.
 </p>
---

-[![NPM version][npm-image]][npm-url] [![Build Status][travis-image]][travis-url] [![Dependency Status][daviddm-image]][daviddm-url] [![Known Vulnerabilities][snky-image]][snky-url]
+-----

-# docx
-> A tool to create Word Documents (.docx) with JS or TS, written in TS.
+[![NPM version][npm-image]][npm-url] [![Build Status][travis-image]][travis-url] [![Dependency Status][gemnasium-image]][gemnasium-url] [![Known Vulnerabilities][snky-image]][snky-url] [![Chat on Gitter][gitter-image]][gitter-url]

 [![NPM](https://nodei.co/npm/docx.png?downloads=true&downloadRank=true&stars=true)](https://nodei.co/npm/docx/)

-# Table of Contents
- [Install](#)
- [Usage](#)
-	- [Create simple Word Document](#)
-	- [Create Paragraph](#)
-		- [Styles](#)
-			- [Heading1 - Heading5](#)
-			- [Title](#)
-		- [Text Alignment](#)
-			- [Example](#)
-		- [Thematic Break (Page Break)](#)
-	- [Text](#)
-		- [Typographical Emphasis](#)
-			- [Bold](#)
-			- [Italics](#)
-			- [Underline](#)
-		- [Break](#)
-		- [Chaining](#)
-	- [Bullet Points](#)
-	- [Tab Stops](#)
-		- [Left Tab Stop](#)
-		- [Center Tab Stop](#)
-		- [Right Tab Stop](#)
-		- [Max Right Tab Stop](#)
-		- [Example](#)
- [Exporting](#)
-	- [Express](#)
-	- [Standalone .docx file](#)
- [Examples](#)
- [License](#)
+# docx

-# Install
+## Install

 ```sh
 $ npm install --save docx
 ```

+## Demo

-# Usage
+```sh
+$ npm run demo
+```
+
+will run the demo selector app in the `demo` folder. It will prompt you to select a demo number, which will run a demo from that folder.
+
+## Guide
+
+Please refer to [the Wiki](https://github.com/dolanmiu/docx/wiki) for details on how to use this library, examples and much more!
+
+Full documentation can be found here: [http://dolanmiu.github.io/docx](http://dolanmiu.github.io/docx)
+
+## Simple Usage

 ```js
 // Used to create docx files
@ -61,326 +43,34 @@ var docx = require('docx');
 // Create document
 var doc = new docx.Document();

+// Add some content in the document
+var paragraph = new docx.Paragraph("Some cool text here.");
+// Add more text into the paragraph if you wish
+paragraph.addRun(new docx.TextRun('Lorem Ipsum Foo Bar'));
+doc.addParagraph(paragraph);
+
 // Used to export the file into a .docx file
+var exporter = new docx.LocalPacker(doc);
+
+// Or use the express packer to make the file downloadable.
 // res is express' Response object
 var exporter = new docx.ExpressPacker(doc, res);
-var exporter = new docx.LocalPacker(doc);
-```
-## Create simple Word Document
-```js
-var doc = new docx.Document();

-var paragraph = new docx.Paragraph();
-var text = new docx.TextRun('Hello World');
-paragraph.addText(text);
-doc.addParagraph(paragraph);
+exporter.pack('My First Document');
+
+// done! A file called 'My First Document.docx'
+// will be in your file system if you used LocalPacker
+// Or it will start downloading if you are using Express
 ```

-### Document properties
-You can add properties to the Word document by specifying options, for example:
-```js
-var doc = new docx.Document({
-    creator: 'Dolan Miu',
-    description: 'My extremely interesting document',
-    title: 'My Document'
-});
-```
+## Examples
+Check [the Wiki](https://github.com/dolanmiu/docx/wiki/Examples) for examples.

-#### Full list of options:
-```
-creator
-description
-title
-subject
-keywords
-lastModifiedBy
-revision
-```
+-----

-You can mix and match whatever properties you want, or provide no properties.
+Made with 💖

-## Create Paragraph
-Every text block in OpenXML is organised in paragraphs. You can add more text to the paragraph by doing this:
-```js
-var paragraph = new docx.Paragraph(),
-```
-```js
-var text = new docx.TextRun('Lorem Ipsum Foo Bar');
-var paragraph = new docx.Paragraph();
-paragraph.addText(text);
-```
-```js
-var paragraph = new docx.Paragraph("Short hand notation for adding text.");
-```
-
-After you create the paragraph, you must add the paragraph into the `document`:
-```js
-doc.addParagraph(paragraph);
-```
-
-### Styles
-Styles is a very important part of the look of a word document. At the moment, only headings and title is supported, but son the rest will be supported along with custom styles!
-
-![Word 2013 Styles menu](http://content.gcflearnfree.org/topics/233/style_apply_choose.png "Word 2013 Styles menu")
-
-#### Heading1 - Heading5
-```js
-paragraph.heading1();
-paragraph.heading2();
-paragraph.heading3();
-paragraph.heading4();
-paragraph.heading5();
-```
-
-#### Title
-```js
-paragraph.title();
-```
-
-### Text Alignment
-To change the text alignment of a paragraph, for center, left, right or justified:
-```js
-paragraph.center();
-```
-```js
-paragraph.left();
-```
-```js
-paragraph.right();
-```
-```js
-paragraph.justified();
-```
-
-#### Example
-```js
-paragraph.heading1().center();
-```
-The above will create a `heading 1` which is `centered`.
-
-### Thematic Break
-To add a break in the page, simply add `.thematicBreak()` on a paragraph:
-
-```js
-var paragraph = new docx.Paragraph("Amazing Heading").heading1().thematicBreak();
-```
-The above example will create a heading with a page break directly under it.
-
-### Page Break
-To move to a new page (insert a page break), simply add `.pageBreak()` on a paragraph:
-
-```js
-var paragraph = new docx.Paragraph("Amazing Heading").heading1().pageBreak();
-```
-The above example will create a heading and start a new page immediately afterwards.
-
-## Text
-Paragraphs need `text run` objects. To create text:
-```js
-var text = new docx.TextRun("My awesome text here for my university dissertation");
-paragraph.addText(text);
-```
-Text objects have methods inside which changes the way the text is displayed.
-
-### Typographical Emphasis
-More info [here](https://english.stackexchange.com/questions/97081/what-is-the-typography-term-which-refers-to-the-usage-of-bold-italics-and-unde)
-#### Bold
-```js
-text.bold();
-```
-
-#### Italics
-```js
-text.italic();
-```
-
-#### Underline
-```js
-text.underline();
-```
-
-#### Strike through
-```js
-text.strike();
-```
-
-#### Double strike through
-```js
-text.doubleStrike();
-```
-
-#### Superscript
-```js
-text.superScript();
-```
-
-#### Subscript
-```js
-text.subScript();
-```
-
-#### All Capitals
-```js
-text.allCaps();
-```
-
-#### Small Capitals
-```js
-text.smallCaps();
-```
-
-### Break
-Sometimes you would want to put text underneath another line of text but inside the same paragraph.
-```js
-text.break();
-```
-
-### Chaining
-What if you want to create a paragraph which is ***bold*** and ***italic***?
-```js
-paragraph.bold().italic();
-```
-
-## Bullet Points
-To make a bullet point, simply make a paragraph into a bullet point:
-```js
-var text = new docx.TextRun("Bullet points");
-var paragraph = new docx.Paragraph(text).bullet();
-
-var text2 = new docx.TextRun("Are awesome");
-var paragraph2 = new docx.Paragraph(text2).bullet();
-
-doc.addParagraph(paragraph);
-doc.addParagraph(paragraph2);
-```
-This will produce:
-* Bullet points
-* Are awesome
-
-## Tab Stops
-If you do not know why tab stops are useful, then I recommend you do a bit of research. It enables side by side text which is nicely laid out without the need for tables, or constantly pressing space bar.
-
-**Note**: At the moment, the unit of measurement for a tab stop is counter intuitive for a human. It is using OpenXMLs own measuring system. For example, 2268 roughly translates to 3cm. Therefore in the future, I may consider changing it to percentages or even cm.
-
-![Word 2013 Tabs](http://www.teachucomp.com/wp-content/uploads/blog-4-22-2015-UsingTabStopsInWord-1024x577.png "Word 2013 Tab Stops")
-
-Simply call the relevant methods on the paragraph listed below. Then just add a `tab()` method call to a text object. Adding multiple `tabStops` will mean you would have to chain `tab()` until the desired `tabStop` is selected. Example is shown below.
-
-### Left Tab Stop
-```js
-paragraph.leftTabStop(2268);
-```
-2268 is the distance from the left side.
-
-### Center Tab Stop
-```js
-paragraph.centerTabStp(2268);
-```
-2268 is the distance from the left side.
-
-### Right Tab Stop
-```js
-paragraph.rightTabStop(2268);
-```
-2268 is the distance from the left side.
-
-### Max Right Tab Stop
-```js
-paragraph.maxRightTabStop();
-```
-This will create a tab stop on the very edge of the right hand side. Handy for right aligning and left aligning text on the same line.
-
-### Example
-```js
-var paragraph = new docx.Paragraph().maxRightTabStop();
-var leftText = new docx.TextRun("Hey everyone").bold();
-var rightText = new docx.TextRun("11th November 2015").tab();
-paragraph.addText(leftText);
-paragraph.addText(rightText);
-```
-The example above will create a left aligned text, and a right aligned text on the same line. The laymans approach to this problem would be to either use text boxes or tables. YUK!
-
-```js
-var paragraph = new docx.Paragraph();
-paragraph.maxRightTabStop();
-paragraph.leftTabStop(1000);
-var text = new docx.TextRun("Second tab stop here I come!").tab().tab();
-paragraph.addText(text);
-```
-The above shows the use of two tab stops, and how to select/use it.
-
-# Exporting
-I used the express exporter in my [website](http://www.dolan.bio). It's very useful, and is the preferred way if you want to make a downloadable file for a visitor. it is much better than generating a physical file on the server, and then passing a download link to that file.
-## Express
-Simply use the exporter, and pass in the necessary parameters:
-```js
-var docx = require('docx');
-
-var doc = new docx.Document();
-var exporter = new docx.ExpressPacker(doc, res);
-exporter.pack('My Document');
-```
-where `res` is the response object obtained through the Express router. It is that simple. The file will begin downloading in the browser.
-
-## Standalone .docx file
-```js
-var docx = require('docx');
-
-var doc = new docx.Document();
-var exporter = new docx.LocalPacker(doc);
-exporter.pack('My Document');
-```
-
-# Examples
-## In practice
-I used this library in my personal portfolio/CV website. Click generate CV for a demonstration. [http://www.dolan.bio](http://www.dolan.bio)
-
-## General
-#### Simple paragraph
-```js
-var doc = new docx.Document();
-
-var paragraph = new docx.Paragraph("Hello World");
-var institutionText = new docx.TextRun("University College London").bold(),
-var dateText = new docx.TextRun("5th Dec 2015").tab().bold();
-paragraph.addText(institutionText);
-paragraph.addText(dateText);
-
-doc.addParagraph(paragraph);
-var exporter = new docx.LocalPacker(doc);
-exporter.pack('My Document');
-```
-
-Or:
-```js
-var doc = new docx.Document();
-
-var paragraph = new docx.Paragraph("Hello World");
-var institutionText = new docx.TextRun("University College London").bold(),
-var dateText = new docx.TextRun("5th Dec 2015").tab().bold();
-paragraph.addText(institutionText);
-paragraph.addText(dateText);
-
-var exporter = new docx.ExpressPacker(doc, res);
-exporter.pack('My Document');
-```
-Would produce:
-
-***University College London***
-
-***5th Dec 2015***
-
-Made with 💖 by Dolan Miu 🍆 💦 😝
-
-# License
-
-MIT © [Dolan Miu](http://www.dolan.bio)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Huge thanks to [@felipeochoa](https://github.com/felipeochoa) for awesome contributions to this project

 [npm-image]: https://badge.fury.io/js/docx.svg
 [npm-url]: https://npmjs.org/package/docx
@ -390,3 +80,8 @@ THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 [daviddm-url]: https://david-dm.org/dolanmiu/docx
 [snky-image]: https://snyk.io/test/github/dolanmiu/docx/badge.svg
 [snky-url]: https://snyk.io/test/github/dolanmiu/docx
+[gitter-image]: https://badges.gitter.im/dolanmiu/docx.svg
+[gitter-url]: https://gitter.im/docx-lib/Lobby
+[gemnasium-image]: https://gemnasium.com/badges/github.com/dolanmiu/docx.svg
+[gemnasium-url]: https://gemnasium.com/github.com/dolanmiu/docx
+
--- a/demo/demo1.js
+++ b/demo/demo1.js
@ -0,0 +1,22 @@
+const docx = require('../build');
+
+var doc = new docx.Document();
+
+var paragraph = new docx.Paragraph("Hello World");
+var institutionText = new docx.TextRun("University College London").bold();
+var dateText = new docx.TextRun("5th Dec 2015").tab().bold();
+paragraph.addRun(institutionText);
+paragraph.addRun(dateText);
+
+doc.addParagraph(paragraph);
+
+// Feature coming soon
+// var media = new docx.Media();
+// media.addMedia("happy-penguins", "./demo/penguins.jpg");
+// var pictureRun = new docx.PictureRun(media.getMedia("happy-penguins"));
+
+// var exporter = new docx.LocalPacker(doc);
+var exporter = new docx.LocalPacker(doc);
+exporter.pack('My Document');
+
+console.log('Document created succesfully at project root!');
--- a/demo/demo2.js
+++ b/demo/demo2.js
@ -0,0 +1,74 @@
+const docx = require('../build');
+
+const styles = new docx.Styles();
+styles.createParagraphStyle('Heading1', 'Heading 1')
+    .basedOn("Normal")
+    .next("Normal")
+    .quickFormat()
+    .size(28)
+    .bold()
+    .italics()
+    .spacing({after: 120});
+
+styles.createParagraphStyle('Heading2', 'Heading 2')
+    .basedOn("Normal")
+    .next("Normal")
+    .quickFormat()
+    .size(26)
+    .bold()
+    .underline('double', 'FF0000')
+    .spacing({before: 240, after: 120});
+
+styles.createParagraphStyle('aside', 'Aside')
+    .basedOn('Normal')
+    .next('Normal')
+    .color('999999')
+    .italics()
+    .indent(720)
+    .spacing({line: 276});
+
+styles.createParagraphStyle('wellSpaced', 'Well Spaced')
+    .basedOn('Normal')
+    .spacing({line: 276, before: 20 * 72 * .1, after: 20 * 72 * .05});
+
+styles.createParagraphStyle('ListParagraph', 'List Paragraph')
+    .quickFormat()
+    .basedOn('Normal');
+
+
+const numbering = new docx.Numbering();
+const numberedAbstract = numbering.createAbstractNumbering();
+numberedAbstract.createLevel(0, "lowerLetter", "%1)", "left");
+
+const doc = new docx.Document({
+    creator: 'Clippy',
+    title: 'Sample Document',
+    description: 'A brief example of using docx',
+});
+
+doc.createParagraph('Test heading1, bold and italicized').heading1();
+doc.createParagraph('Some simple content');
+doc.createParagraph('Test heading2 with double red underline').heading2();
+
+const letterNumbering = numbering.createConcreteNumbering(numberedAbstract);
+const letterNumbering5 = numbering.createConcreteNumbering(numberedAbstract);
+letterNumbering5.overrideLevel(0, 5);
+
+doc.createParagraph('Option1').setNumbering(letterNumbering, 0);
+doc.createParagraph('Option5 -- override 2 to 5').setNumbering(letterNumbering5, 0);
+doc.createParagraph('Option3').setNumbering(letterNumbering, 0);
+
+doc.createParagraph()
+    .createTextRun('Some monospaced content')
+    .font('Monospace');
+
+doc.createParagraph('An aside, in light gray italics and indented').style('aside');
+doc.createParagraph('This is normal, but well-spaced text').style('wellSpaced');
+const para = doc.createParagraph();
+para.createTextRun('This is a bold run,').bold();
+para.createTextRun(' switching to normal ');
+para.createTextRun('and then underlined ').underline();
+para.createTextRun('and back to normal.');
+
+const exporter = new docx.LocalPacker(doc, styles, undefined, numbering);
+exporter.pack('test.docx');
--- a/demo/index.js
+++ b/demo/index.js
@ -0,0 +1,29 @@
+var prompt = require('prompt');
+var shelljs = require('shelljs');
+var fs = require('fs');
+
+console.log('What demo do you wish to run? (Enter a number)');
+
+var schema = {
+    properties: {
+        number: {
+            pattern: /^[0-9]+$/,
+            message: 'Please enter a number.',
+            required: true
+        }
+    }
+};
+
+prompt.start();
+
+prompt.get(schema, function (err, result) {
+    var demoNumber = result.number;
+    var filePath = `./demo/demo${demoNumber}.js`;
+
+    if (!fs.existsSync(filePath)) {
+        console.error(`demo${demoNumber} does not exist: ${filePath}`);
+        return;
+    }
+    console.log(`Running demo ${demoNumber}`);
+    shelljs.exec(`node ${filePath}`);
+});
--- a/demo/penguins.jpg
+++ b/demo/penguins.jpg
--- a/deploy-docs.sh
+++ b/deploy-docs.sh
@ -0,0 +1,68 @@
+#!/bin/bash
+set -e # Exit with nonzero exit code if anything fails
+
+SOURCE_BRANCH="master"
+TARGET_BRANCH="gh-pages"
+
+function doCompile {
+  npm run typedoc
+}
+
+# Pull requests and commits to other branches shouldn't try to deploy, just build to verify
+if [ "$TRAVIS_PULL_REQUEST" != "false" -o "$TRAVIS_BRANCH" != "$SOURCE_BRANCH" ]; then
+    echo "Skipping deploy; just doing a build."
+    doCompile
+    exit 0
+fi
+
+# Save some useful information
+REPO=`git config remote.origin.url`
+SSH_REPO=${REPO/https:\/\/github.com\//git@github.com:}
+SHA=`git rev-parse --verify HEAD`
+
+# Clone the existing gh-pages for this repo into docs/
+# Create a new empty branch if gh-pages doesn't exist yet (should only happen on first deply)
+git clone $REPO docs
+cd docs
+git checkout $TARGET_BRANCH || git checkout --orphan $TARGET_BRANCH
+cd ..
+
+# Clean out existing contents
+# echo "Cleaning out existing contents."
+# rm -rf docs/*
+
+# Run our compile script
+doCompile
+
+# Now let's go have some fun with the cloned repo
+cd docs
+git config user.name "Travis CI"
+git config user.email "dolan_miu@hotmail.com"
+ls
+
+# add .nojekyll file
+touch .nojekyll
+
+# If there are no changes to the compiled out (e.g. this is a README update) then just bail.
+if [ -z `git diff --exit-code` ]; then
+    echo "No changes to the output on this push; exiting."
+    exit 0
+fi
+
+# Commit the "changes", i.e. the new version.
+# The delta will show diffs between new and old versions.
+git add .
+git commit -m "Deploy to GitHub Pages: ${SHA}"
+
+# Get the deploy key by using Travis's stored variables to decrypt deploy-key.enc
+ENCRYPTED_KEY_VAR="encrypted_${ENCRYPTION_LABEL}_key"
+ENCRYPTED_IV_VAR="encrypted_${ENCRYPTION_LABEL}_iv"
+ENCRYPTED_KEY=${!ENCRYPTED_KEY_VAR}
+ENCRYPTED_IV=${!ENCRYPTED_IV_VAR}
+openssl aes-256-cbc -K $ENCRYPTED_KEY -iv $ENCRYPTED_IV -in deploy-key.enc -out deploy-key -d
+chmod 600 deploy-key
+eval `ssh-agent -s`
+ssh-add deploy-key
+
+# Now that we're all set up, we can push.
+git push $SSH_REPO $TARGET_BRANCH
--- a/deploy-key.enc
+++ b/deploy-key.enc
--- a/package.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
  "name": "docx",
-  "version": "1.2.1",
+  "version": "2.1.1",
  "description": "Generate .docx documents with JavaScript (formerly Office-Clippy)",
  "main": "build/index.js",
  "scripts": {
@ -8,11 +8,14 @@
    "test": "mocha ./build-tests --recursive",
    "prepublishOnly": "npm run build",
    "lint": "tslint --project ./ts",
-    "build": "rimraf ./build && tsc -p ts"
+    "build": "rimraf ./build && tsc -p ts",
+    "demo": "npm run build && node ./demo",
+    "typedoc": "typedoc --out docs/ ts/ --module commonjs --target ES6 --disableOutputCheck"
  },
  "files": [
    "ts",
-    "build"
+    "build",
+    "template"
  ],
  "repository": {
    "type": "git",
@ -20,21 +23,20 @@
  },
  "keywords": [
    "office",
+    "word",
    "generate",
+    "creator",
+    "create",
    "document",
    "doc",
    "officegen",
    "clippy"
  ],
+  "types": "./build/index.d.ts",
  "dependencies": {
-    "@types/archiver": "^0.15.37",
+    "@types/archiver": "^1.3.4",
    "@types/express": "^4.0.35",
-    "@types/lodash": "^4.14.54",
-    "app-root-path": "^2.0.1",
    "archiver": "^1.3.0",
-    "install": "^0.8.7",
-    "lodash": "^4.6.1",
-    "npm": "^4.3.0",
    "xml": "^1.0.1"
  },
  "author": "Dolan Miu",
@ -48,8 +50,11 @@
    "@types/mocha": "^2.2.39",
    "chai": "^3.5.0",
    "mocha": "^3.2.0",
+    "prompt": "^1.0.0",
    "rimraf": "^2.5.2",
-    "tslint": "^4.5.1",
-    "typescript": "^2.2.1"
+    "shelljs": "^0.7.7",
+    "tslint": "^5.1.0",
+    "typedoc": "^0.5.10",
+    "typescript": "^2.4.1"
  }
 }
--- a/ts/docx/document/body/index.ts
+++ b/ts/docx/document/body/index.ts
@ -1,15 +1,12 @@
-import { Attributes, XmlComponent } from "../../xml-components";
-import { SectionProperties } from "./section-properties";
+import { XmlComponent } from "../../xml-components";

 export class Body extends XmlComponent {

    constructor() {
        super("w:body");
-        // this.root.push(new SectionProperties()); not actually needed
    }

    public push(component: XmlComponent): void {
-        // this.root.splice(this.body.length - 1, 0, component);
        this.root.push(component);
    }
 }
--- a/ts/docx/document/document-attributes.ts
+++ b/ts/docx/document/document-attributes.ts
@ -1,6 +1,6 @@
 import { XmlAttributeComponent } from "../xml-components";

-interface IDocumentAttributesProperties {
+export interface IDocumentAttributesProperties {
    wpc?: string;
    mc?: string;
    o?: string;
@ -26,10 +26,8 @@ interface IDocumentAttributesProperties {
    type?: string;
 }

-export class DocumentAttributes extends XmlAttributeComponent {
-
-    constructor(properties?: IDocumentAttributesProperties) {
-        super({
+export class DocumentAttributes extends XmlAttributeComponent<IDocumentAttributesProperties> {
+    protected xmlKeys = {
        wpc: "xmlns:wpc",
        mc: "xmlns:mc",
        o: "xmlns:o",
@ -53,12 +51,5 @@ export class DocumentAttributes extends XmlAttributeComponent {
        dcmitype: "xmlns:dcmitype",
        xsi: "xmlns:xsi",
        type: "xsi:type",
-        }, properties);
-
-        this.root = properties;
-
-        if (!properties) {
-            this.root = {};
-        }
-    }
+    };
 }
--- a/ts/docx/document/index.ts
+++ b/ts/docx/document/index.ts
@ -1,7 +1,9 @@
 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;

@ -34,8 +36,20 @@ export class Document extends XmlComponent {
        this.body.push(paragraph);
    }

-    public clearVariables(): void {
-        this.body.clearVariables();
-        delete this.body;
+    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;
+    }
+
 }
--- a/ts/docx/index.ts
+++ b/ts/docx/index.ts
@ -2,3 +2,6 @@ export { Document } from "./document";
 export { Paragraph } from "./paragraph";
 export { Run } from "./run";
 export { TextRun } from "./run/text-run";
+export { PictureRun } from "./run/picture-run";
+export { Table } from "./table";
+// Perhaps all run related stuff can be exported from run, instead of exporting Run, TextRun, PictureRun seperately.
--- a/ts/docx/paragraph/alignment.ts
+++ b/ts/docx/paragraph/alignment.ts
@ -0,0 +1,15 @@
+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}));
+    }
+}
--- a/ts/docx/paragraph/formatting.ts
+++ b/ts/docx/paragraph/formatting.ts
@ -0,0 +1,10 @@
+export { Alignment } from "./alignment";
+export { ThematicBreak } from "./border";
+export { Indent } from "./indent";
+export { KeepLines, KeepNext } from "./keep";
+export { PageBreak } from "./page-break";
+export { ParagraphProperties } from "./properties";
+export { ISpacingProperties, Spacing } from "./spacing";
+export { Style } from "./style";
+export { LeftTabStop, MaxRightTabStop } from "./tab-stop";
+export { NumberProperties } from "./unordered-list";
--- a/ts/docx/paragraph/indent.ts
+++ b/ts/docx/paragraph/indent.ts
@ -0,0 +1,24 @@
+import { XmlAttributeComponent, XmlComponent } from "../xml-components";
+
+interface IIndentAttributesProperties {
+    left?: number;
+    hanging?: number;
+}
+
+class IndentAttributes extends XmlAttributeComponent<IIndentAttributesProperties> {
+    protected xmlKeys = {
+        left: "w:left",
+        hanging: "w:hanging",
+    };
+}
+
+export class Indent extends XmlComponent {
+
+    constructor(left: number, hanging?: number) {
+        super("w:ind");
+        this.root.push(new IndentAttributes({
+            left: left,
+            hanging: hanging,
+        }));
+    }
+}
--- a/ts/docx/paragraph/index.ts
+++ b/ts/docx/paragraph/index.ts
@ -1,23 +1,21 @@
+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 { Attributes, XmlComponent } from "../xml-components";
+import { XmlComponent } from "../xml-components";
+
+import { Alignment } from "./alignment";
 import { ThematicBreak } from "./border";
+import { Indent } from "./indent";
+import { KeepLines, KeepNext } from "./keep";
 import { PageBreak } from "./page-break";
 import { ParagraphProperties } from "./properties";
+import { ISpacingProperties, Spacing } from "./spacing";
 import { Style } from "./style";
 import { LeftTabStop, MaxRightTabStop } from "./tab-stop";
 import { NumberProperties } from "./unordered-list";

-class Alignment extends XmlComponent {
-
-    constructor(type: string) {
-        super("w:jc");
-        this.root.push(new Attributes({
-            val: type,
-        }));
-    }
-}
-
 export class Paragraph extends XmlComponent {
    private properties: ParagraphProperties;

@ -30,11 +28,23 @@ export class Paragraph extends XmlComponent {
        }
    }

-    public addText(run: TextRun): Paragraph {
+    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;
@ -116,4 +126,29 @@ export class Paragraph extends XmlComponent {
        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(start: number, hanging?: number): Paragraph {
+        this.properties.push(new Indent(start, hanging));
+        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;
+    }
 }
--- a/ts/docx/paragraph/keep.ts
+++ b/ts/docx/paragraph/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");
+    }
+}
--- a/ts/docx/paragraph/properties.ts
+++ b/ts/docx/paragraph/properties.ts
@ -1,10 +1,9 @@
-import { Attributes, XmlComponent } from "../xml-components";
+import { XmlComponent } from "../xml-components";

 export class ParagraphProperties extends XmlComponent {

    constructor() {
        super("w:pPr");
-        this.root.push(new Attributes());
    }

    public push(item: XmlComponent): void {
--- a/ts/docx/paragraph/spacing.ts
+++ b/ts/docx/paragraph/spacing.ts
@ -0,0 +1,22 @@
+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));
+    }
+}
--- a/ts/docx/paragraph/tab-stop.ts
+++ b/ts/docx/paragraph/tab-stop.ts
@ -1,6 +1,6 @@
-import { Attributes, XmlComponent } from "../xml-components";
+import { XmlAttributeComponent, XmlComponent } from "../xml-components";

-class TabStop extends XmlComponent {
+export class TabStop extends XmlComponent {

    constructor(tab: Tab) {
        super("w:tabs");
@ -8,11 +8,17 @@ class TabStop extends XmlComponent {
    }
 }

-class Tab extends XmlComponent {
+export type TabOptions = "left" | "right";

-    constructor(value: string, position: any) {
+export class TabAttributes extends XmlAttributeComponent<{val: TabOptions, pos: string | number}> {
+    protected xmlKeys = {val: "w:val", pos: "w:pos"};
+}
+
+export class Tab extends XmlComponent {
+
+    constructor(value: TabOptions, position: string | number) {
        super("w:tab");
-        this.root.push(new Attributes({
+        this.root.push(new TabAttributes({
            val: value,
            pos: position,
        }));
--- a/ts/docx/paragraph/unordered-list.ts
+++ b/ts/docx/paragraph/unordered-list.ts
@ -1,5 +1,4 @@
 import { Attributes, XmlComponent } from "../xml-components";
-import { Style } from "./style";

 export class NumberProperties extends XmlComponent {

--- a/ts/docx/run/formatting.ts
+++ b/ts/docx/run/formatting.ts
@ -1,4 +1,7 @@
 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 {

--- a/ts/docx/run/index.ts
+++ b/ts/docx/run/index.ts
@ -1,14 +1,14 @@
 import { Break } from "./break";
 import { Caps, SmallCaps } from "./caps";
-import { Bold, Italics } from "./formatting";
+import { Bold, Color, DoubleStrike, Italics, Size, Strike } from "./formatting";
 import { RunProperties } from "./properties";
 import { RunFonts } from "./run-fonts";
 import { SubScript, SuperScript } from "./script";
-import { DoubleStrike, Strike } from "./strike";
+import { Style } from "./style";
 import { Tab } from "./tab";
 import { Underline } from "./underline";

-import { Attributes, XmlComponent } from "../xml-components";
+import { XmlComponent } from "../xml-components";

 export class Run extends XmlComponent {
    private properties: RunProperties;
@ -29,8 +29,18 @@ export class Run extends XmlComponent {
        return this;
    }

-    public underline(): Run {
-        this.properties.push(new Underline());
+    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;
    }

@ -78,4 +88,9 @@ export class Run extends XmlComponent {
        this.properties.push(new RunFonts(fontName));
        return this;
    }
+
+    public style(styleId: string): Run {
+        this.properties.push(new Style(styleId));
+        return this;
+    }
 }
--- a/ts/docx/run/picture-run.ts
+++ b/ts/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));
+    }
+}
--- a/ts/docx/run/run-components/drawing/index.ts
+++ b/ts/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));
+    }
+}
--- a/ts/docx/run/run-components/drawing/inline/graphic/graphic-data/index.ts
+++ b/ts/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));
+    }
+}
--- a/ts/docx/run/run-components/drawing/inline/graphic/graphic-data/pic/blip/blip-fill.ts
+++ b/ts/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());
+    }
+}
--- a/ts/docx/run/run-components/drawing/inline/graphic/graphic-data/pic/blip/blip.ts
+++ b/ts/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}`,
+        }));
+    }
+}
--- a/ts/docx/run/run-components/drawing/inline/graphic/graphic-data/pic/blip/source-rectangle.ts
+++ b/ts/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");
+    }
+}
--- a/ts/docx/run/run-components/drawing/inline/graphic/graphic-data/pic/blip/stretch.ts
+++ b/ts/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());
+    }
+}
--- a/ts/docx/run/run-components/drawing/inline/graphic/graphic-data/pic/index.ts
+++ b/ts/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));
+    }
+}
--- a/ts/docx/run/run-components/drawing/inline/graphic/index.ts
+++ b/ts/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));
+    }
+}
--- a/ts/docx/run/run-components/drawing/inline/index.ts
+++ b/ts/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));
+    }
+}
--- a/ts/docx/run/run-components/text.ts
+++ b/ts/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);
+        }
+    }
+}
--- a/ts/docx/run/run-fonts.ts
+++ b/ts/docx/run/run-fonts.ts
@ -6,15 +6,12 @@ interface IRunFontAttributesProperties {
    hint?: string;
 }

-class RunFontAttributes extends XmlAttributeComponent {
-
-    constructor(properties: IRunFontAttributesProperties) {
-        super({
+class RunFontAttributes extends XmlAttributeComponent<IRunFontAttributesProperties> {
+    protected xmlKeys = {
        ascii: "w:ascii",
        hAnsi: "w:hAnsi",
        hint: "w:hint",
-        }, properties);
-    }
+    };
 }

 export class RunFonts extends XmlComponent {
--- a/ts/docx/run/script.ts
+++ b/ts/docx/run/script.ts
@ -1,6 +1,6 @@
 import { Attributes, XmlComponent } from "../xml-components";

-abstract class VerticalAlign extends XmlComponent {
+export abstract class VerticalAlign extends XmlComponent {

    constructor(type: string) {
        super("w:vertAlign");
--- a/ts/docx/run/strike.ts
+++ b/ts/docx/run/strike.ts
@ -1,15 +0,0 @@
-import { XmlComponent } from "../xml-components";
-
-export class Strike extends XmlComponent {
-
-    constructor() {
-        super("w:strike");
-    }
-}
-
-export class DoubleStrike extends XmlComponent {
-
-    constructor() {
-        super("w:dstrike");
-    }
-}
--- a/ts/docx/run/style.ts
+++ b/ts/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}));
+    }
+}
--- a/ts/docx/run/text-run.ts
+++ b/ts/docx/run/text-run.ts
@ -1,5 +1,5 @@
 import { Run } from "../run";
-import { Text } from "./text";
+import { Text } from "./run-components/text";

 export class TextRun extends Run {

--- a/ts/docx/run/text.ts
+++ b/ts/docx/run/text.ts
@ -1,9 +0,0 @@
-import { XmlUnitComponent } from "../xml-components";
-
-export class Text extends XmlUnitComponent {
-
-    constructor(text: string) {
-        super("w:t");
-        this.root = text;
-    }
-}
--- a/ts/docx/run/underline.ts
+++ b/ts/docx/run/underline.ts
@ -1,6 +1,6 @@
 import { Attributes, XmlComponent } from "../xml-components";

-abstract class BaseUnderline extends XmlComponent {
+export abstract class BaseUnderline extends XmlComponent {

    constructor(underlineType: string, color?: string) {
        super("w:u");
@ -13,8 +13,8 @@ abstract class BaseUnderline extends XmlComponent {

 export class Underline extends BaseUnderline {

-    constructor() {
-        super("");
+    constructor(underlineType: string = "single", color?: string) {
+        super(underlineType, color);
    }
 }

--- a/ts/docx/table.ts
+++ b/ts/docx/table.ts
@ -1,3 +0,0 @@
-export class Table {
-
-}
--- a/ts/docx/table/grid.ts
+++ b/ts/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}));
+        }
+    }
+}
--- a/ts/docx/table/index.ts
+++ b/ts/docx/table/index.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");
+    }
+}
--- a/ts/docx/table/properties.ts
+++ b/ts/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}));
+    }
+}
--- a/ts/docx/xml-components/attributes.ts
+++ b/ts/docx/xml-components/attributes.ts
@ -1,6 +1,6 @@
 import { XmlAttributeComponent } from "./default-attributes";

-interface IAttributesProperties {
+export interface IAttributesProperties {
    val?: string | number | boolean;
    color?: string;
    space?: string;
@ -19,13 +19,11 @@ interface IAttributesProperties {
    footer?: string;
    gutter?: string;
    linePitch?: string;
-    pos?: string;
+    pos?: string | number; // Little strange. Perhaps it is normal. Need to clarify in the spec.
 }

-export class Attributes extends XmlAttributeComponent {
-
-    constructor(properties?: IAttributesProperties) {
-        super({
+export class Attributes extends XmlAttributeComponent<IAttributesProperties> {
+    protected xmlKeys = {
        val: "w:val",
        color: "w:color",
        space: "w:space",
@ -45,6 +43,5 @@ export class Attributes extends XmlAttributeComponent {
        gutter: "w:gutter",
        linePitch: "w:linePitch",
        pos: "w:pos",
-        }, properties);
-    }
+    };
 }
--- a/ts/docx/xml-components/base.ts
+++ b/ts/docx/xml-components/base.ts
@ -1,3 +1,5 @@
+import { IXmlableObject } from "./xmlable-object";
+
 export abstract class BaseXmlComponent {
    protected rootKey: string;

@ -5,9 +7,5 @@ export abstract class BaseXmlComponent {
        this.rootKey = rootKey;
    }

-    public abstract replaceKey(): void;
-
-    public clearVariables(): void {
-        // Do Nothing
-    }
+    public abstract prepForXml(): IXmlableObject;
 }
--- a/ts/docx/xml-components/default-attributes.ts
+++ b/ts/docx/xml-components/default-attributes.ts
@ -1,30 +1,26 @@
-import * as _ from "lodash";
 import { BaseXmlComponent } from "./base";
+import { IXmlableObject } from "./xmlable-object";

-export abstract class XmlAttributeComponent extends BaseXmlComponent {
-    protected root: Object;
-    private xmlKeys: Object;
+export type AttributeMap<T> = {[P in keyof T]: string};

-    constructor(xmlKeys: Object, properties: Object) {
+export abstract class XmlAttributeComponent<T> extends BaseXmlComponent {
+    protected root: T;
+    protected xmlKeys: AttributeMap<T>;
+
+    constructor(properties: T) {
        super("_attr");
-        this.xmlKeys = xmlKeys;
-
        this.root = properties;
-
-        if (!properties) {
-            this.root = {};
-        }
    }

-    public replaceKey(): void {
-        if (this.root !== undefined) {
-            _.forOwn(this.root, (value, key) => {
+    public prepForXml(): IXmlableObject {
+        const attrs = {};
+        Object.keys(this.root).forEach((key) => {
+            const value = this.root[key];
+            if (value !== undefined) {
                const newKey = this.xmlKeys[key];
-                this.root[newKey] = value;
-                delete this.root[key];
+                attrs[newKey] = value;
+            }
        });
-            this[this.rootKey] = this.root;
-            delete this.root;
-        }
+        return {_attr: attrs};
    }
 }
--- a/ts/docx/xml-components/index.ts
+++ b/ts/docx/xml-components/index.ts
@ -1,30 +1,27 @@
-import * as _ from "lodash";
 import { BaseXmlComponent } from "./base";
+import { IXmlableObject } from "./xmlable-object";
+export { BaseXmlComponent };

 export abstract class XmlComponent extends BaseXmlComponent {
-    protected root: BaseXmlComponent[];
+    protected root: Array<BaseXmlComponent | string>;

    constructor(rootKey: string) {
        super(rootKey);
        this.root = new Array<BaseXmlComponent>();
    }

-    public replaceKey(): void {
-        // console.log(this.rootKey);
-        // console.log(this.root);
-        if (this.root !== undefined) {
-            this.root.forEach((root) => {
-                if (root && root instanceof BaseXmlComponent) {
-                    root.replaceKey();
-                }
-            });
-            this[this.rootKey] = this.root;
-            delete this.root;
+    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,
+        };
    }
 }

-export * from "./attributes"
+export * from "./attributes";
 export * from "./default-attributes";
-export * from "./unit";
-export * from "./property";
--- a/ts/docx/xml-components/property.ts
+++ b/ts/docx/xml-components/property.ts
@ -1,57 +0,0 @@
-import { ParagraphProperties } from "../paragraph/properties";
-import { RunProperties } from "../run/properties";
-import { XmlComponent } from "./";
-
-export class ParagraphPropertyXmlComponent extends XmlComponent {
-    private paragraphProperties: ParagraphProperties;
-
-    constructor(rootKey: string) {
-        super(rootKey);
-        this.paragraphProperties = new ParagraphProperties();
-        this.root.push(this.paragraphProperties);
-    }
-
-    public clearVariables(): void {
-        this.paragraphProperties.clearVariables();
-
-        delete this.paragraphProperties;
-    }
-}
-
-export class RunPropertyXmlComponent extends XmlComponent {
-    private runProperties: RunProperties;
-
-    constructor(rootKey: string) {
-        super(rootKey);
-        this.runProperties = new RunProperties();
-        this.root.push(this.runProperties);
-    }
-
-    public clearVariables(): void {
-        this.runProperties.clearVariables();
-
-        delete this.runProperties;
-    }
-}
-
-export class MultiPropertyXmlComponent extends XmlComponent {
-    private runProperties: RunProperties;
-    private paragraphProperties: ParagraphProperties;
-
-    constructor(rootKey: string) {
-        super(rootKey);
-        this.runProperties = new RunProperties();
-        this.root.push(this.runProperties);
-
-        this.paragraphProperties = new ParagraphProperties();
-        this.root.push(this.paragraphProperties);
-    }
-
-    public clearVariables(): void {
-        this.runProperties.clearVariables();
-        this.paragraphProperties.clearVariables();
-
-        delete this.runProperties;
-        delete this.paragraphProperties;
-    }
-}
--- a/ts/docx/xml-components/unit.ts
+++ b/ts/docx/xml-components/unit.ts
@ -1,16 +0,0 @@
-import {BaseXmlComponent} from "./base";
-
-export abstract class XmlUnitComponent extends BaseXmlComponent {
-    protected root: string;
-
-    constructor(rootKey: string) {
-        super(rootKey);
-    }
-
-    public replaceKey(): void {
-        if (this.root !== undefined) {
-            this[this.rootKey] = this.root;
-            delete this.root;
-        }
-    }
-}
--- a/ts/docx/xml-components/xmlable-object.ts
+++ b/ts/docx/xml-components/xmlable-object.ts
@ -0,0 +1,3 @@
+export interface IXmlableObject extends Object {
+    _attr?: { [key: string]: (string | number | boolean) };
+}
--- a/ts/export/formatter.ts
+++ b/ts/export/formatter.ts
@ -1,52 +1,8 @@
-import * as _ from "lodash";
-import {XmlComponent} from "../docx/xml-components";
+import { BaseXmlComponent } from "../docx/xml-components";
+import { IXmlableObject } from "../docx/xml-components/xmlable-object";

 export class Formatter {
-
-    public format(input: any): Object {
-        input.clearVariables();
-        this.replaceKeys(input);
-        const newJson = this.clense(input);
-        // console.log(JSON.stringify(newJson, null, "  "));
-        return newJson;
+    public format(input: BaseXmlComponent): IXmlableObject {
+        return input.prepForXml();
    }
-
-    private replaceKeys(input: XmlComponent): Object {
-        input.replaceKey();
-
-        return input;
-    }
-
-    private clense(input: any): Object {
-        const newJson = this.jsonify(input);
-
-        this.deepTraverseJson(newJson, (parent, value, key) => {
-            if (key === "properties") {
-                delete parent[key];
-            }
-            if (key === "xmlKeys") {
-                delete parent[key];
-            }
-            if (key === "rootKey") {
-                delete parent[key];
-            }
-        });
-
-        return newJson;
-    }
-
-    private jsonify(obj: Object): Object {
-        let stringifiedJson = JSON.stringify(obj);
-        return JSON.parse(stringifiedJson);
-    }
-
-    private deepTraverseJson(json: Object, lambda: (json: any, value: any, key: any) => void): void {
-        _.forOwn(json, (value, key) => {
-            if (_.isObject(value) && key !== "xmlKeys" && key !== "rootKey") {
-                this.deepTraverseJson(value, lambda);
-            }
-            lambda(json, value, key);
-        });
-    }
-
 }
--- a/ts/export/index.ts
+++ b/ts/export/index.ts
@ -1,2 +1,3 @@
 export { LocalPacker } from "./packer/local";
 export { ExpressPacker } from "./packer/express";
+export { Packer } from "./packer/packer";
--- a/ts/export/packer/express.ts
+++ b/ts/export/packer/express.ts
@ -1,16 +1,16 @@
 import * as express from "express";
-import * as fs from "fs";
 import { Document } from "../../docx/document";
+import { Media } from "../../media";
 import { Numbering } from "../../numbering";
 import { Properties } from "../../properties";
+import { Styles } from "../../styles";
 import { Packer } from "./packer";

-
 export class ExpressPacker extends Packer {
    private res: express.Response;

-    constructor(document: Document, res: express.Response, styles?: any, properties?: Properties, numbering?: Numbering) {
-        super(document, styles, properties, numbering);
+    constructor(document: Document, res: express.Response, styles?: Styles, properties?: Properties, numbering?: Numbering, media?: Media) {
+        super(document, styles, properties, numbering, media);
        this.res = res;

        this.res.on("close", () => {
@ -19,7 +19,7 @@ export class ExpressPacker extends Packer {
    }

    public pack(name: string): void {
-        this.res.attachment(name + ".docx");
-        super.pack(this.res);
+        this.res.attachment(`${name}.docx`);
+        super.compile(this.res);
    }
 }
--- a/ts/export/packer/local.ts
+++ b/ts/export/packer/local.ts
@ -1,19 +1,21 @@
 import * as fs from "fs";
 import { Document } from "../../docx/document";
+import { Media } from "../../media";
 import { Numbering } from "../../numbering";
 import { Properties } from "../../properties";
+import { Styles } from "../../styles";
 import { Packer } from "./packer";

-
 export class LocalPacker extends Packer {
    private stream: fs.WriteStream;

-    constructor(document: Document, styles?: any, properties?: Properties, numbering?: Numbering) {
-        super(document, styles, properties, numbering);
+    constructor(document: Document, styles?: Styles, properties?: Properties, numbering?: Numbering, media?: Media) {
+        super(document, styles, properties, numbering, media);
    }

    public pack(path: string): void {
-        this.stream = fs.createWriteStream(path);
-        super.pack(this.stream);
+        path = path.replace(/.docx$/, "");
+        this.stream = fs.createWriteStream(`${path}.docx`);
+        super.compile(this.stream);
    }
 }
--- a/ts/export/packer/packer.ts
+++ b/ts/export/packer/packer.ts
@ -1,46 +1,42 @@
 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 appRoot = require("app-root-path");
+const TEMPLATE_PATH = path.resolve(__dirname, "../../../template");

 export abstract class Packer {
-    protected archive: any;
-    protected document: Document;
+    protected archive: archiver.Archiver;
    private formatter: Formatter;
    private style: Styles;
-    private properties: Properties;
-    private numbering: Numbering;

-    constructor(document: Document, style?: any, properties?: Properties, numbering?: Numbering) {
-        this.formatter = new Formatter();
-        this.document = document;
-        this.style = style;
-        this.properties = properties;
-        this.numbering = numbering;
-        this.archive = archiver.create("zip", {});
-
-        if (!style) {
-            const stylesFactory = new DefaultStylesFactory();
-            this.style = stylesFactory.newInstance();
-        }
-
-        if (!properties) {
-            this.properties = new Properties({
+    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 (!numbering) {
-            this.numbering = new Numbering();
+        if (style) {
+            this.style = style;
+        } else {
+            const stylesFactory = new DefaultStylesFactory();
+            this.style = stylesFactory.newInstance();
        }

        this.archive.on("error", (err) => {
@ -48,33 +44,26 @@ export abstract class Packer {
        });
    }

-    public pack(output: any): void {
+    protected compile(output: fs.WriteStream | express.Response): void {
        this.archive.pipe(output);
-        console.log(appRoot.path + "/template");
        this.archive.glob("**", {
-            expand: true,
-            cwd: appRoot.path + "/template",
+            cwd: TEMPLATE_PATH,
        });

        this.archive.glob("**/.rels", {
-            expand: true,
-            cwd: appRoot.path + "/template",
+            cwd: TEMPLATE_PATH,
        });

-        // this.archive.file(appRoot.path + "/template/[Content_Types].xml", { name: "[Content_Types].xml" });
-        // console.log(__dirname + "/packer.js");
-        // this.archive.file(__dirname + "/packer.js", { name: "/[Content_Types].xml" });
-
-        /*this.archive.directory(appRoot.path + "/template", {
-            name: "/root/g.txt",
-            prefix: "root"
-        });*/
        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 xmlProperties = xml(this.formatter.format(this.properties), {
+            declaration: {
+                standalone: "yes",
+                encoding: "UTF-8",
+            },
+        });
        const xmlNumbering = xml(this.formatter.format(this.numbering));
-        // console.log(JSON.stringify(this.numbering, null, " "));
-        console.log(xmlNumbering);
+
        this.archive.append(xmlDocument, {
            name: "word/document.xml",
        });
@ -91,6 +80,12 @@ export abstract class Packer {
            name: "word/numbering.xml",
        });

+        for (const data of this.media.array) {
+            this.archive.append(data.stream, {
+                name: `media/${data.fileName}`,
+            });
+        }
+
        this.archive.finalize();
    }
 }
--- a/ts/index.ts
+++ b/ts/index.ts
@ -1,3 +1,6 @@
 export * from "./docx";
 export * from "./export";
 export { Numbering } from "./numbering";
+export { Styles } from "./styles";
+export { Media } from "./media";
+export * from "./export";
--- a/ts/media/data.ts
+++ b/ts/media/data.ts
@ -0,0 +1,8 @@
+import * as fs from "fs";
+
+export interface IData {
+    referenceId: number;
+    stream: fs.ReadStream;
+    path: string;
+    fileName: string;
+}
--- a/ts/media/index.ts
+++ b/ts/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;
+    }
+}
--- a/ts/numbering/abstract-numbering.ts
+++ b/ts/numbering/abstract-numbering.ts
@ -1,4 +1,3 @@
-import * as _ from "lodash";
 import { XmlAttributeComponent, XmlComponent } from "../docx/xml-components";
 import { Level } from "./level";
 import { MultiLevelType } from "./multi-level-type";
@ -8,14 +7,11 @@ interface IAbstractNumberingAttributesProperties {
    restartNumberingAfterBreak?: number;
 }

-class AbstractNumberingAttributes extends XmlAttributeComponent {
-
-    constructor(properties: IAbstractNumberingAttributesProperties) {
-        super({
+class AbstractNumberingAttributes extends XmlAttributeComponent<IAbstractNumberingAttributesProperties> {
+    protected xmlKeys = {
        abstractNumId: "w:abstractNumId",
        restartNumberingAfterBreak: "w15:restartNumberingAfterBreak",
-        }, properties);
-    }
+    };
 }

 export class AbstractNumbering extends XmlComponent {
@ -40,11 +36,4 @@ export class AbstractNumbering extends XmlComponent {
        this.addLevel(level);
        return level;
    }
-
-    public clearVariables(): void {
-        _.forEach(this.root, (element) => {
-            element.clearVariables();
-        });
-        delete this.id;
-    }
 }
--- a/ts/numbering/indent.ts
+++ b/ts/numbering/indent.ts
@ -1,27 +0,0 @@
-import { XmlAttributeComponent, XmlComponent } from "../docx/xml-components";
-
-interface IndentAttributesProperties {
-    left: number;
-    hanging: number;
-}
-
-class IndentAttributes extends XmlAttributeComponent {
-
-    constructor(properties: IndentAttributesProperties) {
-        super({
-            left: "w:left",
-            hanging: "w:hanging",
-        }, properties);
-    }
-}
-
-export class Indent extends XmlComponent {
-
-    constructor(left: number, hanging: number) {
-        super("w:ind");
-        this.root.push(new IndentAttributes({
-            left: left,
-            hanging: hanging,
-        }));
-    }
-}
--- a/ts/numbering/index.ts
+++ b/ts/numbering/index.ts
@ -1,13 +1,11 @@
-import * as _ from "lodash";
 import { DocumentAttributes } from "../docx/document/document-attributes";
+import { Indent } from "../docx/paragraph/indent";
 import { RunFonts } from "../docx/run/run-fonts";
-import { MultiPropertyXmlComponent } from "../docx/xml-components";
+import { XmlComponent } from "../docx/xml-components";
 import { AbstractNumbering } from "./abstract-numbering";
-import { Indent } from "./indent";
-import { Level } from "./level";
 import { Num } from "./num";

-export class Numbering extends MultiPropertyXmlComponent {
+export class Numbering extends XmlComponent {
    private nextId: number;

    constructor() {
@ -86,12 +84,4 @@ export class Numbering extends MultiPropertyXmlComponent {
        this.root.push(num);
        return num;
    }
-
-    public clearVariables(): void {
-        super.clearVariables();
-        _.forEach(this.root, (element) => {
-            element.clearVariables();
-        });
-        delete this.nextId;
-    }
 }
--- a/ts/numbering/level.ts
+++ b/ts/numbering/level.ts
@ -1,20 +1,19 @@
+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, MultiPropertyXmlComponent, XmlAttributeComponent, XmlComponent } from "../docx/xml-components";
+import { Attributes, XmlAttributeComponent, XmlComponent } from "../docx/xml-components";

 interface ILevelAttributesProperties {
    ilvl?: number;
    tentative?: number;
 }

-class LevelAttributes extends XmlAttributeComponent {
-
-    constructor(properties: ILevelAttributesProperties) {
-        super({
+class LevelAttributes extends XmlAttributeComponent<ILevelAttributesProperties> {
+    protected xmlKeys = {
        ilvl: "w:ilvl",
        tentative: "w15:tentative",
-        }, properties);
-    }
+    };
 }

 class Start extends XmlComponent {
@ -57,21 +56,29 @@ class LevelJc extends XmlComponent {
    }
 }

-export class Level extends XmlComponent {
+export class LevelBase extends XmlComponent {
    private paragraphProperties: ParagraphProperties;
    private runProperties: RunProperties;

-    constructor(level: number, numberFormat: string, levelText: string, lvlJc: string) {
+    constructor(level: number, start?: number, numberFormat?: string, levelText?: string, lvlJc?: string) {
        super("w:lvl");
        this.root.push(new LevelAttributes({
            ilvl: level,
            tentative: 1,
        }));

-        this.root.push(new Start(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();
@ -80,14 +87,6 @@ export class Level extends XmlComponent {
        this.root.push(this.runProperties);
    }

-    public clearVariables(): void {
-        this.paragraphProperties.clearVariables();
-        this.runProperties.clearVariables();
-
-        delete this.paragraphProperties;
-        delete this.runProperties;
-    }
-
    public addParagraphProperty(property: XmlComponent): Level {
        this.paragraphProperties.push(property);
        return this;
@ -97,4 +96,133 @@ export class Level extends XmlComponent {
        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(left: number, hanging?: number): Level {
+        this.addParagraphProperty(new paragraph.Indent(left, hanging));
+        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 {}
--- a/ts/numbering/num.ts
+++ b/ts/numbering/num.ts
@ -1,4 +1,5 @@
 import { Attributes, XmlAttributeComponent, XmlComponent } from "../docx/xml-components";
+import { LevelForOverride } from "./level";

 class AbstractNumId extends XmlComponent {

@ -14,13 +15,8 @@ interface INumAttributesProperties {
    numId: number;
 }

-class NumAttributes extends XmlAttributeComponent {
-
-    constructor(properties: INumAttributesProperties) {
-        super({
-            numId: "w:numId",
-        }, properties);
-    }
+class NumAttributes extends XmlAttributeComponent<INumAttributesProperties> {
+    protected xmlKeys = {numId: "w:numId"};
 }

 export class Num extends XmlComponent {
@ -35,8 +31,50 @@ export class Num extends XmlComponent {
        this.id = numId;
    }

-    public clearVariables(): void {
-        super.clearVariables();
-        delete this.id;
+    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}));
    }
 }
--- a/ts/properties/components.ts
+++ b/ts/properties/components.ts
@ -1,66 +1,64 @@
 import { DocumentAttributes } from "../docx/document/document-attributes";
-import { XmlUnitComponent } from "../docx/xml-components";
 import { XmlComponent } from "../docx/xml-components";

-export class Title extends XmlUnitComponent {
+export class Title extends XmlComponent {

    constructor(value: string) {
        super("dc:title");
-        this.root = value;
+        this.root.push(value);
    }
 }

-export class Subject extends XmlUnitComponent {
+export class Subject extends XmlComponent {

    constructor(value: string) {
        super("dc:subject");
-        this.root = value;
+        this.root.push(value);
    }
 }

-export class Creator extends XmlUnitComponent {
+export class Creator extends XmlComponent {

    constructor(value: string) {
        super("dc:creator");
-        this.root = value;
+        this.root.push(value);
    }
 }

-export class Keywords extends XmlUnitComponent {
+export class Keywords extends XmlComponent {

    constructor(value: string) {
        super("cp:keywords");
-        this.root = value;
+        this.root.push(value);
    }
 }

-export class Description extends XmlUnitComponent {
+export class Description extends XmlComponent {

    constructor(value: string) {
        super("dc:description");
-        this.root = value;
+        this.root.push(value);
    }
 }

-export class LastModifiedBy extends XmlUnitComponent {
+export class LastModifiedBy extends XmlComponent {

    constructor(value: string) {
        super("cp:lastModifiedBy");
-        this.root = value;
+        this.root.push(value);
    }
 }

-export class Revision extends XmlUnitComponent {
+export class Revision extends XmlComponent {

    constructor(value: string) {
        super("cp:revision");
-        const revision = value;
-        this.root = value;
+        this.root.push(value);
    }
 }

-abstract class DateComponent extends XmlComponent {
-    protected getCurrentDate(): any {
+export abstract class DateComponent extends XmlComponent {
+    protected getCurrentDate(): string {
        const date = new Date();
        const year = date.getFullYear();
        const month = ("0" + (date.getMonth() + 1)).slice(-2);
--- a/ts/properties/index.ts
+++ b/ts/properties/index.ts
@ -2,7 +2,7 @@ import { DocumentAttributes } from "../docx/document/document-attributes";
 import { XmlComponent } from "../docx/xml-components";
 import { Created, Creator, Description, Keywords, LastModifiedBy, Modified, Revision, Subject, Title } from "./components";

-interface IPropertiesOptions {
+export interface IPropertiesOptions {
    title?: string;
    subject?: string;
    creator?: string;
@ -23,13 +23,27 @@ export class Properties extends XmlComponent {
            dcmitype: "http://purl.org/dc/dcmitype/",
            xsi: "http://www.w3.org/2001/XMLSchema-instance",
        }));
+        if (options.title) {
            this.root.push(new Title(options.title));
+        }
+        if (options.subject) {
            this.root.push(new Subject(options.subject));
+        }
+        if (options.creator) {
            this.root.push(new Creator(options.creator));
+        }
+        if (options.keywords) {
            this.root.push(new Keywords(options.keywords));
+        }
+        if (options.description) {
            this.root.push(new Description(options.description));
+        }
+        if (options.lastModifiedBy) {
            this.root.push(new LastModifiedBy(options.lastModifiedBy));
+        }
+        if (options.revision) {
            this.root.push(new Revision(options.revision));
+        }
        this.root.push(new Created());
        this.root.push(new Modified());
    }
--- a/ts/relationships/attributes.ts
+++ b/ts/relationships/attributes.ts
@ -0,0 +1,11 @@
+import { XmlAttributeComponent } from "../docx/xml-components";
+
+export interface IRelationshipsAttributesProperties {
+    xmlns: string;
+}
+
+export class RelationshipsAttributes extends XmlAttributeComponent<IRelationshipsAttributesProperties> {
+    protected xmlKeys = {
+        xmlns: "xmlns",
+    };
+}
--- a/ts/relationships/index.ts
+++ b/ts/relationships/index.ts
@ -0,0 +1,14 @@
+import { XmlComponent } from "../docx/xml-components";
+import { RelationshipsAttributes } from "./attributes";
+
+export class Relationships extends XmlComponent {
+
+    constructor() {
+        super("Relationships");
+        this.root.push(new RelationshipsAttributes({
+            xmlns: "http://schemas.openxmlformats.org/package/2006/relationships",
+        }));
+
+        // this.root.push(new Created());
+    }
+}
--- a/ts/relationships/relationship.ts
+++ b/ts/relationships/relationship.ts
--- a/ts/styles/defaults/index.ts
+++ b/ts/styles/defaults/index.ts
@ -14,11 +14,4 @@ export class DocumentDefaults extends XmlComponent {
        this.root.push(this.runPropertiesDefaults);
        this.root.push(this.paragraphPropertiesDefaults);
    }
-
-    clearVariables(): void {
-        this.runPropertiesDefaults.clearVariables();
-        this.paragraphPropertiesDefaults.clearVariables();
-        delete this.runPropertiesDefaults;
-        delete this.paragraphPropertiesDefaults;
-    }
 }
--- a/ts/styles/defaults/paragraph-properties.ts
+++ b/ts/styles/defaults/paragraph-properties.ts
@ -1,5 +1,5 @@
-import {XmlComponent} from "../../docx/xml-components";
 import { ParagraphProperties } from "../../docx/paragraph/properties";
+import { XmlComponent } from "../../docx/xml-components";

 export class ParagraphPropertiesDefaults extends XmlComponent {

--- a/ts/styles/defaults/run-properties.ts
+++ b/ts/styles/defaults/run-properties.ts
@ -1,5 +1,5 @@
-import {XmlComponent} from "../../docx/xml-components";
 import { RunProperties } from "../../docx/run/properties";
+import { XmlComponent } from "../../docx/xml-components";

 export class RunPropertiesDefaults extends XmlComponent {

--- a/ts/styles/factory.ts
+++ b/ts/styles/factory.ts
@ -1,56 +1,54 @@
+import { Color, Italics, Size } from "../docx/run/formatting";
+
 import { Styles } from "./";
 import { DocumentDefaults } from "./defaults";
-import {ParagraphPropertiesDefaults} from "./defaults/paragraph-properties";
-import {RunPropertiesDefaults} from "./defaults/run-properties";
-import {Heading1Style, Heading2Style, TitleStyle, Heading3Style, Heading4Style, Heading5Style, Heading6Style, ListParagraph} from "./style";
-// import {StyleAttributes} from "./style/attributes";
-import {ParagraphProperties} from "../docx/paragraph/properties";
-import {RunProperties} from "../docx/run/properties";
-import {Color, Size, Italics} from "../docx/run/formatting";
+import {
+    Heading1Style, Heading2Style, Heading3Style, Heading4Style, Heading5Style, Heading6Style,
+    ListParagraph, TitleStyle,
+} from "./style";

 export class DefaultStylesFactory {

-    newInstance(): Styles {
-        let styles = new Styles();
+    public newInstance(): Styles {
+        const styles = new Styles();
        styles.push(new DocumentDefaults());

-        let titleStyle = new TitleStyle();
+        const titleStyle = new TitleStyle();
        titleStyle.addRunProperty(new Size(56));
        styles.push(titleStyle);

-        let heading1Style = new Heading1Style();
+        const heading1Style = new Heading1Style();
        heading1Style.addRunProperty(new Color("2E74B5"));
        heading1Style.addRunProperty(new Size(32));
        styles.push(heading1Style);

-        let heading2Style = new Heading2Style();
+        const heading2Style = new Heading2Style();
        heading2Style.addRunProperty(new Color("2E74B5"));
        heading2Style.addRunProperty(new Size(26));
        styles.push(heading2Style);

-        let heading3Style = new Heading3Style();
+        const heading3Style = new Heading3Style();
        heading3Style.addRunProperty(new Color("1F4D78"));
        heading3Style.addRunProperty(new Size(24));
        styles.push(heading3Style);

-        let heading4Style = new Heading4Style();
+        const heading4Style = new Heading4Style();
        heading4Style.addRunProperty(new Color("2E74B5"));
        heading4Style.addRunProperty(new Italics());
        styles.push(heading4Style);

-        let heading5Style = new Heading5Style();
+        const heading5Style = new Heading5Style();
        heading5Style.addRunProperty(new Color("2E74B5"));
        styles.push(heading5Style);

-        let heading6Style = new Heading6Style();
+        const heading6Style = new Heading6Style();
        heading6Style.addRunProperty(new Color("1F4D78"));
        styles.push(heading6Style);

-        let listParagraph = new ListParagraph();
+        const listParagraph = new ListParagraph();
        // listParagraph.addParagraphProperty();
        styles.push(listParagraph);

-        // console.log(JSON.stringify(styles, null, "  "));
        return styles;
    }
 }
--- a/ts/styles/index.ts
+++ b/ts/styles/index.ts
@ -1,9 +1,6 @@
-import {XmlComponent} from "../docx/xml-components";
 import { DocumentAttributes } from "../docx/document/document-attributes";
-import {DocumentDefaults} from "./defaults";
-import {LatentStyles} from "./latent-styles";
-import {LatentStyleException} from "./latent-styles/exceptions";
-import {LatentStyleExceptionAttributes} from "./latent-styles/exceptions/attributes";
+import { XmlComponent } from "../docx/xml-components";
+import { ParagraphStyle } from "./style";

 export class Styles extends XmlComponent {

@ -15,7 +12,7 @@ export class Styles extends XmlComponent {
            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",
-            Ignorable: "w14 w15"
+            Ignorable: "w14 w15",
        }));
        // let latentStyles = new LatentStyles();
        // latentStyles.push(new LatentStyleException(new LatentStyleExceptionAttributes({
@ -24,13 +21,14 @@ export class Styles extends XmlComponent {
        // this.root.push(latentStyles);
    }

-    push(style: XmlComponent): void {
+    public push(style: XmlComponent): Styles {
        this.root.push(style);
+        return this;
    }

-    clearVariables() {
-        this.root.forEach(element => {
-            element.clearVariables();
-        });
+    public createParagraphStyle(styleId: string, name?: string): ParagraphStyle {
+        const para = new ParagraphStyle(styleId, name);
+        this.push(para);
+        return para;
    }
 }
--- a/ts/styles/latent-styles/exceptions.ts
+++ b/ts/styles/latent-styles/exceptions.ts
@ -0,0 +1,27 @@
+import { XmlAttributeComponent, XmlComponent } from "../../docx/xml-components";
+
+export interface ILatentStyleExceptionAttributesProperties {
+    name?: string;
+    uiPriority?: string;
+    qFormat?: string;
+    semiHidden?: string;
+    unhideWhenUsed?: string;
+}
+
+export class LatentStyleExceptionAttributes extends XmlAttributeComponent<ILatentStyleExceptionAttributesProperties> {
+    protected xmlKeys = {
+        name: "w:name",
+        uiPriority: "w:uiPriority",
+        qFormat: "w:qFormat",
+        semiHidden: "w:semiHidden",
+        unhideWhenUsed: "w:unhideWhenUsed",
+    };
+}
+
+export class LatentStyleException extends XmlComponent {
+
+    constructor(attributes: ILatentStyleExceptionAttributesProperties) {
+        super("w:lsdException");
+        this.root.push(new LatentStyleExceptionAttributes(attributes));
+    }
+}
--- a/ts/styles/latent-styles/exceptions/attributes.ts
+++ b/ts/styles/latent-styles/exceptions/attributes.ts
@ -1,31 +0,0 @@
-import {XmlComponent} from "../../../docx/xml-components";
-
-interface LatentStyleExceptionAttributesProperties {
-    name?: string;
-    uiPriority?: string;
-    qFormat?: string;
-    semiHidden?: string;
-    unhideWhenUsed?: string;
-}
-
-export class LatentStyleExceptionAttributes extends XmlComponent {
-    private _attr: Object;
-
-    xmlKeys = {
-        name: "w:name",
-        uiPriority: "w:uiPriority",
-        qFormat: "w:qFormat",
-        semiHidden: "w:semiHidden",
-        unhideWhenUsed: "w:unhideWhenUsed"
-    };
-
-    constructor(properties?: LatentStyleExceptionAttributesProperties) {
-        super("_attr");
-        this._attr = properties;
-
-        if (!properties) {
-            this._attr = {};
-        }
-        this._attr["xmlKeys"] = this.xmlKeys;
-    }
-}
--- a/ts/styles/latent-styles/exceptions/index.ts
+++ b/ts/styles/latent-styles/exceptions/index.ts
@ -1,10 +0,0 @@
-import {XmlComponent} from "../../../docx/xml-components";
-import {LatentStyleExceptionAttributes} from "./attributes";
-
-export class LatentStyleException extends XmlComponent {
-
-    constructor(attributes: LatentStyleExceptionAttributes) {
-        super("w:lsdException");
-        this.root.push(attributes);
-    }
-}
--- a/ts/styles/latent-styles/index.ts
+++ b/ts/styles/latent-styles/index.ts
@ -7,7 +7,7 @@ export class LatentStyles extends XmlComponent {
        super("w:latentStyles");
    }

-    push(latentException: LatentStyleException): void {
+    public push(latentException: LatentStyleException): void {
        this.root.push(latentException);
    }
 }
--- a/ts/styles/style/attributes.ts
+++ b/ts/styles/style/attributes.ts
@ -1,24 +0,0 @@
-import {XmlComponent} from "../../docx/xml-components";
-import {XmlAttributeComponent} from "../../docx/xml-components";
-
-interface StyleAttributesProperties {
-    type?: string;
-    styleId?: string;
-    default?: string;
-    customStyle?: string;
-    val?: string;
-}
-
-export class StyleAttributes extends XmlAttributeComponent {
-    private _attr: Object;
-
-    constructor(properties: StyleAttributesProperties) {
-        super({
-            type: "w:type",
-            styleId: "w:styleId",
-            default: "w:default",
-            customStyle: "w:customStyle",
-            val: "w:val"
-        }, properties);
-    }
-}
--- a/ts/styles/style/components.ts
+++ b/ts/styles/style/components.ts
@ -1,13 +1,18 @@
-import {XmlComponent} from "../../docx/xml-components";
-import {StyleAttributes} from "./attributes";
+import { XmlAttributeComponent, XmlComponent } from "../../docx/xml-components";
+
+interface IComponentAttributes {
+    val: string;
+}
+
+class ComponentAttributes extends XmlAttributeComponent<IComponentAttributes> {
+    protected xmlKeys = {val: "w:val"};
+}

 export class Name extends XmlComponent {

    constructor(value: string) {
        super("w:name");
-        this.root.push(new StyleAttributes({
-            val: value
-        }));
+        this.root.push(new ComponentAttributes({val: value}));
    }
 }

@ -15,9 +20,7 @@ export class BasedOn extends XmlComponent {

    constructor(value: string) {
        super("w:basedOn");
-        this.root.push(new StyleAttributes({
-            val: value
-        }));
+        this.root.push(new ComponentAttributes({val: value}));
    }
 }

@ -25,10 +28,7 @@ export class Next extends XmlComponent {

    constructor(value: string) {
        super("w:next");
-        this.root.push(new StyleAttributes({
-            styleId: "1",
-            val: value
-        }));
+        this.root.push(new ComponentAttributes({val: value}));
    }
 }

@ -36,9 +36,7 @@ export class Link extends XmlComponent {

    constructor(value: string) {
        super("w:link");
-        this.root.push(new StyleAttributes({
-            val: value
-        }));
+        this.root.push(new ComponentAttributes({val: value}));
    }
 }

@ -46,9 +44,8 @@ export class UiPriority extends XmlComponent {

    constructor(value: string) {
        super("w:uiPriority");
-        this.root.push(new StyleAttributes({
-            val: value
-        }));
+        // TODO: this value should be a ST_DecimalNumber
+        this.root.push(new ComponentAttributes({val: value}));
    }
 }

--- a/ts/styles/style/index.ts
+++ b/ts/styles/style/index.ts
@ -1,63 +1,204 @@
-import {XmlComponent} from "../../docx/xml-components";
-import {StyleAttributes} from "./attributes";
-import {ParagraphProperties} from "../../docx/paragraph/properties";
+import * as paragraph from "../../docx/paragraph/formatting";
+import * as formatting from "../../docx/run/formatting";
 import { RunProperties } from "../../docx/run/properties";
-import {Name, BasedOn, Next, QuickFormat} from "./components";
+import { XmlAttributeComponent, XmlComponent } from "../../docx/xml-components";
+
+import { BasedOn, Name, Next, QuickFormat } from "./components";
+
+export interface IStyleAttributes {
+    type?: string;
+    styleId?: string;
+    default?: boolean;
+    customStyle?: string;
+}
+
+class StyleAttributes extends XmlAttributeComponent<IStyleAttributes> {
+    protected xmlKeys = {
+        type: "w:type",
+        styleId: "w:styleId",
+        default: "w:default",
+        customStyle: "w:customStyle",
+    };
+}

 export class Style extends XmlComponent {

-    constructor(attributes: StyleAttributes) {
+    constructor(attributes: IStyleAttributes, name?: string) {
        super("w:style");
-        this.root.push(attributes);
+        this.root.push(new StyleAttributes(attributes));
+        if (name) {
+            this.root.push(new Name(name));
+        }
    }

-    push(styleSegment: XmlComponent): void {
+    public push(styleSegment: XmlComponent): void {
        this.root.push(styleSegment);
    }
 }

 export class ParagraphStyle extends Style {

-    private paragraphProperties: ParagraphProperties;
+    private paragraphProperties: paragraph.ParagraphProperties;
    private runProperties: RunProperties;

-    constructor(styleId: string) {
-
-        let attributes = new StyleAttributes({
-            type: "paragraph",
-            styleId: styleId
-        });
-        super(attributes);
-        this.paragraphProperties = new ParagraphProperties();
+    constructor(styleId: string, name?: string) {
+        super({type: "paragraph", styleId: styleId}, name);
+        this.paragraphProperties = new paragraph.ParagraphProperties();
        this.runProperties = new RunProperties();
        this.root.push(this.paragraphProperties);
        this.root.push(this.runProperties);
    }

-    clearVariables(): void {
-        this.paragraphProperties.clearVariables();
-        this.runProperties.clearVariables();
-        delete this.paragraphProperties;
-        delete this.runProperties;
-    }
-
-    addParagraphProperty(property: XmlComponent): void {
+    public addParagraphProperty(property: XmlComponent): void {
        this.paragraphProperties.push(property);
    }

-    addRunProperty(property: XmlComponent): void {
+    public addRunProperty(property: XmlComponent): void {
        this.runProperties.push(property);
    }
+
+    public basedOn(parentId: string): ParagraphStyle {
+        this.root.push(new BasedOn(parentId));
+        return this;
+    }
+
+    public quickFormat(): ParagraphStyle {
+        this.root.push(new QuickFormat());
+        return this;
+    }
+
+    public next(nextId: string): ParagraphStyle {
+        this.root.push(new Next(nextId));
+        return this;
+    }
+
+    // ----------  Run formatting ---------------------- //
+
+    public size(twips: number): ParagraphStyle {
+        this.addRunProperty(new formatting.Size(twips));
+        return this;
+    }
+
+    public bold(): ParagraphStyle {
+        this.addRunProperty(new formatting.Bold());
+        return this;
+    }
+
+    public italics(): ParagraphStyle {
+        this.addRunProperty(new formatting.Italics());
+        return this;
+    }
+
+    public smallCaps(): ParagraphStyle {
+        this.addRunProperty(new formatting.SmallCaps());
+        return this;
+    }
+
+    public allCaps(): ParagraphStyle {
+        this.addRunProperty(new formatting.Caps());
+        return this;
+    }
+
+    public strike(): ParagraphStyle {
+        this.addRunProperty(new formatting.Strike());
+        return this;
+    }
+
+    public doubleStrike(): ParagraphStyle {
+        this.addRunProperty(new formatting.DoubleStrike());
+        return this;
+    }
+
+    public subScript(): ParagraphStyle {
+        this.addRunProperty(new formatting.SubScript());
+        return this;
+    }
+
+    public superScript(): ParagraphStyle {
+        this.addRunProperty(new formatting.SuperScript());
+        return this;
+    }
+
+    public underline(underlineType?: string, color?: string): ParagraphStyle {
+        this.addRunProperty(new formatting.Underline(underlineType, color));
+        return this;
+    }
+
+    public color(color: string): ParagraphStyle {
+        this.addRunProperty(new formatting.Color(color));
+        return this;
+    }
+
+    public font(fontName: string): ParagraphStyle {
+        this.addRunProperty(new formatting.RunFonts(fontName));
+        return this;
+    }
+
+    // --------------------- Paragraph formatting ------------------------ //
+
+    public center(): ParagraphStyle {
+        this.addParagraphProperty(new paragraph.Alignment("center"));
+        return this;
+    }
+
+    public left(): ParagraphStyle {
+        this.addParagraphProperty(new paragraph.Alignment("left"));
+        return this;
+    }
+
+    public right(): ParagraphStyle {
+        this.addParagraphProperty(new paragraph.Alignment("right"));
+        return this;
+    }
+
+    public justified(): ParagraphStyle {
+        this.addParagraphProperty(new paragraph.Alignment("both"));
+        return this;
+    }
+
+    public thematicBreak(): ParagraphStyle {
+        this.addParagraphProperty(new paragraph.ThematicBreak());
+        return this;
+    }
+
+    public maxRightTabStop(): ParagraphStyle {
+        this.addParagraphProperty(new paragraph.MaxRightTabStop());
+        return this;
+    }
+
+    public leftTabStop(position: number): ParagraphStyle {
+        this.addParagraphProperty(new paragraph.LeftTabStop(position));
+        return this;
+    }
+
+    public indent(left: number, hanging?: number): ParagraphStyle {
+        this.addParagraphProperty(new paragraph.Indent(left, hanging));
+        return this;
+    }
+
+    public spacing(params: paragraph.ISpacingProperties): ParagraphStyle {
+        this.addParagraphProperty(new paragraph.Spacing(params));
+        return this;
+    }
+
+    public keepNext(): ParagraphStyle {
+        this.addParagraphProperty(new paragraph.KeepNext());
+        return this;
+    }
+
+    public keepLines(): ParagraphStyle {
+        this.addParagraphProperty(new paragraph.KeepLines());
+        return this;
+    }
 }

 export class HeadingStyle extends ParagraphStyle {

    constructor(styleId: string, name: string) {
-        super(styleId);
-        this.root.push(new Name(name));
-        this.root.push(new BasedOn("Normal"));
-        this.root.push(new Next("Normal"));
-        this.root.push(new QuickFormat());
+        super(styleId, name);
+        this.basedOn("Normal");
+        this.next("Normal");
+        this.quickFormat();
    }
 }

--- a/ts/test-tsconfig.json
+++ b/ts/test-tsconfig.json
@ -1,7 +1,12 @@
 {
    "compilerOptions": {
        "target": "es6",
+        "strictNullChecks": true,
+        "sourceMap": true,
+        "removeComments": true,
+        "preserveConstEnums": true,
        "outDir": "../build-tests",
+        "sourceRoot": "./",
        "rootDir": "./",
        "module": "commonjs"
    }
--- a/ts/tests/_testTemplate.ts
+++ b/ts/tests/_testTemplate.ts
@ -1,19 +1,17 @@
+/* tslint:disable */
 import { assert } from "chai";
-
-function jsonify(obj: Object) {
-    let stringifiedJson = JSON.stringify(obj);
-    return JSON.parse(stringifiedJson);
-}
+import { Utility } from "./utility";
+/* tslint:enable */

 describe("", () => {

    beforeEach(() => {
-
+        // TODO
    });

    describe("#methodName()", () => {
        it("should ", () => {
-
+            // TODO
        });
    });
 });
--- a/ts/tests/docx/document/bodyTest.ts
+++ b/ts/tests/docx/document/bodyTest.ts
@ -1,15 +1,11 @@
-import { Body } from "../../../docx/document/body";
 import { assert } from "chai";
-import { SectionProperties } from "../../../docx/document/body/section-properties";
-import { PageSize } from "../../../docx/document/body/page-size";
-import { PageMargin } from "../../../docx/document/body/page-margin";
+import { Body } from "../../../docx/document/body";
 import { Columns } from "../../../docx/document/body/columns";
 import { DocumentGrid } from "../../../docx/document/body/doc-grid";
-
-function jsonify(obj: Object) {
-    let stringifiedJson = JSON.stringify(obj);
-    return JSON.parse(stringifiedJson);
-}
+import { PageMargin } from "../../../docx/document/body/page-margin";
+import { PageSize } from "../../../docx/document/body/page-size";
+import { SectionProperties } from "../../../docx/document/body/section-properties";
+import { Utility } from "../../utility";

 describe("Body", () => {
    let body: Body;
@ -26,27 +22,27 @@ describe("Body", () => {
    describe("#constructor()", () => {

        it("should create the Section Properties", () => {
-            let newJson = jsonify(body);
+            const newJson = Utility.jsonify(body);
            assert.equal(newJson.root[0].rootKey, "w:sectPr");
        });

        it("should create the Page Size", () => {
-            let newJson = jsonify(body);
+            const newJson = Utility.jsonify(body);
            assert.equal(newJson.root[1].rootKey, "w:pgSz");
        });

        it("should create the Page Margin", () => {
-            let newJson = jsonify(body);
+            const newJson = Utility.jsonify(body);
            assert.equal(newJson.root[2].rootKey, "w:pgMar");
        });

        it("should create the Columns", () => {
-            let newJson = jsonify(body);
+            const newJson = Utility.jsonify(body);
            assert.equal(newJson.root[3].rootKey, "w:cols");
        });

        it("should create the Document Grid", () => {
-            let newJson = jsonify(body);
+            const newJson = Utility.jsonify(body);
            assert.equal(newJson.root[4].rootKey, "w:docGrid");
        });
    });
--- a/ts/tests/docx/document/documentTest.ts
+++ b/ts/tests/docx/document/documentTest.ts
@ -1,5 +1,6 @@
+import { assert, expect } from "chai";
 import * as docx from "../../../docx";
-import { assert } from "chai";
+import { Formatter } from "../../../export/formatter";

 describe("Document", () => {
    let document: docx.Document;
@ -11,7 +12,7 @@ describe("Document", () => {
    describe("#constructor()", () => {

        it("should create valid JSON", () => {
-            let stringifiedJson = JSON.stringify(document);
+            const stringifiedJson = JSON.stringify(document);
            let newJson;

            try {
@ -22,4 +23,51 @@ describe("Document", () => {
            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);
+        });
+    });
 });
--- a/ts/tests/docx/paragraph/borderTest.ts
+++ b/ts/tests/docx/paragraph/borderTest.ts
@ -1,13 +1,9 @@
-import { ThematicBreak } from "../../../docx/paragraph/border";
 import { assert } from "chai";
-
-function jsonify(obj: Object) {
-    let stringifiedJson = JSON.stringify(obj);
-    return JSON.parse(stringifiedJson);
-}
+import { ThematicBreak } from "../../../docx/paragraph/border";
+import { Utility } from "../../utility";

 describe("Border", () => {
-
+    // TODO: Need tests here
 });

 describe("ThematicBreak", () => {
@ -19,12 +15,12 @@ describe("ThematicBreak", () => {

    describe("#constructor()", () => {
        it("should create a Thematic Break with correct border properties", () => {
-            let newJson = jsonify(thematicBreak);
-            let attributes = {
+            const newJson = Utility.jsonify(thematicBreak);
+            const attributes = {
                color: "auto",
                space: "1",
                val: "single",
-                sz: "6"
+                sz: "6",
            };
            assert.equal(JSON.stringify(newJson.root[0].root[0].root), JSON.stringify(attributes));
        });
--- a/ts/tests/docx/paragraph/pageBreakTests.ts
+++ b/ts/tests/docx/paragraph/pageBreakTests.ts
@ -1,10 +1,6 @@
-import { PageBreak } from "../../../docx/paragraph/page-break";
 import { assert } from "chai";
-
-function jsonify(obj: Object) {
-    let stringifiedJson = JSON.stringify(obj);
-    return JSON.parse(stringifiedJson);
-}
+import { PageBreak } from "../../../docx/paragraph/page-break";
+import { Utility } from "../../utility";

 describe("PageBreak", () => {
    let pageBreak: PageBreak;
@ -15,20 +11,20 @@ describe("PageBreak", () => {

    describe("#constructor()", () => {
        it("should create a Page Break with correct attributes", () => {
-            let newJson = jsonify(pageBreak);
-            let attributes = {
-                type: "page"
+            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", () => {
-            let newJson = jsonify(pageBreak);
+            const newJson = Utility.jsonify(pageBreak);
            assert.equal(newJson.rootKey, "w:r");
        });

        it("should create a Page Break with a Break inside", () => {
-            let newJson = jsonify(pageBreak);
+            const newJson = Utility.jsonify(pageBreak);
            assert.equal(newJson.root[1].rootKey, "w:br");
        });
    });
--- a/ts/tests/docx/paragraph/paragraphStyleTest.ts
+++ b/ts/tests/docx/paragraph/paragraphStyleTest.ts
@ -1,10 +1,6 @@
-import { Style } from "../../../docx/paragraph/style";
 import { assert } from "chai";
-
-function jsonify(obj: Object) {
-    let stringifiedJson = JSON.stringify(obj);
-    return JSON.parse(stringifiedJson);
-}
+import { Style } from "../../../docx/paragraph/style";
+import { Utility } from "../../utility";

 describe("ParagraphStyle", () => {
    let style: Style;
@ -12,15 +8,14 @@ describe("ParagraphStyle", () => {
    describe("#constructor()", () => {
        it("should create a style with given value", () => {
            style = new Style("test");
-            let newJson = jsonify(style);
+            const newJson = Utility.jsonify(style);
            assert.equal(newJson.root[0].root.val, "test");
        });

        it("should create a style with blank val", () => {
            style = new Style("");
-            let newJson = jsonify(style);
+            const newJson = Utility.jsonify(style);
            assert.equal(newJson.root[0].root.val, "");
        });
    });
-
 });
--- a/ts/tests/docx/paragraph/paragraphTests.ts
+++ b/ts/tests/docx/paragraph/paragraphTests.ts
@ -1,12 +1,7 @@
+import { assert, expect } from "chai";
 import * as docx from "../../../docx";
 import { Formatter } from "../../../export/formatter";
 import { Numbering } from "../../../numbering";
-import { assert, expect } from "chai";
-
-function jsonify(obj: Object) {
-    let stringifiedJson = JSON.stringify(obj);
-    return JSON.parse(stringifiedJson);
-}

 describe("Paragraph", () => {
    let paragraph: docx.Paragraph;
@ -18,7 +13,7 @@ describe("Paragraph", () => {
    describe("#constructor()", () => {

        it("should create valid JSON", () => {
-            let stringifiedJson = JSON.stringify(paragraph);
+            const stringifiedJson = JSON.stringify(paragraph);
            let newJson;

            try {
@ -30,89 +25,158 @@ describe("Paragraph", () => {
        });

        it("should create have valid properties", () => {
-            let stringifiedJson = JSON.stringify(paragraph);
-            let newJson = JSON.parse(stringifiedJson);
+            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();
-            let newJson = jsonify(paragraph);
-            assert.equal(newJson.root[0].root[1].root[0].root.val, "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();
-            let newJson = jsonify(paragraph);
-
-            assert.equal(newJson.root[0].root[1].root[0].root.val, "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();
-            let newJson = jsonify(paragraph);
-
-            assert.equal(newJson.root[0].root[1].root[0].root.val, "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();
-            let newJson = jsonify(paragraph);
-
-            assert.equal(newJson.root[0].root[1].root[0].root.val, "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();
-            let newJson = jsonify(paragraph);
-
-            assert.equal(newJson.root[0].root[1].root[0].root.val, "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();
-            let newJson = jsonify(paragraph);
-            assert.equal(newJson.root[0].root[1].rootKey, "w:pBdr");
+            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();
-            let newJson = jsonify(paragraph);
-            assert.equal(newJson.root[0].root[1].root[1].rootKey, "w:br");
+            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"}}]},
+                        ],
+                    }],
+                }],
            });
-
-        it("should add page break with 'page' type", () => {
-            paragraph.pageBreak();
-            let newJson = jsonify(paragraph);
-            assert.equal(newJson.root[0].root[1].root[1].root[0].root.type, "page");
        });
    });

    describe("#bullet()", () => {
        it("should add list paragraph style to JSON", () => {
            paragraph.bullet();
-            let newJson = jsonify(paragraph);
-            assert.equal(newJson.root[0].root[1].root[0].root.val, "ListParagraph");
+            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();
-            let newJson = jsonify(paragraph);
-            assert.isDefined(newJson.root[0].root[2]);
+            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}}]},
+                ],
+            });
        });
    });

@ -124,8 +188,12 @@ describe("Paragraph", () => {
            const letterNumbering = numbering.createConcreteNumbering(numberedAbstract);

            paragraph.setNumbering(letterNumbering, 0);
-            let newJson = jsonify(paragraph);
-            assert.equal(newJson.root[0].root[1].root[0].root.val, "ListParagraph");
+            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", () => {
@ -136,23 +204,89 @@ describe("Paragraph", () => {

            paragraph.setNumbering(letterNumbering, 0);
            const tree = new Formatter().format(paragraph);
-            console.log(JSON.stringify(tree, null, 2));
            expect(tree).to.deep.equal({
                "w:p": [
                    {
                        "w:pPr": [
-                            {"_attr": {}},
-                            {"w:pStyle": [{"_attr": {"w:val": "ListParagraph"}}]},
+                            {"w:pStyle": [{_attr: {"w:val": "ListParagraph"}}]},
                            {
                                "w:numPr": [
-                                    {"w:ilvl": [{"_attr": {"w:val": 0}}]},
-                                    {"w:numId": [{"_attr": {"w:val": letterNumbering.id}}]}
-                                ]
+                                    {"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(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": []}]}],
+            });
        });
    });
 });
--- a/ts/tests/docx/paragraph/spacingTest.ts
+++ b/ts/tests/docx/paragraph/spacingTest.ts
@ -0,0 +1,23 @@
+import { expect } from "chai";
+import { Spacing } from "../../../docx/paragraph/spacing";
+import { Formatter } from "../../../export/formatter";
+
+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}}],
+            });
+        });
+    });
+});
--- a/ts/tests/docx/paragraph/tabStopTests.ts
+++ b/ts/tests/docx/paragraph/tabStopTests.ts
@ -1,10 +1,6 @@
-import { LeftTabStop, MaxRightTabStop } from "../../../docx/paragraph/tab-stop";
 import { assert } from "chai";
-
-function jsonify(obj: Object) {
-    let stringifiedJson = JSON.stringify(obj);
-    return JSON.parse(stringifiedJson);
-}
+import { LeftTabStop, MaxRightTabStop } from "../../../docx/paragraph/tab-stop";
+import { Utility } from "../../utility";

 describe("LeftTabStop", () => {
    let tabStop: LeftTabStop;
@ -15,23 +11,23 @@ describe("LeftTabStop", () => {

    describe("#constructor()", () => {
        it("should create a Tab Stop with correct attributes", () => {
-            let newJson = jsonify(tabStop);
-            let attributes = {
+            const newJson = Utility.jsonify(tabStop);
+            const attributes = {
                val: "left",
-                pos: 100
+                pos: 100,
            };
            assert.equal(JSON.stringify(newJson.root[0].root[0].root), JSON.stringify(attributes));
        });

        it("should create a Tab Stop with w:tab", () => {
-            let newJson = jsonify(tabStop);
+            const newJson = Utility.jsonify(tabStop);
            assert.equal(newJson.root[0].rootKey, "w:tab");
        });
    });
 });

 describe("RightTabStop", () => {
-
+    // TODO
 });

 describe("MaxRightTabStop", () => {
@ -43,17 +39,17 @@ describe("MaxRightTabStop", () => {

    describe("#constructor()", () => {
        it("should create a Tab Stop with correct attributes", () => {
-            let newJson = jsonify(tabStop);
+            const newJson = Utility.jsonify(tabStop);

-            let attributes = {
+            const attributes = {
                val: "right",
-                pos: 9026
+                pos: 9026,
            };
            assert.equal(JSON.stringify(newJson.root[0].root[0].root), JSON.stringify(attributes));
        });

        it("should create a Tab Stop with w:tab", () => {
-            let newJson = jsonify(tabStop);
+            const newJson = Utility.jsonify(tabStop);
            assert.equal(newJson.root[0].rootKey, "w:tab");
        });
    });
--- a/ts/tests/docx/paragraph/unorderedListTests.ts
+++ b/ts/tests/docx/paragraph/unorderedListTests.ts
@ -1,10 +1,6 @@
-import { NumberProperties } from "../../../docx/paragraph/unordered-list";
 import { assert } from "chai";
-
-function jsonify(obj: Object) {
-    let stringifiedJson = JSON.stringify(obj);
-    return JSON.parse(stringifiedJson);
-}
+import { NumberProperties } from "../../../docx/paragraph/unordered-list";
+import { Utility } from "../../utility";

 describe("NumberProperties", () => {
    let numberProperties: NumberProperties;
@ -15,18 +11,18 @@ describe("NumberProperties", () => {

    describe("#constructor()", () => {
        it("should create a Number Properties with correct root key", () => {
-            let newJson = jsonify(numberProperties);
+            const newJson = Utility.jsonify(numberProperties);
            assert.equal(newJson.rootKey, "w:numPr");
        });

        it("should create a Page Break with a Indent Level inside", () => {
-            let newJson = jsonify(numberProperties);
+            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", () => {
-            let newJson = jsonify(numberProperties);
+            const newJson = Utility.jsonify(numberProperties);
            assert.equal(newJson.root[1].rootKey, "w:numId");
            assert.equal(newJson.root[1].root[0].root.val, 5);
        });
--- a/ts/tests/docx/run/breakTests.ts
+++ b/ts/tests/docx/run/breakTests.ts
@ -1,10 +1,6 @@
-import { Break } from "../../../docx/run/break";
 import { assert } from "chai";
-
-function jsonify(obj: Object) {
-    let stringifiedJson = JSON.stringify(obj);
-    return JSON.parse(stringifiedJson);
-}
+import { Break } from "../../../docx/run/break";
+import { Utility } from "../../utility";

 describe("Break", () => {
    let currentBreak: Break;
@ -15,7 +11,7 @@ describe("Break", () => {

    describe("#constructor()", () => {
        it("should create a Break with correct root key", () => {
-            let newJson = jsonify(currentBreak);
+            const newJson = Utility.jsonify(currentBreak);
            assert.equal(newJson.rootKey, "w:br");
        });
    });
--- a/ts/tests/docx/run/run-components/drawingTests.ts
+++ b/ts/tests/docx/run/run-components/drawingTests.ts
@ -0,0 +1,26 @@
+import { assert } from "chai";
+import * as fs from "fs";
+import { Drawing } from "../../../../docx/run/run-components/drawing";
+import { Utility } from "../../../utility";
+
+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));
+        });
+    });
+});
--- a/ts/tests/docx/run/run-components/text.ts
+++ b/ts/tests/docx/run/run-components/text.ts
@ -0,0 +1,22 @@
+import { expect } from "chai";
+import { Text } from "../../../../docx/run/run-components/text";
+import { Formatter } from "../../../../export/formatter";
+
+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",
+            ]});
+        });
+    });
+});
--- a/ts/tests/docx/run/runTest.ts
+++ b/ts/tests/docx/run/runTest.ts
@ -1,11 +1,7 @@
 import { assert, expect } from "chai";
 import { Run } from "../../../docx/run";
-import { TextRun } from "../../../docx/run/text-run";
 import { Formatter } from "../../../export/formatter";
-
-function jsonify(obj: object) {
-    return JSON.parse(JSON.stringify(obj));
-}
+import { Utility } from "../../utility";

 describe("Run", () => {
    let run: Run;
@ -17,7 +13,7 @@ describe("Run", () => {
    describe("#bold()", () => {
        it("it should add bold to the properties", () => {
            run.bold();
-            const newJson = jsonify(run);
+            const newJson = Utility.jsonify(run);
            assert.equal(newJson.root[0].root[0].rootKey, "w:b");
        });
    });
@ -25,7 +21,7 @@ describe("Run", () => {
    describe("#italic()", () => {
        it("it should add italics to the properties", () => {
            run.italic();
-            const newJson = jsonify(run);
+            const newJson = Utility.jsonify(run);
            assert.equal(newJson.root[0].root[0].rootKey, "w:i");
        });
    });
@ -33,15 +29,35 @@ describe("Run", () => {
    describe("#underline()", () => {
        it("it should add underline to the properties", () => {
            run.underline();
-            const newJson = jsonify(run);
+            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 = jsonify(run);
+            const newJson = Utility.jsonify(run);
            assert.equal(newJson.root[0].root[0].rootKey, "w:smallCaps");
        });
    });
@ -49,7 +65,7 @@ describe("Run", () => {
    describe("#caps()", () => {
        it("it should add caps to the properties", () => {
            run.allCaps();
-            const newJson = jsonify(run);
+            const newJson = Utility.jsonify(run);
            assert.equal(newJson.root[0].root[0].rootKey, "w:caps");
        });
    });
@ -57,7 +73,7 @@ describe("Run", () => {
    describe("#strike()", () => {
        it("it should add strike to the properties", () => {
            run.strike();
-            const newJson = jsonify(run);
+            const newJson = Utility.jsonify(run);
            assert.equal(newJson.root[0].root[0].rootKey, "w:strike");
        });
    });
@ -65,7 +81,7 @@ describe("Run", () => {
    describe("#doubleStrike()", () => {
        it("it should add caps to the properties", () => {
            run.doubleStrike();
-            const newJson = jsonify(run);
+            const newJson = Utility.jsonify(run);
            assert.equal(newJson.root[0].root[0].rootKey, "w:dstrike");
        });
    });
@ -73,7 +89,7 @@ describe("Run", () => {
    describe("#break()", () => {
        it("it should add break to the run", () => {
            run.break();
-            const newJson = jsonify(run);
+            const newJson = Utility.jsonify(run);
            assert.equal(newJson.root[1].rootKey, "w:br");
        });
    });
@ -81,7 +97,7 @@ describe("Run", () => {
    describe("#tab()", () => {
        it("it should add break to the run", () => {
            run.tab();
-            const newJson = jsonify(run);
+            const newJson = Utility.jsonify(run);
            assert.equal(newJson.root[1].rootKey, "w:tab");
        });
    });
@ -101,4 +117,40 @@ describe("Run", () => {
            });
        });
    });
+
+    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"}}]}]},
+                ],
+            });
+        });
+    });
 });
--- a/ts/tests/docx/run/scriptTests.ts
+++ b/ts/tests/docx/run/scriptTests.ts
@ -1,10 +1,6 @@
-import { SubScript, SuperScript } from "../../../docx/run/script";
 import { assert } from "chai";
-
-function jsonify(obj: Object) {
-    let stringifiedJson = JSON.stringify(obj);
-    return JSON.parse(stringifiedJson);
-}
+import { SubScript, SuperScript } from "../../../docx/run/script";
+import { Utility } from "../../utility";

 describe("SubScript", () => {
    let subScript: SubScript;
@ -15,15 +11,15 @@ describe("SubScript", () => {

    describe("#constructor()", () => {
        it("should create a Sub Script with correct attributes", () => {
-            let newJson = jsonify(subScript);
-            let attributes = {
-                val: "subscript"
+            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", () => {
-            let newJson = jsonify(subScript);
+            const newJson = Utility.jsonify(subScript);
            assert.equal(newJson.rootKey, "w:vertAlign");
        });
    });
@ -38,15 +34,15 @@ describe("SuperScript", () => {

    describe("#constructor()", () => {
        it("should create a Super Script with correct attributes", () => {
-            let newJson = jsonify(superScript);
-            let attributes = {
-                val: "superscript"
+            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", () => {
-            let newJson = jsonify(superScript);
+            const newJson = Utility.jsonify(superScript);
            assert.equal(newJson.rootKey, "w:vertAlign");
        });
    });
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Dolan	70c4e89a65	Version bump	2017-07-08 21:37:02 +01:00
Dolan	8f632d4ecd	Made XmlableObject non ambient typings to fix typescript problem	2017-07-08 20:45:19 +01:00
Dolan	6784dc1f3d	Updated archiver types	2017-07-08 01:24:25 +01:00
Dolan	fd63a30298	Updated definitions	2017-07-07 16:51:22 +01:00
Dolan	b0a29e26c9	Version bump	2017-07-07 14:36:34 +01:00
Dolan	8826fb010d	Added types to package json	2017-07-07 14:34:03 +01:00
Dolan	97101adb10	Enabled declarations in tsconfig to be true	2017-07-07 14:31:08 +01:00
Dolan	2ec171d4a8	Used my updated typings for archiver 1.3	2017-05-09 18:03:31 +01:00
Dolan	8876bb1fea	updated readme about demos	2017-04-17 19:53:53 +01:00
Dolan	96ca9d9c23	commented out the rm	2017-04-17 16:36:56 +01:00
Dolan	74a65f02fa	remove exit code	2017-04-17 16:07:28 +01:00
Dolan	339c017940	edited rm function	2017-04-17 15:41:03 +01:00
Dolan	969b52ae05	added nojekyll to gh-pages	2017-04-17 13:24:43 +01:00
Dolan	eb8f0f4033	added debugging to deployment	2017-04-17 13:05:02 +01:00
Dolan	d7229eb049	removed rimraf	2017-04-16 12:41:24 +01:00
Dolan	644819ed81	added deployment keys and scripts	2017-04-16 12:22:50 +01:00
Dolan	96fd61d3e4	using stable version of node	2017-04-16 02:25:44 +01:00
Dolan	b96cfe7b19	git fetch added	2017-04-16 01:29:29 +01:00
Dolan	d0e7c97a88	added commit message with merge with gh pages	2017-04-16 01:18:22 +01:00
Dolan	0ede54cfdc	added travis doc deployment solution	2017-04-16 01:12:42 +01:00
Dolan	5be1163549	remove docs in gitignore	2017-04-16 01:07:11 +01:00
Dolan	580f6eb633	fixed tests	2017-04-16 00:44:35 +01:00
Dolan	321be35918	added docs in gitignore	2017-04-16 00:30:27 +01:00
Dolan	45a18742d7	moved documentation to gh-pages branch	2017-04-16 00:22:29 +01:00
Dolan	7e81da404a	updated readme	2017-04-16 00:09:07 +01:00
Dolan	6c2abb4abc	added typedoc generated docs	2017-04-16 00:07:16 +01:00
Dolan	e8b0dbf93b	added docs ignore to npmignore file	2017-04-16 00:04:29 +01:00
Dolan	e59c255d85	added type to pack param	2017-04-15 23:45:27 +01:00
Dolan	17b28cb724	fixed more linting issues	2017-04-15 20:11:54 +01:00
Dolan	410152441b	fixed tslinting issues	2017-04-15 17:54:47 +01:00
Dolan	dfff4b96bd	updated tslint to 5.1.0	2017-04-15 17:47:29 +01:00
Dolan	72cb75a486	added comma	2017-04-15 17:46:56 +01:00
Dolan	53fe1dd988	added typedoc support for generating documentation	2017-04-15 17:46:11 +01:00
Dolan	043219f005	Merge pull request #32 from felipeochoa/keep-lines add keepLines and keepNext support for paragraph formatting	2017-04-15 17:41:11 +01:00
felipe	0453f28951	add keepLines and keepNext support for paragraph formatting This commit adds it to the three places where paragraph formatting can be applied right now (directly on the paragraph, paragraph styles, and bullets/numbering styles). I'm separately adding an entry to the wiki regarding what these methods do (widow/orphan control)	2017-04-14 21:13:11 +02:00
Dolan	94716e081b	Merge pull request #31 from felipeochoa/spacing-bugfix Spacing bugfix	2017-04-14 17:30:54 +01:00
Dolan	30f826fd3d	made a mini app which you can select the demo you want from a list with an interactive prompt.	2017-04-14 15:48:12 +01:00
felipe	99b7a03b8a	update demo2 to test space preservation	2017-04-14 11:09:08 +02:00
felipe	b1c8b2beb8	add xml:space="preserve" to text runs In MS Word 2015 (and possibly others), leading and trailing spaces are ignored in text runs. This means that calling TextRun with leading/trailing space would result in a document that didn't include those spaces. The fix here (per http://officeopenxml.com/WPtext.php) is to include an extra attribute on the "w:t" element that forces word to recognize those spaces.	2017-04-14 11:08:19 +02:00
Dolan	a706455a7c	Merge pull request #30 from felipeochoa/overrides Add support for numbering level overrides	2017-04-12 18:34:07 +01:00
felipe	8c388a95c4	bump patch version	2017-04-12 16:01:26 +02:00
felipe	9a41d78ecb	add an additional demo	2017-04-12 16:00:16 +02:00
felipe	6fc4ad782a	add #overrideLevel method to concrete numberings	2017-04-12 16:00:16 +02:00
felipe	16b9057ac6	prepare Level to be extended for overrides	2017-04-12 15:57:26 +02:00
Dolan Miu	28c62c1ee4	version 2.0.0	2017-04-01 13:31:24 +01:00
Dolan Miu	91a757619e	fixed unit tests	2017-04-01 12:30:27 +01:00
Dolan Miu	f89049e4c1	version bump	2017-04-01 12:23:01 +01:00
Dolan Miu	086f5f5d03	Merge branch 'image-support'	2017-04-01 12:22:23 +01:00
Dolan Miu	a2694f1d7d	edited demo code	2017-04-01 12:21:59 +01:00
Dolan Miu	fd350d53db	fixed some typescript compile issues	2017-04-01 12:18:23 +01:00
Dolan	af48af2854	added error checking and updated demo	2017-03-29 22:57:52 +01:00
Dolan	15009884e3	made image take in IData instead of image path	2017-03-29 22:47:34 +01:00
Dolan Miu	ad462dfe10	added relationships	2017-03-27 01:28:52 +01:00
Dolan Miu	68fe380575	renamed template constant	2017-03-27 01:28:31 +01:00
Dolan Miu	5b2a311ad4	media now adds object into docx /media folder	2017-03-26 20:57:43 +01:00
Dolan	5db2503e7b	added media class and packer to handle it	2017-03-25 21:50:33 +00:00
Dolan	55a1d23f29	fixed missing comma	2017-03-14 11:33:46 +00:00
Dolan	0bfd753a0d	fixed json, missing comma	2017-03-14 11:28:05 +00:00
Dolan	22adabd2d9	updated keywords	2017-03-14 10:51:05 +00:00
Dolan	6d5c89ff47	corrected underline	2017-03-14 10:48:24 +00:00
Dolan	96a9bb1a1e	corrected underline	2017-03-14 10:47:50 +00:00
Dolan	2be00d3f1e	corrected example	2017-03-14 10:38:05 +00:00
Dolan	30b21217a9	added create picture run method	2017-03-13 23:41:14 +00:00
Dolan	260a680f56	Merge branch 'master' into image-support	2017-03-13 23:37:09 +00:00
Dolan	486777b108	named this addRun because I realised Text can be a Run, but also a Picture can be a run	2017-03-13 23:35:24 +00:00
Dolan	3730e2b60e	clean up of packer	2017-03-13 23:30:26 +00:00
Dolan	e7e6d02cc5	Merge pull request #28 from felipeochoa/npm-fixes NPM fixes	2017-03-13 22:38:13 +00:00
felipe	c7b7b585be	fix path to template when installed via npm I'm not sure why, buy app-root-path was not picking up the correct path for this module when installed via NPM. Since we're already using relative paths for imports, I don't think we gain much from using it anyway, so I've changed to using path.resolve instead	2017-03-13 20:40:16 +01:00
felipe	0c128ae4a5	add template to npm bundle	2017-03-13 20:40:16 +01:00
Dolan	d7a70ffe03	use gemnasium rather than david-dm	2017-03-13 16:14:03 +00:00
Dolan	e1c699ec41	Merge pull request #27 from felipeochoa/styles More styles harmony	2017-03-13 12:31:25 +00:00
Dolan	245f0ae2ea	added gitter integration	2017-03-13 12:30:22 +00:00
felipe	762fc0ca9d	added run formatting methods to levels	2017-03-13 12:38:16 +01:00
felipe	457d074a59	added paragraph formatting methods to numbering Level	2017-03-13 12:38:16 +01:00
Dolan	ba80440faf	formatting and correct heading values	2017-03-13 01:21:26 +00:00
Dolan	ae41e22df5	moved Documents section to Wiki. Cleaned up Wiki Added felipeochoa mention removed TOC	2017-03-13 01:19:39 +00:00
Dolan	bf2e5201c8	made usage much more clear	2017-03-13 01:11:11 +00:00
Dolan	2662bcc60b	removed Paragraph from readme, and put it in the Wiki	2017-03-13 01:03:57 +00:00
Dolan	efa4f1933a	moved Text section to Wiki	2017-03-13 00:57:57 +00:00
Dolan	8c58ec2ba4	moved bullet points to Wiki	2017-03-13 00:54:05 +00:00
Dolan	e6ed3a55ff	updated contents	2017-03-13 00:51:01 +00:00
Dolan	69abf509c9	removed tab stops and placed it in the Wiki	2017-03-13 00:50:29 +00:00
Dolan Miu	66eace4a33	added a attribute to graphic	2017-03-13 00:40:39 +00:00
Dolan Miu	eeb2187db4	added source rectangle and stretch in the blip fill	2017-03-13 00:33:59 +00:00
Dolan Miu	fa44acca1b	added the remaining classes required	2017-03-13 00:02:56 +00:00
Dolan Miu	34ce662f70	added basic test for drawing	2017-03-12 23:32:02 +00:00
Dolan Miu	8d72fa5542	added more boilerplate files to drawing	2017-03-12 23:31:43 +00:00
Dolan Miu	64d642b593	Merge branch 'master' into image-support	2017-03-12 21:44:17 +00:00
Dolan Miu	d9e533156f	fixed the build :P removed .docx extension if one is already present	2017-03-12 21:43:52 +00:00
Dolan Miu	90e5cc3ad5	Revert "fixed the build :P removed .docx extension if one is already present" This reverts commit `9f61ca7abe`.	2017-03-12 21:43:15 +00:00
Dolan Miu	9f61ca7abe	fixed the build :P removed .docx extension if one is already present	2017-03-12 21:42:45 +00:00
Dolan Miu	6af79a884c	Merge branch 'master' into image-support	2017-03-12 21:38:38 +00:00
Dolan	353401d148	updated readme to add demo folder	2017-03-12 21:37:36 +00:00
Dolan Miu	f17360d45a	add simple demo page	2017-03-12 21:34:49 +00:00
Dolan Miu	4bc6ed0eda	added more files to drawing	2017-03-12 21:30:46 +00:00
Dolan	bf22866a8d	Merge pull request #26 from felipeochoa/styles Standardizing formatting methods	2017-03-12 21:26:47 +00:00
felipe	a6e40d9d92	tightened type checking for tab stops	2017-03-12 22:06:43 +01:00
felipe	0b78e33444	added #leftTabStop and #maxRightTabStop methods to paragraph styles	2017-03-12 22:05:54 +01:00
felipe	6689f76c28	added #thematicBreak method to paragraph styles	2017-03-12 21:58:12 +01:00
felipe	df8ba1e8b8	added alignment methods to paragraph style	2017-03-12 21:40:01 +01:00
felipe	b3524971ac	clean up imports into paragraph and paragraph style (this prep for importing it from styles)	2017-03-12 21:39:29 +01:00
felipe	1cd681bc2d	added #font method to paragraph styles	2017-03-12 17:53:32 +01:00
felipe	7f4d1bf3e7	added #SubScript and #SuperScript methods to ParagraphStyle	2017-03-12 17:52:03 +01:00
felipe	8c6cd012e7	eliminated duplicate implementation of strikethrough	2017-03-12 17:51:52 +01:00
felipe	371398bc2c	added #strike and #doubleStrike methods to paragraphStyle	2017-03-12 17:44:42 +01:00
felipe	9a90818729	added #smallCaps and #allCaps methods to ParagraphStyle	2017-03-12 17:43:00 +01:00
felipe	90049a31ee	added #style method to runs	2017-03-12 17:35:15 +01:00
felipe	3dbd917667	added #color and #size methods to Run	2017-03-12 17:31:36 +01:00
felipe	d85c6ce56a	allow Run#underline to take style and color arguments	2017-03-12 17:28:52 +01:00
Dolan	db24f67e34	Merge pull request #21 from felipeochoa/tables Tables!	2017-03-11 20:31:57 +00:00
felipe	fb6a4383ff	renamed cell#push to cell#addContent	2017-03-11 21:15:45 +01:00
Dolan Miu	c33cdb450c	added initial constructor	2017-03-11 18:21:31 +00:00
Dolan Miu	62b6b33254	created drawing file and refactored run components in components folder	2017-03-11 16:56:35 +00:00
Dolan	64ab91765a	edited contents	2017-03-11 16:06:09 +00:00
Dolan	c0ba937c3a	simplified readme	2017-03-11 16:05:20 +00:00
felipe	70f4613e1b	appease the linter	2017-03-11 10:30:25 +01:00
felipe	bd9d6b74f5	added Cell#createParagraph method	2017-03-11 10:30:08 +01:00
felipe	bd3eb3e214	move the cell-paragraph validation into prepForXml Instead of forcing table cells to only have a single paragraph as their content, we now check whether they end in a paragraph (and insert one if necessary) during #prepForXml	2017-03-11 10:22:30 +01:00
felipe	c10b576a3a	added fixedWidthLayout option and method	2017-03-11 09:59:29 +01:00
felipe	210b97d00b	added document#createTable	2017-03-11 09:02:36 +01:00
felipe	62a238de84	more sane width management	2017-03-11 09:02:22 +01:00
felipe	7b6f5bbaef	forgot to test #getCell	2017-03-10 17:48:05 +01:00
felipe	a45048a464	fix a handful of strict null errors; make test config also be strict These errors only arose because I didn't run `npm build`, only `npm test`. Then, when I tried building the null checks failed. Keeping the two config fiels in sync will help prevent this issue in the future	2017-03-10 17:45:37 +01:00
felipe	c0b0649f37	added tests for table v1	2017-03-10 17:39:37 +01:00
felipe	e7e5c61a90	clean up initial table attempt (linter, interfaces, etc.)	2017-03-10 17:11:08 +01:00
felipe	f1fb0c4f22	initial attempt at Table	2017-03-10 16:55:39 +01:00
Dolan	0de30f6c59	Merge pull request #19 from felipeochoa/cleanup fix unused imports linter warnings	2017-03-10 15:43:19 +00:00
felipe	599be5bf2b	got a little carried away with the purge! fixed failing errors	2017-03-10 16:35:48 +01:00
felipe	9d7573ed9c	fix unused imports linter warnings	2017-03-10 16:09:21 +01:00
Dolan	738cac0253	Merge pull request #17 from felipeochoa/cleanup More cleanup	2017-03-10 14:53:42 +00:00
felipe	35ddda444a	rename paragraph#createRun to paragraph#createTextRun	2017-03-10 14:44:25 +01:00
felipe	8d11ec3422	add paragraph.createRun method	2017-03-10 14:36:16 +01:00
felipe	ea647d84df	add document.createParagraph method	2017-03-10 14:31:21 +01:00
felipe	8c91c04afa	clean up latentstyles to use modern attribute implementation	2017-03-10 14:31:21 +01:00
felipe	a89718ea83	fix a couple of compiler null warnings	2017-03-10 14:31:21 +01:00
felipe	62911d6e44	make XmlAttributeComponent into a generic class This change brings increased type safety to uses of XmlAttributeComponent. Now the compiler is checkign for us that the properties that get passed in to every subclass match the intended interface, and also that the xmlKeys property -> xml attribute mapping has all the right keys	2017-03-10 14:19:45 +01:00
felipe	766069c7cc	make packers a top-level export	2017-03-10 13:54:49 +01:00
felipe	09f1d473c3	remove lodash from dependencies as it's no longer used	2017-03-10 13:54:44 +01:00
felipe	74ea0f699f	remove npm and install from dependencies These aren't actually needed at run time or build time	2017-03-10 13:54:37 +01:00
Dolan	b00e4fa5b5	moved exporting to the wiki	2017-03-10 11:35:43 +00:00
Dolan	7ffa59d7fa	formatting	2017-03-10 11:27:48 +00:00
Dolan	d662391a64	removed LICENCE in readme. It is already in the repository as the LICENCE file. No need to repeat	2017-03-10 11:26:04 +00:00
Dolan	7a9661c55a	moved examples to Wiki	2017-03-10 11:24:41 +00:00
Dolan	f80a5654b4	adding unused variable checking	2017-03-10 10:33:42 +00:00
Dolan	001b756866	Merge pull request #16 from felipeochoa/cleanup Cleanup	2017-03-10 10:32:05 +00:00
felipe	fd1aab48f7	removed some dead code causing tslint problems	2017-03-10 10:35:38 +01:00
felipe	7ff838357a	removed empty Attributes from ParagraphProperties I checked the spec, and "w:pPr" does not take any attributes. I also converted the paragraph tests to use the deep.equal style to get rid of some more jsonify!	2017-03-10 10:32:40 +01:00
felipe	958b5ea307	improved type annotation for Attributes#prepForXml	2017-03-10 08:58:29 +01:00
felipe	3a6cf81c60	use strict null checks for added type safety From the TypeScript manual "In strict null checking mode, the null and undefined values are not in the domain of every type and are only assignable to themselves and any (the one exception being that undefined is also assignable to void)." In other words, this setting means the compiler will complain if you try to use a variable, but it might be null or undefined. Since the project builds and tests pass with it, I think it's good to turn it on. If it becomes annoying, you can always turn it off later	2017-03-10 08:54:55 +01:00
felipe	10684b34aa	clean up unused imports and a linter warning	2017-03-10 08:52:47 +01:00
felipe	2fc9156e93	remove console.log statements	2017-03-10 08:25:11 +01:00
felipe	c521d0ce63	rename toXml -> prepForXml	2017-03-10 08:23:27 +01:00
Dolan	50ca71087e	reverted back as they’re both buggy	2017-03-10 00:52:43 +00:00
Dolan	72eff21027	used html as markdown version is buggy	2017-03-10 00:51:42 +00:00
Dolan	11bbb5e285	linting	2017-03-09 23:32:52 +00:00
Dolan	18bba1870e	added types for app-root-path	2017-03-09 23:20:37 +00:00
Dolan	c6eef3fd79	tslint fixes	2017-03-09 23:20:28 +00:00
Dolan	06353a6977	linting	2017-03-09 22:57:37 +00:00
Dolan	2b28dd42ee	unclear variable name. please improve	2017-03-09 22:57:30 +00:00
Dolan	7022b39d2e	linting	2017-03-09 22:56:08 +00:00
Dolan	5fac776dca	listing stuff	2017-03-09 22:31:55 +00:00
Dolan	0e8d92f8bb	Merge pull request #14 from felipeochoa/formatting Clean up xml formatting (clearVariables) and introduced toXml()	2017-03-09 22:17:04 +00:00
felipe	30fef5238e	fix some linter warnings	2017-03-09 21:06:54 +01:00
felipe	0fe6ff95a2	fix an incorrect test	2017-03-09 20:49:34 +01:00
felipe	11e918114d	clear out clearVariables! In comes toXml	2017-03-09 20:49:14 +01:00
felipe	879b9163a3	Allow XmlComponent to take strings and remove XmlUnit	2017-03-09 20:21:49 +01:00
felipe	4a2b8a1e04	remove unused XmlProperty code	2017-03-09 19:04:17 +01:00
felipe	d6f5fe0ae8	Remove extraneous multi-property from base numbering object	2017-03-09 17:59:17 +01:00
Dolan	dd4ff944d7	Merge pull request #12 from felipeochoa/styles Styles cleanup	2017-03-09 15:25:19 +00:00
felipe	aac81ffa12	add Styles to top-level exports	2017-03-09 13:27:53 +01:00
felipe	d93432678b	added #createParagraphStyle method to Styles	2017-03-09 13:27:40 +01:00
felipe	ac7799a875	add an #underline method to ParagraphStyle	2017-03-09 13:19:50 +01:00
felipe	766bcabcb8	allow Underline to be called with type and color; fix default	2017-03-09 12:42:19 +01:00
felipe	f06094c91d	clean up underlineTests linter warnings	2017-03-09 12:36:33 +01:00
felipe	3b18b8267a	fix paragraphTests.ts linter warnings	2017-03-09 12:25:59 +01:00
felipe	20ec9b679e	added Spacing for paragraphs and ParagraphStyle	2017-03-09 12:16:49 +01:00
felipe	449d1bc2c3	added fluent formatting methods to ParagraphStyle	2017-03-09 11:27:47 +01:00
felipe	b4dca79d72	added optional name parameter to style constructor	2017-03-09 11:11:07 +01:00
felipe	e6e0658812	clean up style & components attributes	2017-03-09 11:11:07 +01:00
felipe	18ca93e50a	add paragraph#style method to quickly set the style	2017-03-09 11:11:07 +01:00
felipe	f5144e6d72	ts/styles linter warnings	2017-03-09 11:11:07 +01:00
felipe	2684f16579	move indent.ts over to paragraph and add a #indent method	2017-03-09 09:59:48 +01:00