Merge branch 'master' into feat/right-indent

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

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

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

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

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

src/file/paragraph/links/hyperlink.ts

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