diff --git a/.eslintrc b/.eslintrc
index 76b8a957..dce14a12 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -1,5 +1,5 @@
 {
-    "extends": "nfl",
+    "extends": ["nfl", "prettier"],
     "env": {
         "browser": true,
         "mocha": true,
@@ -8,5 +8,22 @@
     "globals": {
         "expect": false,
         "sinon": false
+    },
+    "plugins": [
+        "prettier"
+    ],
+    "rules": {
+        "prettier/prettier": ["error", {
+                "printWidth": 80,
+                "tabWidth": 4,
+                "singleQuote": false,
+                "trailingComma": "none",
+                "bracketSpacing": false,
+                "semi": true,
+                "useTabs": false,
+                "parser": "babylon",
+                "jsxBracketSameLine": false
+            }
+        ]
     }
 }
diff --git a/README.md b/README.md
index b2e08d8e..fd305078 100644
--- a/README.md
+++ b/README.md
@@ -18,6 +18,7 @@ import React from "react";
 import {Helmet} from "react-helmet";
 
 class Application extends React.Component {
+  render () {
     return (
         <div className="application">
             <Helmet>
@@ -28,6 +29,7 @@ class Application extends React.Component {
             ...
         </div>
     );
+  }
 };
 ```
 
@@ -212,6 +214,9 @@ function HTML () {
     <link rel="canonical" href="http://mysite.com/example" />
     <link rel="apple-touch-icon" href="http://mysite.com/img/apple-touch-icon-57x57.png" />
     <link rel="apple-touch-icon" sizes-"72x72" href="http://mysite.com/img/apple-touch-icon-72x72.png" />
+    {locales.map((locale) => {
+        <link rel="alternate" href="http://example.com/{locale}" hrefLang={locale} />
+    })}
 
     {/* multiple script elements */}
     <script src="http://include.com/pathtojs.js" type="text/javascript" />
diff --git a/karma.config.js b/karma.config.js
index d52d63cf..0e38d130 100644
--- a/karma.config.js
+++ b/karma.config.js
@@ -1,6 +1,6 @@
 // Karma configuration
 
-module.exports = function (config) {
+module.exports = function(config) {
     function normalizationBrowserName(browser) {
         return browser.toLowerCase().split(/[ /-]/)[0];
     }
@@ -20,14 +20,9 @@ module.exports = function (config) {
         },
 
         // frameworks to use
-        frameworks: [
-            "chai-sinon",
-            "mocha"
-        ],
+        frameworks: ["chai-sinon", "mocha"],
 
-        files: [
-            "./test/test.js"
-        ],
+        files: ["./test/test.js"],
 
         preprocessors: {
             // add webpack as preprocessor
@@ -37,21 +32,25 @@ module.exports = function (config) {
         coverageReporter: {
             dir: "coverage/json",
             includeAllSources: true,
-            reporters: [{
-                type: "json",
-                subdir: normalizationBrowserName
-            }]
+            reporters: [
+                {
+                    type: "json",
+                    subdir: normalizationBrowserName
+                }
+            ]
         },
 
         webpack: {
             devtool: "inline-source-map",
             module: {
-                rules: [{
-                    test: /\.js$/,
-                    // exclude this dirs from coverage
-                    exclude: [/node_modules/],
-                    loader: "babel-loader"
-                }]
+                rules: [
+                    {
+                        test: /\.js$/,
+                        // exclude this dirs from coverage
+                        exclude: [/node_modules/],
+                        loader: "babel-loader"
+                    }
+                ]
             },
             watch: true
         },
@@ -62,10 +61,7 @@ module.exports = function (config) {
 
         // test results reporter to use
         // possible values: "dots", "progress", "junit", "growl", "coverage"
-        reporters: [
-            "coverage",
-            "spec"
-        ],
+        reporters: ["coverage", "spec"],
 
         // web server port
         port: 9876,
diff --git a/package.json b/package.json
index fd5d1e26..2904d0d7 100644
--- a/package.json
+++ b/package.json
@@ -55,9 +55,11 @@
     "cz-conventional-changelog": "^2.0.0",
     "eslint": "^3.18.0",
     "eslint-config-nfl": "^11.1.0",
+    "eslint-config-prettier": "^2.2.0",
     "eslint-plugin-import": "^2.2.0",
     "eslint-plugin-jsx-a11y": "^4.0.0",
     "eslint-plugin-mocha": "^4.9.0",
+    "eslint-plugin-prettier": "^2.1.2",
     "eslint-plugin-react": "^6.10.2",
     "istanbul": "^0.4.5",
     "karma": "^1.5.0",
@@ -76,6 +78,7 @@
     "karma-webpack": "^2.0.3",
     "mocha": "^3.2.0",
     "phantomjs-prebuilt": "^2.1.14",
+    "prettier": "^1.4.4",
     "react": "^15.x",
     "react-dom": "^15.x",
     "rimraf": "^2.6.1",
@@ -86,7 +89,7 @@
   "scripts": {
     "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s",
     "clean": "rimraf lib coverage es",
-    "lint": "eslint --ignore-path .gitignore -- .",
+    "lint": "eslint --ignore-path .gitignore --fix -- .",
     "test": "cross-env BABEL_ENV=test karma start karma.config.js",
     "posttest": "istanbul report lcov text",
     "pretest": "npm run clean && npm run lint",
diff --git a/src/Helmet.js b/src/Helmet.js
index 3a15593c..0a5e2d47 100644
--- a/src/Helmet.js
+++ b/src/Helmet.js
@@ -11,8 +11,9 @@ import {
 } from "./HelmetUtils.js";
 import {TAG_NAMES, VALID_TAG_NAMES} from "./HelmetConstants.js";
 
-const Helmet = (Component) => class HelmetWrapper extends React.Component {
-    /**
+const Helmet = Component =>
+    class HelmetWrapper extends React.Component {
+        /**
      * @param {Object} base: {"target": "_blank", "href": "http://mysite.com/"}
      * @param {Object} bodyAttributes: {"className": "root"}
      * @param {String} defaultTitle: "Default Title"
@@ -28,232 +29,245 @@ const Helmet = (Component) => class HelmetWrapper extends React.Component {
      * @param {Object} titleAttributes: {"itemprop": "name"}
      * @param {String} titleTemplate: "MySite.com - %s"
      */
-    static propTypes = {
-        base: PropTypes.object,
-        bodyAttributes: PropTypes.object,
-        children: PropTypes.oneOfType([
-            PropTypes.arrayOf(PropTypes.node),
-            PropTypes.node
-        ]),
-        defaultTitle: PropTypes.string,
-        encodeSpecialCharacters: PropTypes.bool,
-        htmlAttributes: PropTypes.object,
-        link: PropTypes.arrayOf(PropTypes.object),
-        meta: PropTypes.arrayOf(PropTypes.object),
-        noscript: PropTypes.arrayOf(PropTypes.object),
-        onChangeClientState: PropTypes.func,
-        script: PropTypes.arrayOf(PropTypes.object),
-        style: PropTypes.arrayOf(PropTypes.object),
-        title: PropTypes.string,
-        titleAttributes: PropTypes.object,
-        titleTemplate: PropTypes.string
-    };
-
-    static defaultProps = {
-        encodeSpecialCharacters: true
-    };
+        static propTypes = {
+            base: PropTypes.object,
+            bodyAttributes: PropTypes.object,
+            children: PropTypes.oneOfType([
+                PropTypes.arrayOf(PropTypes.node),
+                PropTypes.node
+            ]),
+            defaultTitle: PropTypes.string,
+            encodeSpecialCharacters: PropTypes.bool,
+            htmlAttributes: PropTypes.object,
+            link: PropTypes.arrayOf(PropTypes.object),
+            meta: PropTypes.arrayOf(PropTypes.object),
+            noscript: PropTypes.arrayOf(PropTypes.object),
+            onChangeClientState: PropTypes.func,
+            script: PropTypes.arrayOf(PropTypes.object),
+            style: PropTypes.arrayOf(PropTypes.object),
+            title: PropTypes.string,
+            titleAttributes: PropTypes.object,
+            titleTemplate: PropTypes.string
+        };
 
-    // Component.peek comes from react-side-effect:
-    // For testing, you may use a static peek() method available on the returned component.
-    // It lets you get the current state without resetting the mounted instance stack.
-    // Don’t use it for anything other than testing.
-    static peek = Component.peek;
-
-    static rewind = () => {
-        let mappedState = Component.rewind();
-        if (!mappedState) {
-            // provide fallback if mappedState is undefined
-            mappedState = mapStateOnServer({
-                baseTag: [],
-                bodyAttributes: {},
-                encodeSpecialCharacters: true,
-                htmlAttributes: {},
-                linkTags: [],
-                metaTags: [],
-                noscriptTags: [],
-                scriptTags: [],
-                styleTags: [],
-                title: "",
-                titleAttributes: {}
-            });
-        }
+        static defaultProps = {
+            encodeSpecialCharacters: true
+        };
 
-        return mappedState;
-    };
+        // Component.peek comes from react-side-effect:
+        // For testing, you may use a static peek() method available on the returned component.
+        // It lets you get the current state without resetting the mounted instance stack.
+        // Don’t use it for anything other than testing.
+        static peek = Component.peek;
+
+        static rewind = () => {
+            let mappedState = Component.rewind();
+            if (!mappedState) {
+                // provide fallback if mappedState is undefined
+                mappedState = mapStateOnServer({
+                    baseTag: [],
+                    bodyAttributes: {},
+                    encodeSpecialCharacters: true,
+                    htmlAttributes: {},
+                    linkTags: [],
+                    metaTags: [],
+                    noscriptTags: [],
+                    scriptTags: [],
+                    styleTags: [],
+                    title: "",
+                    titleAttributes: {}
+                });
+            }
 
-    static set canUseDOM(canUseDOM) {
-        Component.canUseDOM = canUseDOM;
-    }
+            return mappedState;
+        };
 
-    shouldComponentUpdate(nextProps) {
-        return !deepEqual(this.props, nextProps);
-    }
+        static set canUseDOM(canUseDOM) {
+            Component.canUseDOM = canUseDOM;
+        }
 
-    mapNestedChildrenToProps(child, nestedChildren) {
-        if (!nestedChildren) {
-            return null;
+        shouldComponentUpdate(nextProps) {
+            return !deepEqual(this.props, nextProps);
         }
 
-        switch (child.type) {
-            case TAG_NAMES.SCRIPT:
-            case TAG_NAMES.NOSCRIPT:
-                return {
-                    innerHTML: nestedChildren
-                };
+        mapNestedChildrenToProps(child, nestedChildren) {
+            if (!nestedChildren) {
+                return null;
+            }
 
-            case TAG_NAMES.STYLE:
-                return {
-                    cssText: nestedChildren
-                };
-        }
+            switch (child.type) {
+                case TAG_NAMES.SCRIPT:
+                case TAG_NAMES.NOSCRIPT:
+                    return {
+                        innerHTML: nestedChildren
+                    };
 
-        throw new Error(`<${child.type} /> elements are self-closing and can not contain children. Refer to our API for more information.`);
-    }
-
-    flattenArrayTypeChildren({
-        child,
-        arrayTypeChildren,
-        newChildProps,
-        nestedChildren
-    }) {
-        return {
-            ...arrayTypeChildren,
-            [child.type]: [
-                ...arrayTypeChildren[child.type] || [],
-                {
-                    ...newChildProps,
-                    ...this.mapNestedChildrenToProps(child, nestedChildren)
-                }
-            ]
-        };
-    }
-
-    mapObjectTypeChildren({
-        child,
-        newProps,
-        newChildProps,
-        nestedChildren
-    }) {
-        switch (child.type) {
-            case TAG_NAMES.TITLE:
-                return {
-                    ...newProps,
-                    [child.type]: nestedChildren,
-                    titleAttributes: {...newChildProps}
-                };
+                case TAG_NAMES.STYLE:
+                    return {
+                        cssText: nestedChildren
+                    };
+            }
 
-            case TAG_NAMES.BODY:
-                return {
-                    ...newProps,
-                    bodyAttributes: {...newChildProps}
-                };
+            throw new Error(
+                `<${child.type} /> elements are self-closing and can not contain children. Refer to our API for more information.`
+            );
+        }
 
-            case TAG_NAMES.HTML:
-                return {
-                    ...newProps,
-                    htmlAttributes: {...newChildProps}
-                };
+        flattenArrayTypeChildren({
+            child,
+            arrayTypeChildren,
+            newChildProps,
+            nestedChildren
+        }) {
+            return {
+                ...arrayTypeChildren,
+                [child.type]: [
+                    ...(arrayTypeChildren[child.type] || []),
+                    {
+                        ...newChildProps,
+                        ...this.mapNestedChildrenToProps(child, nestedChildren)
+                    }
+                ]
+            };
         }
 
-        return {
-            ...newProps,
-            [child.type]: {...newChildProps}
-        };
-    }
+        mapObjectTypeChildren({
+            child,
+            newProps,
+            newChildProps,
+            nestedChildren
+        }) {
+            switch (child.type) {
+                case TAG_NAMES.TITLE:
+                    return {
+                        ...newProps,
+                        [child.type]: nestedChildren,
+                        titleAttributes: {...newChildProps}
+                    };
+
+                case TAG_NAMES.BODY:
+                    return {
+                        ...newProps,
+                        bodyAttributes: {...newChildProps}
+                    };
+
+                case TAG_NAMES.HTML:
+                    return {
+                        ...newProps,
+                        htmlAttributes: {...newChildProps}
+                    };
+            }
+
+            return {
+                ...newProps,
+                [child.type]: {...newChildProps}
+            };
+        }
 
-    mapArrayTypeChildrenToProps(arrayTypeChildren, newProps) {
-        let newFlattenedProps = {...newProps};
+        mapArrayTypeChildrenToProps(arrayTypeChildren, newProps) {
+            let newFlattenedProps = {...newProps};
 
-        Object.keys(arrayTypeChildren)
-            .forEach(arrayChildName => {
+            Object.keys(arrayTypeChildren).forEach(arrayChildName => {
                 newFlattenedProps = {
                     ...newFlattenedProps,
                     [arrayChildName]: arrayTypeChildren[arrayChildName]
                 };
             });
 
-        return newFlattenedProps;
-    }
+            return newFlattenedProps;
+        }
 
-    warnOnInvalidChildren(child, nestedChildren) {
-        if (
-            process.env.NODE_ENV !== "production"
-        ) {
-            if (!VALID_TAG_NAMES.some(name => child.type === name)) {
-                if (typeof child.type === "function") {
-                    return warn(`You may be attempting to nest <Helmet> components within each other, which is not allowed. Refer to our API for more information.`);
+        warnOnInvalidChildren(child, nestedChildren) {
+            if (process.env.NODE_ENV !== "production") {
+                if (!VALID_TAG_NAMES.some(name => child.type === name)) {
+                    if (typeof child.type === "function") {
+                        return warn(
+                            `You may be attempting to nest <Helmet> components within each other, which is not allowed. Refer to our API for more information.`
+                        );
+                    }
+
+                    return warn(
+                        `Only elements types ${VALID_TAG_NAMES.join(
+                            ", "
+                        )} are allowed. Helmet does not support rendering <${child.type}> elements. Refer to our API for more information.`
+                    );
                 }
 
-                return warn(`Only elements types ${VALID_TAG_NAMES.join(", ")} are allowed. Helmet does not support rendering <${child.type}> elements. Refer to our API for more information.`);
+                if (
+                    nestedChildren &&
+                    typeof nestedChildren !== "string" &&
+                    (!Array.isArray(nestedChildren) ||
+                        nestedChildren.some(
+                            nestedChild => typeof nestedChild !== "string"
+                        ))
+                ) {
+                    throw new Error(
+                        `Helmet expects a string as a child of <${child.type}>. Did you forget to wrap your children in braces? ( <${child.type}>{\`\`}</${child.type}> ) Refer to our API for more information.`
+                    );
+                }
             }
 
-            if (
-                nestedChildren &&
-                typeof nestedChildren !== "string" &&
-                (
-                    !Array.isArray(nestedChildren) || nestedChildren.some(nestedChild => typeof nestedChild !== "string")
-                )
-            ) {
-                throw new Error(`Helmet expects a string as a child of <${child.type}>. Did you forget to wrap your children in braces? ( <${child.type}>{\`\`}</${child.type}> ) Refer to our API for more information.`);
-            }
+            return true;
         }
 
-        return true;
-    }
+        mapChildrenToProps(children, newProps) {
+            let arrayTypeChildren = {};
 
-    mapChildrenToProps(children, newProps) {
-        let arrayTypeChildren = {};
+            React.Children.forEach(children, child => {
+                if (!child || !child.props) {
+                    return;
+                }
 
-        React.Children.forEach(children, (child) => {
-            if (!child || !child.props) {
-                return;
-            }
+                const {children: nestedChildren, ...childProps} = child.props;
+                const newChildProps = convertReactPropstoHtmlAttributes(
+                    childProps
+                );
+
+                this.warnOnInvalidChildren(child, nestedChildren);
+
+                switch (child.type) {
+                    case TAG_NAMES.LINK:
+                    case TAG_NAMES.META:
+                    case TAG_NAMES.NOSCRIPT:
+                    case TAG_NAMES.SCRIPT:
+                    case TAG_NAMES.STYLE:
+                        arrayTypeChildren = this.flattenArrayTypeChildren({
+                            child,
+                            arrayTypeChildren,
+                            newChildProps,
+                            nestedChildren
+                        });
+                        break;
+
+                    default:
+                        newProps = this.mapObjectTypeChildren({
+                            child,
+                            newProps,
+                            newChildProps,
+                            nestedChildren
+                        });
+                        break;
+                }
+            });
 
-            const {children: nestedChildren, ...childProps} = child.props;
-            const newChildProps = convertReactPropstoHtmlAttributes(childProps);
+            newProps = this.mapArrayTypeChildrenToProps(
+                arrayTypeChildren,
+                newProps
+            );
+            return newProps;
+        }
 
-            this.warnOnInvalidChildren(child, nestedChildren);
+        render() {
+            const {children, ...props} = this.props;
+            let newProps = {...props};
 
-            switch (child.type) {
-                case TAG_NAMES.LINK:
-                case TAG_NAMES.META:
-                case TAG_NAMES.NOSCRIPT:
-                case TAG_NAMES.SCRIPT:
-                case TAG_NAMES.STYLE:
-                    arrayTypeChildren = this.flattenArrayTypeChildren({
-                        child,
-                        arrayTypeChildren,
-                        newChildProps,
-                        nestedChildren
-                    });
-                    break;
-
-                default:
-                    newProps = this.mapObjectTypeChildren({
-                        child,
-                        newProps,
-                        newChildProps,
-                        nestedChildren
-                    });
-                    break;
+            if (children) {
+                newProps = this.mapChildrenToProps(children, newProps);
             }
-        });
-
-        newProps = this.mapArrayTypeChildrenToProps(arrayTypeChildren, newProps);
-        return newProps;
-    }
-
-    render() {
-        const {children, ...props} = this.props;
-        let newProps = {...props};
 
-        if (children) {
-            newProps = this.mapChildrenToProps(children, newProps);
+            return <Component {...newProps} />;
         }
-
-        return <Component {...newProps} />;
-    }
-};
+    };
 
 const NullComponent = () => null;
 
diff --git a/src/HelmetConstants.js b/src/HelmetConstants.js
index 4a9026b8..26ae447a 100644
--- a/src/HelmetConstants.js
+++ b/src/HelmetConstants.js
@@ -17,9 +17,9 @@ export const TAG_NAMES = {
     TITLE: "title"
 };
 
-export const VALID_TAG_NAMES = Object
-    .keys(TAG_NAMES)
-    .map(name => TAG_NAMES[name]);
+export const VALID_TAG_NAMES = Object.keys(TAG_NAMES).map(
+    name => TAG_NAMES[name]
+);
 
 export const TAG_PROPERTIES = {
     CHARSET: "charset",
@@ -36,14 +36,14 @@ export const TAG_PROPERTIES = {
 };
 
 export const REACT_TAG_MAP = {
-    "accesskey": "accessKey",
-    "charset": "charSet",
-    "class": "className",
-    "contenteditable": "contentEditable",
-    "contextmenu": "contextMenu",
+    accesskey: "accessKey",
+    charset: "charSet",
+    class: "className",
+    contenteditable: "contentEditable",
+    contextmenu: "contextMenu",
     "http-equiv": "httpEquiv",
-    "itemprop": "itemProp",
-    "tabindex": "tabIndex"
+    itemprop: "itemProp",
+    tabindex: "tabIndex"
 };
 
 export const HELMET_PROPS = {
@@ -53,13 +53,15 @@ export const HELMET_PROPS = {
     TITLE_TEMPLATE: "titleTemplate"
 };
 
-export const HTML_TAG_MAP = Object
-    .keys(REACT_TAG_MAP)
-    .reduce((obj, key) => {
-        obj[REACT_TAG_MAP[key]] = key;
-        return obj;
-    }, {});
+export const HTML_TAG_MAP = Object.keys(REACT_TAG_MAP).reduce((obj, key) => {
+    obj[REACT_TAG_MAP[key]] = key;
+    return obj;
+}, {});
 
-export const SELF_CLOSING_TAGS = [TAG_NAMES.NOSCRIPT, TAG_NAMES.SCRIPT, TAG_NAMES.STYLE];
+export const SELF_CLOSING_TAGS = [
+    TAG_NAMES.NOSCRIPT,
+    TAG_NAMES.SCRIPT,
+    TAG_NAMES.STYLE
+];
 
 export const HELMET_ATTRIBUTE = "data-react-helmet";
diff --git a/src/HelmetUtils.js b/src/HelmetUtils.js
index 09be73ed..5638f5c8 100644
--- a/src/HelmetUtils.js
+++ b/src/HelmetUtils.js
@@ -17,29 +17,38 @@ const encodeSpecialCharacters = (str, encode = true) => {
     }
 
     return String(str)
-            .replace(/&/g, "&amp;")
-            .replace(/</g, "&lt;")
-            .replace(/>/g, "&gt;")
-            .replace(/"/g, "&quot;")
-            .replace(/'/g, "&#x27;");
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#x27;");
 };
 
-const getTitleFromPropsList = (propsList) => {
+const getTitleFromPropsList = propsList => {
     const innermostTitle = getInnermostProperty(propsList, TAG_NAMES.TITLE);
-    const innermostTemplate = getInnermostProperty(propsList, HELMET_PROPS.TITLE_TEMPLATE);
+    const innermostTemplate = getInnermostProperty(
+        propsList,
+        HELMET_PROPS.TITLE_TEMPLATE
+    );
 
     if (innermostTemplate && innermostTitle) {
         // use function arg to avoid need to escape $ characters
         return innermostTemplate.replace(/%s/g, () => innermostTitle);
     }
 
-    const innermostDefaultTitle = getInnermostProperty(propsList, HELMET_PROPS.DEFAULT_TITLE);
+    const innermostDefaultTitle = getInnermostProperty(
+        propsList,
+        HELMET_PROPS.DEFAULT_TITLE
+    );
 
     return innermostTitle || innermostDefaultTitle || undefined;
 };
 
-const getOnChangeClientState = (propsList) => {
-    return getInnermostProperty(propsList, HELMET_PROPS.ON_CHANGE_CLIENT_STATE) ||(() => {});
+const getOnChangeClientState = propsList => {
+    return (
+        getInnermostProperty(propsList, HELMET_PROPS.ON_CHANGE_CLIENT_STATE) ||
+        (() => {})
+    );
 };
 
 const getAttributesFromPropsList = (tagType, propsList) => {
@@ -64,8 +73,11 @@ const getBaseTagFromPropsList = (primaryAttributes, propsList) => {
                     const attributeKey = keys[i];
                     const lowerCaseAttributeKey = attributeKey.toLowerCase();
 
-                    if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 &&
-                        tag[lowerCaseAttributeKey]) {
+                    if (
+                        primaryAttributes.indexOf(lowerCaseAttributeKey) !==
+                            -1 &&
+                        tag[lowerCaseAttributeKey]
+                    ) {
                         return innermostBaseTag.concat(tag);
                     }
                 }
@@ -80,12 +92,16 @@ const getTagsFromPropsList = (tagName, primaryAttributes, propsList) => {
     const approvedSeenTags = {};
 
     return propsList
-        .filter((props) => {
+        .filter(props => {
             if (Array.isArray(props[tagName])) {
                 return true;
             }
             if (typeof props[tagName] !== "undefined") {
-                warn(`Helmet: ${tagName} should be of type "Array". Instead found type "${typeof props[tagName]}"`);
+                warn(
+                    `Helmet: ${tagName} should be of type "Array". Instead found type "${typeof props[
+                        tagName
+                    ]}"`
+                );
             }
             return false;
         })
@@ -94,63 +110,65 @@ const getTagsFromPropsList = (tagName, primaryAttributes, propsList) => {
         .reduce((approvedTags, instanceTags) => {
             const instanceSeenTags = {};
 
-            instanceTags.filter(tag => {
-                let primaryAttributeKey;
-                const keys = Object.keys(tag);
-                for (let i = 0; i < keys.length; i++) {
-                    const attributeKey = keys[i];
-                    const lowerCaseAttributeKey = attributeKey.toLowerCase();
-
-                    // Special rule with link tags, since rel and href are both primary tags, rel takes priority
-                    if (
-                        primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 &&
-                        !(
-                            primaryAttributeKey === TAG_PROPERTIES.REL &&
-                            tag[primaryAttributeKey].toLowerCase() === "canonical"
-                        ) &&
-                        !(
-                            lowerCaseAttributeKey === TAG_PROPERTIES.REL &&
-                            tag[lowerCaseAttributeKey].toLowerCase() === "stylesheet"
-                        )
-                    ) {
-                        primaryAttributeKey = lowerCaseAttributeKey;
-                    }
-                    // Special case for innerHTML which doesn't work lowercased
-                    if (
-                        primaryAttributes.indexOf(attributeKey) !== -1 &&
-                        (
-                            attributeKey === TAG_PROPERTIES.INNER_HTML ||
-                            attributeKey === TAG_PROPERTIES.CSS_TEXT ||
-                            attributeKey === TAG_PROPERTIES.ITEM_PROP
-                        )
-                    ) {
-                        primaryAttributeKey = attributeKey;
+            instanceTags
+                .filter(tag => {
+                    let primaryAttributeKey;
+                    const keys = Object.keys(tag);
+                    for (let i = 0; i < keys.length; i++) {
+                        const attributeKey = keys[i];
+                        const lowerCaseAttributeKey = attributeKey.toLowerCase();
+
+                        // Special rule with link tags, since rel and href are both primary tags, rel takes priority
+                        if (
+                            primaryAttributes.indexOf(lowerCaseAttributeKey) !==
+                                -1 &&
+                            !(
+                                primaryAttributeKey === TAG_PROPERTIES.REL &&
+                                tag[primaryAttributeKey].toLowerCase() ===
+                                    "canonical"
+                            ) &&
+                            !(
+                                lowerCaseAttributeKey === TAG_PROPERTIES.REL &&
+                                tag[lowerCaseAttributeKey].toLowerCase() ===
+                                    "stylesheet"
+                            )
+                        ) {
+                            primaryAttributeKey = lowerCaseAttributeKey;
+                        }
+                        // Special case for innerHTML which doesn't work lowercased
+                        if (
+                            primaryAttributes.indexOf(attributeKey) !== -1 &&
+                            (attributeKey === TAG_PROPERTIES.INNER_HTML ||
+                                attributeKey === TAG_PROPERTIES.CSS_TEXT ||
+                                attributeKey === TAG_PROPERTIES.ITEM_PROP)
+                        ) {
+                            primaryAttributeKey = attributeKey;
+                        }
                     }
-                }
 
-                if (!primaryAttributeKey || !tag[primaryAttributeKey]) {
-                    return false;
-                }
+                    if (!primaryAttributeKey || !tag[primaryAttributeKey]) {
+                        return false;
+                    }
 
-                const value = tag[primaryAttributeKey].toLowerCase();
+                    const value = tag[primaryAttributeKey].toLowerCase();
 
-                if (!approvedSeenTags[primaryAttributeKey]) {
-                    approvedSeenTags[primaryAttributeKey] = {};
-                }
+                    if (!approvedSeenTags[primaryAttributeKey]) {
+                        approvedSeenTags[primaryAttributeKey] = {};
+                    }
 
-                if (!instanceSeenTags[primaryAttributeKey]) {
-                    instanceSeenTags[primaryAttributeKey] = {};
-                }
+                    if (!instanceSeenTags[primaryAttributeKey]) {
+                        instanceSeenTags[primaryAttributeKey] = {};
+                    }
 
-                if (!approvedSeenTags[primaryAttributeKey][value]) {
-                    instanceSeenTags[primaryAttributeKey][value] = true;
-                    return true;
-                }
+                    if (!approvedSeenTags[primaryAttributeKey][value]) {
+                        instanceSeenTags[primaryAttributeKey][value] = true;
+                        return true;
+                    }
 
-                return false;
-            })
-            .reverse()
-            .forEach(tag => approvedTags.push(tag));
+                    return false;
+                })
+                .reverse()
+                .forEach(tag => approvedTags.push(tag));
 
             // Update seen tags with tags from this instance
             const keys = Object.keys(instanceSeenTags);
@@ -182,46 +200,62 @@ const getInnermostProperty = (propsList, property) => {
     return null;
 };
 
-const reducePropsToState = (propsList) => ({
-    baseTag: getBaseTagFromPropsList([
-        TAG_PROPERTIES.HREF
-    ], propsList),
+const reducePropsToState = propsList => ({
+    baseTag: getBaseTagFromPropsList([TAG_PROPERTIES.HREF], propsList),
     bodyAttributes: getAttributesFromPropsList(ATTRIBUTE_NAMES.BODY, propsList),
-    encode: getInnermostProperty(propsList, HELMET_PROPS.ENCODE_SPECIAL_CHARACTERS),
+    encode: getInnermostProperty(
+        propsList,
+        HELMET_PROPS.ENCODE_SPECIAL_CHARACTERS
+    ),
     htmlAttributes: getAttributesFromPropsList(ATTRIBUTE_NAMES.HTML, propsList),
-    linkTags: getTagsFromPropsList(TAG_NAMES.LINK, [
-        TAG_PROPERTIES.REL,
-        TAG_PROPERTIES.HREF,
-        TAG_PROPERTIES.ONLOAD
-    ], propsList),
-    metaTags: getTagsFromPropsList(TAG_NAMES.META, [
-        TAG_PROPERTIES.NAME,
-        TAG_PROPERTIES.CHARSET,
-        TAG_PROPERTIES.HTTPEQUIV,
-        TAG_PROPERTIES.PROPERTY,
-        TAG_PROPERTIES.ITEM_PROP
-    ], propsList),
-    noscriptTags: getTagsFromPropsList(TAG_NAMES.NOSCRIPT, [
-        TAG_PROPERTIES.INNER_HTML
-    ], propsList),
+    linkTags: getTagsFromPropsList(
+        TAG_NAMES.LINK,
+        [TAG_PROPERTIES.REL, TAG_PROPERTIES.HREF, TAG_PROPERTIES.ONLOAD],
+        propsList
+    ),
+    metaTags: getTagsFromPropsList(
+        TAG_NAMES.META,
+        [
+            TAG_PROPERTIES.NAME,
+            TAG_PROPERTIES.CHARSET,
+            TAG_PROPERTIES.HTTPEQUIV,
+            TAG_PROPERTIES.PROPERTY,
+            TAG_PROPERTIES.ITEM_PROP
+        ],
+        propsList
+    ),
+    noscriptTags: getTagsFromPropsList(
+        TAG_NAMES.NOSCRIPT,
+        [TAG_PROPERTIES.INNER_HTML],
+        propsList
+    ),
     onChangeClientState: getOnChangeClientState(propsList),
-    scriptTags: getTagsFromPropsList(TAG_NAMES.SCRIPT, [
-        TAG_PROPERTIES.SRC,
-        TAG_PROPERTIES.INNER_HTML
-    ], propsList),
-    styleTags: getTagsFromPropsList(TAG_NAMES.STYLE, [
-        TAG_PROPERTIES.CSS_TEXT
-    ], propsList),
+    scriptTags: getTagsFromPropsList(
+        TAG_NAMES.SCRIPT,
+        [TAG_PROPERTIES.SRC, TAG_PROPERTIES.INNER_HTML],
+        propsList
+    ),
+    styleTags: getTagsFromPropsList(
+        TAG_NAMES.STYLE,
+        [TAG_PROPERTIES.CSS_TEXT],
+        propsList
+    ),
     title: getTitleFromPropsList(propsList),
-    titleAttributes: getAttributesFromPropsList(ATTRIBUTE_NAMES.TITLE, propsList)
+    titleAttributes: getAttributesFromPropsList(
+        ATTRIBUTE_NAMES.TITLE,
+        propsList
+    )
 });
 
 const requestIdleCallback = (() => {
-    if (typeof window !== "undefined" && typeof window.requestIdleCallback !== "undefined") {
+    if (
+        typeof window !== "undefined" &&
+        typeof window.requestIdleCallback !== "undefined"
+    ) {
         return window.requestIdleCallback;
     }
 
-    return (cb) => {
+    return cb => {
         const start = Date.now();
         return setTimeout(() => {
             cb({
@@ -235,20 +269,23 @@ const requestIdleCallback = (() => {
 })();
 
 const cancelIdleCallback = (() => {
-    if (typeof window !== "undefined" && typeof window.cancelIdleCallback !== "undefined") {
+    if (
+        typeof window !== "undefined" &&
+        typeof window.cancelIdleCallback !== "undefined"
+    ) {
         return window.cancelIdleCallback;
     }
 
-    return (id) => clearTimeout(id);
+    return id => clearTimeout(id);
 })();
 
-const warn = (msg) => {
+const warn = msg => {
     return console && typeof console.warn === "function" && console.warn(msg);
 };
 
 let _helmetIdleCallback = null;
 
-const handleClientStateChange = (newState) => {
+const handleClientStateChange = newState => {
     const {
         baseTag,
         bodyAttributes,
@@ -301,9 +338,15 @@ const handleClientStateChange = (newState) => {
     });
 };
 
+const flattenArray = possibleArray => {
+    return Array.isArray(possibleArray)
+        ? possibleArray.join("")
+        : possibleArray;
+};
+
 const updateTitle = (title, attributes) => {
     if (typeof title !== "undefined" && document.title !== title) {
-        document.title = Array.isArray(title) ? title.join("") : title;
+        document.title = flattenArray(title);
     }
 
     updateAttributes(TAG_NAMES.TITLE, attributes);
@@ -317,7 +360,9 @@ const updateAttributes = (tagName, attributes) => {
     }
 
     const helmetAttributeString = elementTag.getAttribute(HELMET_ATTRIBUTE);
-    const helmetAttributes = helmetAttributeString ? helmetAttributeString.split(",") : [];
+    const helmetAttributes = helmetAttributeString
+        ? helmetAttributeString.split(",")
+        : [];
     const attributesToRemove = [].concat(helmetAttributes);
     const attributeKeys = Object.keys(attributes);
 
@@ -345,14 +390,18 @@ const updateAttributes = (tagName, attributes) => {
 
     if (helmetAttributes.length === attributesToRemove.length) {
         elementTag.removeAttribute(HELMET_ATTRIBUTE);
-    } else if (elementTag.getAttribute(HELMET_ATTRIBUTE) !== attributeKeys.join(",")) {
+    } else if (
+        elementTag.getAttribute(HELMET_ATTRIBUTE) !== attributeKeys.join(",")
+    ) {
         elementTag.setAttribute(HELMET_ATTRIBUTE, attributeKeys.join(","));
     }
 };
 
 const updateTags = (type, tags) => {
     const headElement = document.head || document.querySelector(TAG_NAMES.HEAD);
-    const tagNodes = headElement.querySelectorAll(`${type}[${HELMET_ATTRIBUTE}]`);
+    const tagNodes = headElement.querySelectorAll(
+        `${type}[${HELMET_ATTRIBUTE}]`
+    );
     const oldTags = Array.prototype.slice.call(tagNodes);
     const newTags = [];
     let indexToDelete;
@@ -369,10 +418,14 @@ const updateTags = (type, tags) => {
                         if (newElement.styleSheet) {
                             newElement.styleSheet.cssText = tag.cssText;
                         } else {
-                            newElement.appendChild(document.createTextNode(tag.cssText));
+                            newElement.appendChild(
+                                document.createTextNode(tag.cssText)
+                            );
                         }
                     } else {
-                        const value = (typeof tag[attribute] === "undefined") ? "" : tag[attribute];
+                        const value = typeof tag[attribute] === "undefined"
+                            ? ""
+                            : tag[attribute];
                         newElement.setAttribute(attribute, value);
                     }
                 }
@@ -381,10 +434,12 @@ const updateTags = (type, tags) => {
             newElement.setAttribute(HELMET_ATTRIBUTE, "true");
 
             // Remove a duplicate tag from domTagstoRemove, so it isn't cleared.
-            if (oldTags.some((existingTag, index) => {
-                indexToDelete = index;
-                return newElement.isEqualNode(existingTag);
-            })) {
+            if (
+                oldTags.some((existingTag, index) => {
+                    indexToDelete = index;
+                    return newElement.isEqualNode(existingTag);
+                })
+            ) {
                 oldTags.splice(indexToDelete, 1);
             } else {
                 newTags.push(newElement);
@@ -401,8 +456,8 @@ const updateTags = (type, tags) => {
     };
 };
 
-const generateElementAttributesAsString = (attributes) => Object.keys(attributes)
-    .reduce((str, key) => {
+const generateElementAttributesAsString = attributes =>
+    Object.keys(attributes).reduce((str, key) => {
         const attr = typeof attributes[key] !== "undefined"
             ? `${key}="${attributes[key]}"`
             : `${key}`;
@@ -411,38 +466,57 @@ const generateElementAttributesAsString = (attributes) => Object.keys(attributes
 
 const generateTitleAsString = (type, title, attributes, encode) => {
     const attributeString = generateElementAttributesAsString(attributes);
+    const flattenedTitle = flattenArray(title);
     return attributeString
-        ? `<${type} ${HELMET_ATTRIBUTE}="true" ${attributeString}>${encodeSpecialCharacters(title, encode)}</${type}>`
-        : `<${type} ${HELMET_ATTRIBUTE}="true">${encodeSpecialCharacters(title, encode)}</${type}>`;
+        ? `<${type} ${HELMET_ATTRIBUTE}="true" ${attributeString}>${encodeSpecialCharacters(
+              flattenedTitle,
+              encode
+          )}</${type}>`
+        : `<${type} ${HELMET_ATTRIBUTE}="true">${encodeSpecialCharacters(
+              flattenedTitle,
+              encode
+          )}</${type}>`;
 };
 
-const generateTagsAsString = (type, tags, encode) => tags.reduce((str, tag) => {
-    const attributeHtml = Object.keys(tag)
-        .filter(attribute => !(attribute === TAG_PROPERTIES.INNER_HTML || attribute === TAG_PROPERTIES.CSS_TEXT))
-        .reduce((string, attribute) => {
-            const attr = typeof tag[attribute] === "undefined"
-                ? attribute
-                : `${attribute}="${encodeSpecialCharacters(tag[attribute], encode)}"`;
-            return string ? `${string} ${attr}` : attr;
-        }, "");
-
-    const tagContent = tag.innerHTML || tag.cssText || "";
-
-    const isSelfClosing = SELF_CLOSING_TAGS.indexOf(type) === -1;
-
-    return `${str}<${type} ${HELMET_ATTRIBUTE}="true" ${attributeHtml}${isSelfClosing ? `/>` : `>${tagContent}</${type}>`}`;
-}, "");
+const generateTagsAsString = (type, tags, encode) =>
+    tags.reduce((str, tag) => {
+        const attributeHtml = Object.keys(tag)
+            .filter(
+                attribute =>
+                    !(
+                        attribute === TAG_PROPERTIES.INNER_HTML ||
+                        attribute === TAG_PROPERTIES.CSS_TEXT
+                    )
+            )
+            .reduce((string, attribute) => {
+                const attr = typeof tag[attribute] === "undefined"
+                    ? attribute
+                    : `${attribute}="${encodeSpecialCharacters(
+                          tag[attribute],
+                          encode
+                      )}"`;
+                return string ? `${string} ${attr}` : attr;
+            }, "");
+
+        const tagContent = tag.innerHTML || tag.cssText || "";
+
+        const isSelfClosing = SELF_CLOSING_TAGS.indexOf(type) === -1;
+
+        return `${str}<${type} ${HELMET_ATTRIBUTE}="true" ${attributeHtml}${isSelfClosing
+            ? `/>`
+            : `>${tagContent}</${type}>`}`;
+    }, "");
 
 const convertElementAttributestoReactProps = (attributes, initProps = {}) => {
     return Object.keys(attributes).reduce((obj, key) => {
-        obj[(REACT_TAG_MAP[key] || key)] = attributes[key];
+        obj[REACT_TAG_MAP[key] || key] = attributes[key];
         return obj;
     }, initProps);
 };
 
 const convertReactPropstoHtmlAttributes = (props, initAttributes = {}) => {
     return Object.keys(props).reduce((obj, key) => {
-        obj[(HTML_TAG_MAP[key] || key)] = props[key];
+        obj[HTML_TAG_MAP[key] || key] = props[key];
         return obj;
     }, initAttributes);
 };
@@ -458,32 +532,48 @@ const generateTitleAsReactComponent = (type, title, attributes) => {
     return [React.createElement(TAG_NAMES.TITLE, props, title)];
 };
 
-const generateTagsAsReactComponent = (type, tags) => tags.map((tag, i) => {
-    const mappedTag = {
-        key: i,
-        [HELMET_ATTRIBUTE]: true
-    };
+const generateTagsAsReactComponent = (type, tags) =>
+    tags.map((tag, i) => {
+        const mappedTag = {
+            key: i,
+            [HELMET_ATTRIBUTE]: true
+        };
 
-    Object.keys(tag).forEach((attribute) => {
-        const mappedAttribute = REACT_TAG_MAP[attribute] || attribute;
+        Object.keys(tag).forEach(attribute => {
+            const mappedAttribute = REACT_TAG_MAP[attribute] || attribute;
 
-        if (mappedAttribute === TAG_PROPERTIES.INNER_HTML || mappedAttribute === TAG_PROPERTIES.CSS_TEXT) {
-            const content = tag.innerHTML || tag.cssText;
-            mappedTag.dangerouslySetInnerHTML = {__html: content};
-        } else {
-            mappedTag[mappedAttribute] = tag[attribute];
-        }
-    });
+            if (
+                mappedAttribute === TAG_PROPERTIES.INNER_HTML ||
+                mappedAttribute === TAG_PROPERTIES.CSS_TEXT
+            ) {
+                const content = tag.innerHTML || tag.cssText;
+                mappedTag.dangerouslySetInnerHTML = {__html: content};
+            } else {
+                mappedTag[mappedAttribute] = tag[attribute];
+            }
+        });
 
-    return React.createElement(type, mappedTag);
-});
+        return React.createElement(type, mappedTag);
+    });
 
 const getMethodsForTag = (type, tags, encode) => {
     switch (type) {
         case TAG_NAMES.TITLE:
             return {
-                toComponent: () => generateTitleAsReactComponent(type, tags.title, tags.titleAttributes, encode),
-                toString: () => generateTitleAsString(type, tags.title, tags.titleAttributes, encode)
+                toComponent: () =>
+                    generateTitleAsReactComponent(
+                        type,
+                        tags.title,
+                        tags.titleAttributes,
+                        encode
+                    ),
+                toString: () =>
+                    generateTitleAsString(
+                        type,
+                        tags.title,
+                        tags.titleAttributes,
+                        encode
+                    )
             };
         case ATTRIBUTE_NAMES.BODY:
         case ATTRIBUTE_NAMES.HTML:
@@ -513,8 +603,16 @@ const mapStateOnServer = ({
     titleAttributes
 }) => ({
     base: getMethodsForTag(TAG_NAMES.BASE, baseTag, encode),
-    bodyAttributes: getMethodsForTag(ATTRIBUTE_NAMES.BODY, bodyAttributes, encode),
-    htmlAttributes: getMethodsForTag(ATTRIBUTE_NAMES.HTML, htmlAttributes, encode),
+    bodyAttributes: getMethodsForTag(
+        ATTRIBUTE_NAMES.BODY,
+        bodyAttributes,
+        encode
+    ),
+    htmlAttributes: getMethodsForTag(
+        ATTRIBUTE_NAMES.HTML,
+        htmlAttributes,
+        encode
+    ),
     link: getMethodsForTag(TAG_NAMES.LINK, linkTags, encode),
     meta: getMethodsForTag(TAG_NAMES.META, metaTags, encode),
     noscript: getMethodsForTag(TAG_NAMES.NOSCRIPT, noscriptTags, encode),
diff --git a/test/HelmetDeclarativeTest.js b/test/HelmetDeclarativeTest.js
index 27200a77..770aeb6f 100644
--- a/test/HelmetDeclarativeTest.js
+++ b/test/HelmetDeclarativeTest.js
@@ -17,7 +17,8 @@ describe("Helmet - Declarative API", () => {
     const container = document.createElement("div");
 
     beforeEach(() => {
-        headElement = headElement || document.head || document.querySelector("head");
+        headElement =
+            headElement || document.head || document.querySelector("head");
 
         // resets DOM after each run
         headElement.innerHTML = "";
@@ -29,11 +30,9 @@ describe("Helmet - Declarative API", () => {
 
     describe("api", () => {
         describe("title", () => {
-            it("updates page title", (done) => {
+            it("updates page title", done => {
                 ReactDOM.render(
-                    <Helmet
-                        defaultTitle={"Fallback"}
-                    >
+                    <Helmet defaultTitle={"Fallback"}>
                         <title>Test Title</title>
                     </Helmet>,
                     container
@@ -46,7 +45,7 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("updates page title and allows children containing expressions", (done) => {
+            it("updates page title and allows children containing expressions", done => {
                 const someValue = "Some Great Title";
 
                 ReactDOM.render(
@@ -63,7 +62,7 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("updates page title with multiple children", (done) => {
+            it("updates page title with multiple children", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet>
@@ -86,7 +85,7 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("sets title based on deepest nested component", (done) => {
+            it("sets title based on deepest nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet>
@@ -106,7 +105,7 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("sets title using deepest nested component with a defined title", (done) => {
+            it("sets title using deepest nested component with a defined title", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet>
@@ -124,11 +123,13 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("uses defaultTitle if no title is defined", (done) => {
+            it("uses defaultTitle if no title is defined", done => {
                 ReactDOM.render(
                     <Helmet
                         defaultTitle={"Fallback"}
-                        titleTemplate={"This is a %s of the titleTemplate feature"}
+                        titleTemplate={
+                            "This is a %s of the titleTemplate feature"
+                        }
                     >
                         <title />
                     </Helmet>,
@@ -142,11 +143,13 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("uses a titleTemplate if defined", (done) => {
+            it("uses a titleTemplate if defined", done => {
                 ReactDOM.render(
                     <Helmet
                         defaultTitle={"Fallback"}
-                        titleTemplate={"This is a %s of the titleTemplate feature"}
+                        titleTemplate={
+                            "This is a %s of the titleTemplate feature"
+                        }
                     >
                         <title>Test</title>
                     </Helmet>,
@@ -154,16 +157,20 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    expect(document.title).to.equal("This is a Test of the titleTemplate feature");
+                    expect(document.title).to.equal(
+                        "This is a Test of the titleTemplate feature"
+                    );
 
                     done();
                 });
             });
 
-            it("replaces multiple title strings in titleTemplate", (done) => {
+            it("replaces multiple title strings in titleTemplate", done => {
                 ReactDOM.render(
                     <Helmet
-                        titleTemplate={"This is a %s of the titleTemplate feature. Another %s."}
+                        titleTemplate={
+                            "This is a %s of the titleTemplate feature. Another %s."
+                        }
                     >
                         <title>Test</title>
                     </Helmet>,
@@ -171,22 +178,28 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    expect(document.title).to.equal("This is a Test of the titleTemplate feature. Another Test.");
+                    expect(document.title).to.equal(
+                        "This is a Test of the titleTemplate feature. Another Test."
+                    );
 
                     done();
                 });
             });
 
-            it("uses a titleTemplate based on deepest nested component", (done) => {
+            it("uses a titleTemplate based on deepest nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet
-                            titleTemplate={"This is a %s of the titleTemplate feature"}
+                            titleTemplate={
+                                "This is a %s of the titleTemplate feature"
+                            }
                         >
                             <title>Test</title>
                         </Helmet>
                         <Helmet
-                            titleTemplate={"A %s using nested titleTemplate attributes"}
+                            titleTemplate={
+                                "A %s using nested titleTemplate attributes"
+                            }
                         >
                             <title>Second Test</title>
                         </Helmet>
@@ -195,17 +208,21 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    expect(document.title).to.equal("A Second Test using nested titleTemplate attributes");
+                    expect(document.title).to.equal(
+                        "A Second Test using nested titleTemplate attributes"
+                    );
 
                     done();
                 });
             });
 
-            it("merges deepest component title with nearest upstream titleTemplate", (done) => {
+            it("merges deepest component title with nearest upstream titleTemplate", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet
-                            titleTemplate={"This is a %s of the titleTemplate feature"}
+                            titleTemplate={
+                                "This is a %s of the titleTemplate feature"
+                            }
                         >
                             <title>Test</title>
                         </Helmet>
@@ -217,32 +234,34 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    expect(document.title).to.equal("This is a Second Test of the titleTemplate feature");
+                    expect(document.title).to.equal(
+                        "This is a Second Test of the titleTemplate feature"
+                    );
 
                     done();
                 });
             });
 
-            it("renders dollar characters in a title correctly when titleTemplate present", (done) => {
+            it("renders dollar characters in a title correctly when titleTemplate present", done => {
                 const dollarTitle = "te$t te$$t te$$$t te$$$$t";
 
                 ReactDOM.render(
-                    <Helmet
-                        titleTemplate={"This is a %s"}
-                    >
+                    <Helmet titleTemplate={"This is a %s"}>
                         <title>{dollarTitle}</title>
                     </Helmet>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    expect(document.title).to.equal("This is a te$t te$$t te$$$t te$$$$t");
+                    expect(document.title).to.equal(
+                        "This is a te$t te$$t te$$$t te$$$$t"
+                    );
 
                     done();
                 });
             });
 
-            it("does not encode all characters with HTML character entity equivalents", (done) => {
+            it("does not encode all characters with HTML character entity equivalents", done => {
                 const chineseTitle = "膣膗 鍆錌雔";
 
                 ReactDOM.render(
@@ -259,11 +278,9 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("page title with prop itemProp", (done) => {
+            it("page title with prop itemProp", done => {
                 ReactDOM.render(
-                    <Helmet
-                        defaultTitle={"Fallback"}
-                    >
+                    <Helmet defaultTitle={"Fallback"}>
                         <title itemProp="name">Test Title with itemProp</title>
                     </Helmet>,
                     container
@@ -278,7 +295,7 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("retains existing title tag when no title tag is defined", (done) => {
+            it("retains existing title tag when no title tag is defined", done => {
                 headElement.innerHTML = `<title>Existing Title</title>`;
 
                 ReactDOM.render(
@@ -295,7 +312,7 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("clears title tag if empty title is defined", (done) => {
+            it("clears title tag if empty title is defined", done => {
                 ReactDOM.render(
                     <Helmet>
                         <title>Existing Title</title>
@@ -328,7 +345,7 @@ describe("Helmet - Declarative API", () => {
                 headElement.innerHTML = `<title>Test Title</title>`;
             });
 
-            it("updates title attributes", (done) => {
+            it("updates title attributes", done => {
                 ReactDOM.render(
                     <Helmet>
                         <title itemProp="name" />
@@ -340,13 +357,15 @@ describe("Helmet - Declarative API", () => {
                     const titleTag = document.getElementsByTagName("title")[0];
 
                     expect(titleTag.getAttribute("itemprop")).to.equal("name");
-                    expect(titleTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("itemprop");
+                    expect(titleTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                        "itemprop"
+                    );
 
                     done();
                 });
             });
 
-            it("sets attributes based on the deepest nested component", (done) => {
+            it("sets attributes based on the deepest nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet>
@@ -364,13 +383,15 @@ describe("Helmet - Declarative API", () => {
 
                     expect(titleTag.getAttribute("lang")).to.equal("ja");
                     expect(titleTag.getAttribute("hidden")).to.equal("true");
-                    expect(titleTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("lang,hidden");
+                    expect(titleTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                        "lang,hidden"
+                    );
 
                     done();
                 });
             });
 
-            it("handles valueless attributes", (done) => {
+            it("handles valueless attributes", done => {
                 ReactDOM.render(
                     <Helmet>
                         <title hidden />
@@ -382,13 +403,15 @@ describe("Helmet - Declarative API", () => {
                     const titleTag = document.getElementsByTagName("title")[0];
 
                     expect(titleTag.getAttribute("hidden")).to.equal("true");
-                    expect(titleTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("hidden");
+                    expect(titleTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                        "hidden"
+                    );
 
                     done();
                 });
             });
 
-            it("clears title attributes that are handled within helmet", (done) => {
+            it("clears title attributes that are handled within helmet", done => {
                 ReactDOM.render(
                     <Helmet>
                         <title lang="en" hidden />
@@ -397,17 +420,18 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    ReactDOM.render(
-                        <Helmet />,
-                        container
-                    );
+                    ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
-                        const titleTag = document.getElementsByTagName("title")[0];
+                        const titleTag = document.getElementsByTagName(
+                            "title"
+                        )[0];
 
                         expect(titleTag.getAttribute("lang")).to.be.null;
                         expect(titleTag.getAttribute("hidden")).to.be.null;
-                        expect(titleTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(null);
+                        expect(
+                            titleTag.getAttribute(HELMET_ATTRIBUTE)
+                        ).to.equal(null);
 
                         done();
                     });
@@ -416,7 +440,7 @@ describe("Helmet - Declarative API", () => {
         });
 
         describe("html attributes", () => {
-            it("updates html attributes", (done) => {
+            it("updates html attributes", done => {
                 ReactDOM.render(
                     <Helmet>
                         <html className="myClassName" lang="en" />
@@ -427,15 +451,19 @@ describe("Helmet - Declarative API", () => {
                 requestIdleCallback(() => {
                     const htmlTag = document.getElementsByTagName("html")[0];
 
-                    expect(htmlTag.getAttribute("class")).to.equal("myClassName");
+                    expect(htmlTag.getAttribute("class")).to.equal(
+                        "myClassName"
+                    );
                     expect(htmlTag.getAttribute("lang")).to.equal("en");
-                    expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("class,lang");
+                    expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                        "class,lang"
+                    );
 
                     done();
                 });
             });
 
-            it("sets attributes based on the deepest nested component", (done) => {
+            it("sets attributes based on the deepest nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet>
@@ -452,13 +480,15 @@ describe("Helmet - Declarative API", () => {
                     const htmlTag = document.getElementsByTagName("html")[0];
 
                     expect(htmlTag.getAttribute("lang")).to.equal("ja");
-                    expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("lang");
+                    expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                        "lang"
+                    );
 
                     done();
                 });
             });
 
-            it("handles valueless attributes", (done) => {
+            it("handles valueless attributes", done => {
                 ReactDOM.render(
                     <Helmet>
                         <html amp />
@@ -470,13 +500,15 @@ describe("Helmet - Declarative API", () => {
                     const htmlTag = document.getElementsByTagName("html")[0];
 
                     expect(htmlTag.getAttribute("amp")).to.equal("true");
-                    expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("amp");
+                    expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                        "amp"
+                    );
 
                     done();
                 });
             });
 
-            it("clears html attributes that are handled within helmet", (done) => {
+            it("clears html attributes that are handled within helmet", done => {
                 ReactDOM.render(
                     <Helmet>
                         <html lang="en" amp />
@@ -485,24 +517,25 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    ReactDOM.render(
-                        <Helmet />,
-                        container
-                    );
+                    ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
-                        const htmlTag = document.getElementsByTagName("html")[0];
+                        const htmlTag = document.getElementsByTagName(
+                            "html"
+                        )[0];
 
                         expect(htmlTag.getAttribute("lang")).to.be.null;
                         expect(htmlTag.getAttribute("amp")).to.be.null;
-                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(null);
+                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                            null
+                        );
 
                         done();
                     });
                 });
             });
 
-            it("updates with multiple additions and removals - overwrite and new", (done) => {
+            it("updates with multiple additions and removals - overwrite and new", done => {
                 ReactDOM.render(
                     <Helmet>
                         <html lang="en" amp />
@@ -519,20 +552,26 @@ describe("Helmet - Declarative API", () => {
                     );
 
                     requestIdleCallback(() => {
-                        const htmlTag = document.getElementsByTagName("html")[0];
+                        const htmlTag = document.getElementsByTagName(
+                            "html"
+                        )[0];
 
                         expect(htmlTag.getAttribute("amp")).to.equal(null);
                         expect(htmlTag.getAttribute("lang")).to.equal("ja");
                         expect(htmlTag.getAttribute("id")).to.equal("html-tag");
-                        expect(htmlTag.getAttribute("title")).to.equal("html tag");
-                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("lang,id,title");
+                        expect(htmlTag.getAttribute("title")).to.equal(
+                            "html tag"
+                        );
+                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                            "lang,id,title"
+                        );
 
                         done();
                     });
                 });
             });
 
-            it("updates with multiple additions and removals - all new", (done) => {
+            it("updates with multiple additions and removals - all new", done => {
                 ReactDOM.render(
                     <Helmet>
                         <html lang="en" amp />
@@ -549,13 +588,19 @@ describe("Helmet - Declarative API", () => {
                     );
 
                     requestIdleCallback(() => {
-                        const htmlTag = document.getElementsByTagName("html")[0];
+                        const htmlTag = document.getElementsByTagName(
+                            "html"
+                        )[0];
 
                         expect(htmlTag.getAttribute("amp")).to.equal(null);
                         expect(htmlTag.getAttribute("lang")).to.equal(null);
                         expect(htmlTag.getAttribute("id")).to.equal("html-tag");
-                        expect(htmlTag.getAttribute("title")).to.equal("html tag");
-                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("id,title");
+                        expect(htmlTag.getAttribute("title")).to.equal(
+                            "html tag"
+                        );
+                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                            "id,title"
+                        );
 
                         done();
                     });
@@ -568,24 +613,24 @@ describe("Helmet - Declarative API", () => {
                     htmlTag.setAttribute("test", "test");
                 });
 
-                it("are not cleared", (done) => {
-                    ReactDOM.render(
-                        <Helmet />,
-                        container
-                    );
-
+                it("are not cleared", done => {
+                    ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
-                        const htmlTag = document.getElementsByTagName("html")[0];
+                        const htmlTag = document.getElementsByTagName(
+                            "html"
+                        )[0];
 
                         expect(htmlTag.getAttribute("test")).to.equal("test");
-                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(null);
+                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                            null
+                        );
 
                         done();
                     });
                 });
 
-                it("overwritten if specified in helmet", (done) => {
+                it("overwritten if specified in helmet", done => {
                     ReactDOM.render(
                         <Helmet>
                             <html test="helmet-attr" />
@@ -594,16 +639,22 @@ describe("Helmet - Declarative API", () => {
                     );
 
                     requestIdleCallback(() => {
-                        const htmlTag = document.getElementsByTagName("html")[0];
+                        const htmlTag = document.getElementsByTagName(
+                            "html"
+                        )[0];
 
-                        expect(htmlTag.getAttribute("test")).to.equal("helmet-attr");
-                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("test");
+                        expect(htmlTag.getAttribute("test")).to.equal(
+                            "helmet-attr"
+                        );
+                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                            "test"
+                        );
 
                         done();
                     });
                 });
 
-                it("cleared once it is managed in helmet", (done) => {
+                it("cleared once it is managed in helmet", done => {
                     ReactDOM.render(
                         <Helmet>
                             <html test="helmet-attr" />
@@ -612,16 +663,17 @@ describe("Helmet - Declarative API", () => {
                     );
 
                     requestIdleCallback(() => {
-                        ReactDOM.render(
-                            <Helmet />,
-                            container
-                        );
+                        ReactDOM.render(<Helmet />, container);
 
                         requestIdleCallback(() => {
-                            const htmlTag = document.getElementsByTagName("html")[0];
+                            const htmlTag = document.getElementsByTagName(
+                                "html"
+                            )[0];
 
                             expect(htmlTag.getAttribute("test")).to.equal(null);
-                            expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(null);
+                            expect(
+                                htmlTag.getAttribute(HELMET_ATTRIBUTE)
+                            ).to.equal(null);
 
                             done();
                         });
@@ -633,26 +685,26 @@ describe("Helmet - Declarative API", () => {
         describe("body attributes", () => {
             context("valid attributes", () => {
                 const attributeList = {
-                    "accessKey": "c",
-                    "className": "test",
-                    "contentEditable": "true",
-                    "contextMenu": "mymenu",
+                    accessKey: "c",
+                    className: "test",
+                    contentEditable: "true",
+                    contextMenu: "mymenu",
                     "data-animal-type": "lion",
-                    "dir": "rtl",
-                    "draggable": "true",
-                    "dropzone": "copy",
-                    "hidden": "true",
-                    "id": "test",
-                    "lang": "fr",
-                    "spellcheck": "true",
-                    "style": "color:green",
-                    "tabIndex": "-1",
-                    "title": "test",
-                    "translate": "no"
+                    dir: "rtl",
+                    draggable: "true",
+                    dropzone: "copy",
+                    hidden: "true",
+                    id: "test",
+                    lang: "fr",
+                    spellcheck: "true",
+                    style: "color:green",
+                    tabIndex: "-1",
+                    title: "test",
+                    translate: "no"
                 };
 
                 Object.keys(attributeList).forEach(attribute => {
-                    it(attribute, (done) => {
+                    it(attribute, done => {
                         const attrValue = attributeList[attribute];
 
                         const attr = {
@@ -669,9 +721,14 @@ describe("Helmet - Declarative API", () => {
                         requestIdleCallback(() => {
                             const bodyTag = document.body;
 
-                            const reactCompatAttr = HTML_TAG_MAP[attribute] || attribute;
-                            expect(bodyTag.getAttribute(reactCompatAttr)).to.equal(attrValue);
-                            expect(bodyTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(reactCompatAttr);
+                            const reactCompatAttr =
+                                HTML_TAG_MAP[attribute] || attribute;
+                            expect(
+                                bodyTag.getAttribute(reactCompatAttr)
+                            ).to.equal(attrValue);
+                            expect(
+                                bodyTag.getAttribute(HELMET_ATTRIBUTE)
+                            ).to.equal(reactCompatAttr);
 
                             done();
                         });
@@ -679,7 +736,7 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("updates multiple body attributes", (done) => {
+            it("updates multiple body attributes", done => {
                 ReactDOM.render(
                     <Helmet>
                         <body className="myClassName" tabIndex={-1} />
@@ -690,15 +747,19 @@ describe("Helmet - Declarative API", () => {
                 requestIdleCallback(() => {
                     const bodyTag = document.body;
 
-                    expect(bodyTag.getAttribute("class")).to.equal("myClassName");
+                    expect(bodyTag.getAttribute("class")).to.equal(
+                        "myClassName"
+                    );
                     expect(bodyTag.getAttribute("tabindex")).to.equal("-1");
-                    expect(bodyTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("class,tabindex");
+                    expect(bodyTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                        "class,tabindex"
+                    );
 
                     done();
                 });
             });
 
-            it("sets attributes based on the deepest nested component", (done) => {
+            it("sets attributes based on the deepest nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet>
@@ -715,13 +776,15 @@ describe("Helmet - Declarative API", () => {
                     const bodyTag = document.body;
 
                     expect(bodyTag.getAttribute("lang")).to.equal("ja");
-                    expect(bodyTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("lang");
+                    expect(bodyTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                        "lang"
+                    );
 
                     done();
                 });
             });
 
-            it("handles valueless attributes", (done) => {
+            it("handles valueless attributes", done => {
                 ReactDOM.render(
                     <Helmet>
                         <body hidden />
@@ -729,18 +792,19 @@ describe("Helmet - Declarative API", () => {
                     container
                 );
 
-
                 requestIdleCallback(() => {
                     const bodyTag = document.body;
 
                     expect(bodyTag.getAttribute("hidden")).to.equal("true");
-                    expect(bodyTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("hidden");
+                    expect(bodyTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                        "hidden"
+                    );
 
                     done();
                 });
             });
 
-            it("clears body attributes that are handled within helmet", (done) => {
+            it("clears body attributes that are handled within helmet", done => {
                 ReactDOM.render(
                     <Helmet>
                         <body lang="en" hidden />
@@ -749,24 +813,23 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    ReactDOM.render(
-                        <Helmet />,
-                        container
-                    );
+                    ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
                         const bodyTag = document.body;
 
                         expect(bodyTag.getAttribute("lang")).to.be.null;
                         expect(bodyTag.getAttribute("hidden")).to.be.null;
-                        expect(bodyTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(null);
+                        expect(bodyTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                            null
+                        );
 
                         done();
                     });
                 });
             });
 
-            it("updates with multiple additions and removals - overwrite and new", (done) => {
+            it("updates with multiple additions and removals - overwrite and new", done => {
                 ReactDOM.render(
                     <Helmet>
                         <body lang="en" hidden />
@@ -788,15 +851,19 @@ describe("Helmet - Declarative API", () => {
                         expect(bodyTag.getAttribute("hidden")).to.equal(null);
                         expect(bodyTag.getAttribute("lang")).to.equal("ja");
                         expect(bodyTag.getAttribute("id")).to.equal("body-tag");
-                        expect(bodyTag.getAttribute("title")).to.equal("body tag");
-                        expect(bodyTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("lang,id,title");
+                        expect(bodyTag.getAttribute("title")).to.equal(
+                            "body tag"
+                        );
+                        expect(bodyTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                            "lang,id,title"
+                        );
 
                         done();
                     });
                 });
             });
 
-            it("updates with multiple additions and removals - all new", (done) => {
+            it("updates with multiple additions and removals - all new", done => {
                 ReactDOM.render(
                     <Helmet>
                         <body lang="en" hidden />
@@ -818,8 +885,12 @@ describe("Helmet - Declarative API", () => {
                         expect(bodyTag.getAttribute("hidden")).to.equal(null);
                         expect(bodyTag.getAttribute("lang")).to.equal(null);
                         expect(bodyTag.getAttribute("id")).to.equal("body-tag");
-                        expect(bodyTag.getAttribute("title")).to.equal("body tag");
-                        expect(bodyTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("id,title");
+                        expect(bodyTag.getAttribute("title")).to.equal(
+                            "body tag"
+                        );
+                        expect(bodyTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                            "id,title"
+                        );
 
                         done();
                     });
@@ -832,23 +903,22 @@ describe("Helmet - Declarative API", () => {
                     bodyTag.setAttribute("test", "test");
                 });
 
-                it("attributes are not cleared", (done) => {
-                    ReactDOM.render(
-                        <Helmet />,
-                        container
-                    );
+                it("attributes are not cleared", done => {
+                    ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
                         const bodyTag = document.body;
 
                         expect(bodyTag.getAttribute("test")).to.equal("test");
-                        expect(bodyTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(null);
+                        expect(bodyTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                            null
+                        );
 
                         done();
                     });
                 });
 
-                it("attributes are overwritten if specified in helmet", (done) => {
+                it("attributes are overwritten if specified in helmet", done => {
                     ReactDOM.render(
                         <Helmet>
                             <body test="helmet-attr" />
@@ -859,14 +929,18 @@ describe("Helmet - Declarative API", () => {
                     requestIdleCallback(() => {
                         const bodyTag = document.body;
 
-                        expect(bodyTag.getAttribute("test")).to.equal("helmet-attr");
-                        expect(bodyTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("test");
+                        expect(bodyTag.getAttribute("test")).to.equal(
+                            "helmet-attr"
+                        );
+                        expect(bodyTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                            "test"
+                        );
 
                         done();
                     });
                 });
 
-                it("attributes are cleared once managed in helmet", (done) => {
+                it("attributes are cleared once managed in helmet", done => {
                     ReactDOM.render(
                         <Helmet>
                             <body test="helmet-attr" />
@@ -875,16 +949,15 @@ describe("Helmet - Declarative API", () => {
                     );
 
                     requestIdleCallback(() => {
-                        ReactDOM.render(
-                            <Helmet />,
-                            container
-                        );
+                        ReactDOM.render(<Helmet />, container);
 
                         requestIdleCallback(() => {
                             const bodyTag = document.body;
 
                             expect(bodyTag.getAttribute("test")).to.equal(null);
-                            expect(bodyTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(null);
+                            expect(
+                                bodyTag.getAttribute(HELMET_ATTRIBUTE)
+                            ).to.equal(null);
 
                             done();
                         });
@@ -894,15 +967,21 @@ describe("Helmet - Declarative API", () => {
         });
 
         describe("onChangeClientState", () => {
-            it("when handling client state change, calls the function with new state, addedTags and removedTags ", (done) => {
+            it("when handling client state change, calls the function with new state, addedTags and removedTags ", done => {
                 const spy = sinon.spy();
                 ReactDOM.render(
                     <div>
                         <Helmet onChangeClientState={spy}>
                             <base href="http://mysite.com/" />
-                            <link href="http://localhost/helmet" rel="canonical" />
+                            <link
+                                href="http://localhost/helmet"
+                                rel="canonical"
+                            />
                             <meta charSet="utf-8" />
-                            <script src="http://localhost/test.js" type="text/javascript" />
+                            <script
+                                src="http://localhost/test.js"
+                                type="text/javascript"
+                            />
                             <title>Main Title</title>
                         </Helmet>
                     </div>,
@@ -916,26 +995,42 @@ describe("Helmet - Declarative API", () => {
                     const removedTags = spy.getCall(0).args[2];
 
                     expect(newState).to.contain({title: "Main Title"});
-                    expect(newState.baseTag).to.contain({href: "http://mysite.com/"});
-                    expect(newState.metaTags).to.contain({"charset": "utf-8"});
-                    expect(newState.linkTags).to.contain({"href": "http://localhost/helmet", "rel": "canonical"});
-                    expect(newState.scriptTags).to.contain({"src": "http://localhost/test.js", "type": "text/javascript"});
+                    expect(newState.baseTag).to.contain({
+                        href: "http://mysite.com/"
+                    });
+                    expect(newState.metaTags).to.contain({charset: "utf-8"});
+                    expect(newState.linkTags).to.contain({
+                        href: "http://localhost/helmet",
+                        rel: "canonical"
+                    });
+                    expect(newState.scriptTags).to.contain({
+                        src: "http://localhost/test.js",
+                        type: "text/javascript"
+                    });
 
                     expect(addedTags).to.have.property("baseTag");
                     expect(addedTags.baseTag).to.have.deep.property("[0]");
-                    expect(addedTags.baseTag[0].outerHTML).to.equal(`<base href="http://mysite.com/" data-react-helmet="true">`);
+                    expect(addedTags.baseTag[0].outerHTML).to.equal(
+                        `<base href="http://mysite.com/" data-react-helmet="true">`
+                    );
 
                     expect(addedTags).to.have.property("metaTags");
                     expect(addedTags.metaTags).to.have.deep.property("[0]");
-                    expect(addedTags.metaTags[0].outerHTML).to.equal(`<meta charset="utf-8" data-react-helmet="true">`);
+                    expect(addedTags.metaTags[0].outerHTML).to.equal(
+                        `<meta charset="utf-8" data-react-helmet="true">`
+                    );
 
                     expect(addedTags).to.have.property("linkTags");
                     expect(addedTags.linkTags).to.have.deep.property("[0]");
-                    expect(addedTags.linkTags[0].outerHTML).to.equal(`<link href="http://localhost/helmet" rel="canonical" data-react-helmet="true">`);
+                    expect(addedTags.linkTags[0].outerHTML).to.equal(
+                        `<link href="http://localhost/helmet" rel="canonical" data-react-helmet="true">`
+                    );
 
                     expect(addedTags).to.have.property("scriptTags");
                     expect(addedTags.scriptTags).to.have.deep.property("[0]");
-                    expect(addedTags.scriptTags[0].outerHTML).to.equal(`<script src="http://localhost/test.js" type="text/javascript" data-react-helmet="true"></script>`);
+                    expect(addedTags.scriptTags[0].outerHTML).to.equal(
+                        `<script src="http://localhost/test.js" type="text/javascript" data-react-helmet="true"></script>`
+                    );
 
                     expect(removedTags).to.be.empty;
 
@@ -943,7 +1038,7 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("calls the deepest defined callback with the deepest state", (done) => {
+            it("calls the deepest defined callback with the deepest state", done => {
                 const spy = sinon.spy();
                 ReactDOM.render(
                     <div>
@@ -959,7 +1054,9 @@ describe("Helmet - Declarative API", () => {
 
                 requestIdleCallback(() => {
                     expect(spy.callCount).to.equal(1);
-                    expect(spy.getCall(0).args[0]).to.contain({title: "Deeper Title"});
+                    expect(spy.getCall(0).args[0]).to.contain({
+                        title: "Deeper Title"
+                    });
 
                     done();
                 });
@@ -967,24 +1064,29 @@ describe("Helmet - Declarative API", () => {
         });
 
         describe("base tag", () => {
-            it("updates base tag", (done) => {
+            it("updates base tag", done => {
                 ReactDOM.render(
                     <Helmet>
-                        <base
-                            href="http://mysite.com/"
-                        />
+                        <base href="http://mysite.com/" />
                     </Helmet>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const existingTags = headElement.querySelectorAll(`base[${HELMET_ATTRIBUTE}]`);
+                    const existingTags = headElement.querySelectorAll(
+                        `base[${HELMET_ATTRIBUTE}]`
+                    );
 
                     expect(existingTags).to.not.equal(undefined);
 
-                    const filteredTags = [].slice.call(existingTags).filter((tag) => {
-                        return tag.getAttribute("href") === "http://mysite.com/";
-                    });
+                    const filteredTags = [].slice
+                        .call(existingTags)
+                        .filter(tag => {
+                            return (
+                                tag.getAttribute("href") ===
+                                "http://mysite.com/"
+                            );
+                        });
 
                     expect(filteredTags.length).to.equal(1);
 
@@ -992,22 +1094,19 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("clears the base tag if one is not specified", (done) => {
+            it("clears the base tag if one is not specified", done => {
                 ReactDOM.render(
-                    <Helmet
-                        base={{"href": "http://mysite.com/"}}
-                    />,
+                    <Helmet base={{href: "http://mysite.com/"}} />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    ReactDOM.render(
-                        <Helmet />,
-                        container
-                    );
+                    ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
-                        const existingTags = headElement.querySelectorAll(`base[${HELMET_ATTRIBUTE}]`);
+                        const existingTags = headElement.querySelectorAll(
+                            `base[${HELMET_ATTRIBUTE}]`
+                        );
 
                         expect(existingTags).to.not.equal(undefined);
                         expect(existingTags.length).to.equal(0);
@@ -1017,18 +1116,18 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("tags without 'href' are not accepted", (done) => {
+            it("tags without 'href' are not accepted", done => {
                 ReactDOM.render(
                     <Helmet>
-                        <base
-                            property="won't work"
-                        />
+                        <base property="won't work" />
                     </Helmet>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const existingTags = headElement.querySelectorAll(`base[${HELMET_ATTRIBUTE}]`);
+                    const existingTags = headElement.querySelectorAll(
+                        `base[${HELMET_ATTRIBUTE}]`
+                    );
 
                     expect(existingTags).to.not.equal(undefined);
                     expect(existingTags.length).to.equal(0);
@@ -1037,54 +1136,58 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("sets base tag based on deepest nested component", (done) => {
+            it("sets base tag based on deepest nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet>
-                            <base
-                                href="http://mysite.com"
-                            />
+                            <base href="http://mysite.com" />
                         </Helmet>
                         <Helmet>
-                            <base
-                                href="http://mysite.com/public"
-                            />
+                            <base href="http://mysite.com/public" />
                         </Helmet>
                     </div>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const existingTags = headElement.querySelectorAll(`base[${HELMET_ATTRIBUTE}]`);
-                    const firstTag = Array.prototype.slice.call(existingTags)[0];
+                    const existingTags = headElement.querySelectorAll(
+                        `base[${HELMET_ATTRIBUTE}]`
+                    );
+                    const firstTag = Array.prototype.slice.call(
+                        existingTags
+                    )[0];
 
                     expect(existingTags).to.not.equal(undefined);
 
                     expect(existingTags.length).to.be.equal(1);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
-                    expect(firstTag.getAttribute("href")).to.equal("http://mysite.com/public");
-                    expect(firstTag.outerHTML).to.equal(`<base href="http://mysite.com/public" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.getAttribute("href")).to.equal(
+                        "http://mysite.com/public"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<base href="http://mysite.com/public" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("does not render tag when primary attribute is null", (done) => {
+            it("does not render tag when primary attribute is null", done => {
                 ReactDOM.render(
                     <Helmet>
-                        <base
-                            href={undefined}
-                        />
+                        <base href={undefined} />
                     </Helmet>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`base[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `base[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     expect(existingTags).to.be.empty;
 
@@ -1094,42 +1197,43 @@ describe("Helmet - Declarative API", () => {
         });
 
         describe("meta tags", () => {
-            it("updates meta tags", (done) => {
+            it("updates meta tags", done => {
                 ReactDOM.render(
                     <Helmet>
                         <meta charSet="utf-8" />
-                        <meta
-                            name="description"
-                            content="Test description"
-                        />
-                        <meta
-                            httpEquiv="content-type"
-                            content="text/html"
-                        />
-                        <meta
-                            property="og:type"
-                            content="article"
-                        />
-                        <meta
-                            itemProp="name"
-                            content="Test name itemprop"
-                        />
+                        <meta name="description" content="Test description" />
+                        <meta httpEquiv="content-type" content="text/html" />
+                        <meta property="og:type" content="article" />
+                        <meta itemProp="name" content="Test name itemprop" />
                     </Helmet>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `meta[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
 
                     expect(existingTags).to.not.equal(undefined);
 
-                    const filteredTags = [].slice.call(existingTags).filter((tag) => {
-                        return tag.getAttribute("charset") === "utf-8" ||
-                            (tag.getAttribute("name") === "description" && tag.getAttribute("content") === "Test description") ||
-                            (tag.getAttribute("http-equiv") === "content-type" && tag.getAttribute("content") === "text/html") ||
-                            (tag.getAttribute("itemprop") === "name" && tag.getAttribute("content") === "Test name itemprop");
-                    });
+                    const filteredTags = [].slice
+                        .call(existingTags)
+                        .filter(tag => {
+                            return (
+                                tag.getAttribute("charset") === "utf-8" ||
+                                (tag.getAttribute("name") === "description" &&
+                                    tag.getAttribute("content") ===
+                                        "Test description") ||
+                                (tag.getAttribute("http-equiv") ===
+                                    "content-type" &&
+                                    tag.getAttribute("content") ===
+                                        "text/html") ||
+                                (tag.getAttribute("itemprop") === "name" &&
+                                    tag.getAttribute("content") ===
+                                        "Test name itemprop")
+                            );
+                        });
 
                     expect(filteredTags.length).to.be.at.least(4);
 
@@ -1137,25 +1241,21 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("clears all meta tags if none are specified", (done) => {
+            it("clears all meta tags if none are specified", done => {
                 ReactDOM.render(
                     <Helmet>
-                        <meta
-                            name="description"
-                            content="Test description"
-                        />
+                        <meta name="description" content="Test description" />
                     </Helmet>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    ReactDOM.render(
-                        <Helmet />,
-                        container
-                    );
+                    ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
-                        const existingTags = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                        const existingTags = headElement.querySelectorAll(
+                            `meta[${HELMET_ATTRIBUTE}]`
+                        );
 
                         expect(existingTags).to.not.equal(undefined);
                         expect(existingTags.length).to.equal(0);
@@ -1165,7 +1265,7 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("tags without 'name', 'http-equiv', 'property', 'charset', or 'itemprop' are not accepted", (done) => {
+            it("tags without 'name', 'http-equiv', 'property', 'charset', or 'itemprop' are not accepted", done => {
                 ReactDOM.render(
                     <Helmet>
                         <meta href="won't work" />
@@ -1174,7 +1274,9 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const existingTags = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                    const existingTags = headElement.querySelectorAll(
+                        `meta[${HELMET_ATTRIBUTE}]`
+                    );
 
                     expect(existingTags).to.not.equal(undefined);
                     expect(existingTags.length).to.equal(0);
@@ -1183,7 +1285,7 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("sets meta tags based on deepest nested component", (done) => {
+            it("sets meta tags based on deepest nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet>
@@ -1198,17 +1300,16 @@ describe("Helmet - Declarative API", () => {
                                 name="description"
                                 content="Inner description"
                             />
-                            <meta
-                                name="keywords"
-                                content="test,meta,tags"
-                            />
+                            <meta name="keywords" content="test,meta,tags" />
                         </Helmet>
                     </div>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `meta[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
 
                     const firstTag = existingTags[0];
@@ -1219,40 +1320,49 @@ describe("Helmet - Declarative API", () => {
 
                     expect(existingTags.length).to.be.equal(3);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
                     expect(firstTag.getAttribute("charset")).to.equal("utf-8");
-                    expect(firstTag.outerHTML).to.equal(`<meta charset="utf-8" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.outerHTML).to.equal(
+                        `<meta charset="utf-8" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[1]")
+                    expect(existingTags).to.have.deep
+                        .property("[1]")
                         .that.is.an.instanceof(Element);
                     expect(secondTag).to.have.property("getAttribute");
-                    expect(secondTag.getAttribute("name")).to.equal("description");
-                    expect(secondTag.getAttribute("content")).to.equal("Inner description");
-                    expect(secondTag.outerHTML).to.equal(`<meta name="description" content="Inner description" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(secondTag.getAttribute("name")).to.equal(
+                        "description"
+                    );
+                    expect(secondTag.getAttribute("content")).to.equal(
+                        "Inner description"
+                    );
+                    expect(secondTag.outerHTML).to.equal(
+                        `<meta name="description" content="Inner description" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[2]")
+                    expect(existingTags).to.have.deep
+                        .property("[2]")
                         .that.is.an.instanceof(Element);
                     expect(thirdTag).to.have.property("getAttribute");
                     expect(thirdTag.getAttribute("name")).to.equal("keywords");
-                    expect(thirdTag.getAttribute("content")).to.equal("test,meta,tags");
-                    expect(thirdTag.outerHTML).to.equal(`<meta name="keywords" content="test,meta,tags" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(thirdTag.getAttribute("content")).to.equal(
+                        "test,meta,tags"
+                    );
+                    expect(thirdTag.outerHTML).to.equal(
+                        `<meta name="keywords" content="test,meta,tags" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("allows duplicate meta tags if specified in the same component", (done) => {
+            it("allows duplicate meta tags if specified in the same component", done => {
                 ReactDOM.render(
                     <Helmet>
-                        <meta
-                            name="description"
-                            content="Test description"
-                        />
+                        <meta name="description" content="Test description" />
                         <meta
                             name="description"
                             content="Duplicate description"
@@ -1262,7 +1372,9 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `meta[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
                     const secondTag = existingTags[1];
@@ -1271,27 +1383,39 @@ describe("Helmet - Declarative API", () => {
 
                     expect(existingTags.length).to.equal(2);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
-                    expect(firstTag.getAttribute("name")).to.equal("description");
-                    expect(firstTag.getAttribute("content")).to.equal("Test description");
-                    expect(firstTag.outerHTML).to.equal(`<meta name="description" content="Test description" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.getAttribute("name")).to.equal(
+                        "description"
+                    );
+                    expect(firstTag.getAttribute("content")).to.equal(
+                        "Test description"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<meta name="description" content="Test description" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[1]")
+                    expect(existingTags).to.have.deep
+                        .property("[1]")
                         .that.is.an.instanceof(Element);
                     expect(secondTag).to.have.property("getAttribute");
-                    expect(secondTag.getAttribute("name")).to.equal("description");
-                    expect(secondTag.getAttribute("content")).to.equal("Duplicate description");
-                    expect(secondTag.outerHTML).to.equal(`<meta name="description" content="Duplicate description" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(secondTag.getAttribute("name")).to.equal(
+                        "description"
+                    );
+                    expect(secondTag.getAttribute("content")).to.equal(
+                        "Duplicate description"
+                    );
+                    expect(secondTag.outerHTML).to.equal(
+                        `<meta name="description" content="Duplicate description" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("overrides duplicate meta tags with single meta tag in a nested component", (done) => {
+            it("overrides duplicate meta tags with single meta tag in a nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet>
@@ -1315,7 +1439,9 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `meta[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
 
@@ -1323,19 +1449,25 @@ describe("Helmet - Declarative API", () => {
 
                     expect(existingTags.length).to.equal(1);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
-                    expect(firstTag.getAttribute("name")).to.equal("description");
-                    expect(firstTag.getAttribute("content")).to.equal("Inner description");
-                    expect(firstTag.outerHTML).to.equal(`<meta name="description" content="Inner description" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.getAttribute("name")).to.equal(
+                        "description"
+                    );
+                    expect(firstTag.getAttribute("content")).to.equal(
+                        "Inner description"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<meta name="description" content="Inner description" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("overrides single meta tag with duplicate meta tags in a nested component", (done) => {
+            it("overrides single meta tag with duplicate meta tags in a nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet>
@@ -1359,7 +1491,9 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `meta[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
                     const secondTag = existingTags[1];
@@ -1368,27 +1502,39 @@ describe("Helmet - Declarative API", () => {
 
                     expect(existingTags.length).to.equal(2);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
-                    expect(firstTag.getAttribute("name")).to.equal("description");
-                    expect(firstTag.getAttribute("content")).to.equal("Inner description");
-                    expect(firstTag.outerHTML).to.equal(`<meta name="description" content="Inner description" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.getAttribute("name")).to.equal(
+                        "description"
+                    );
+                    expect(firstTag.getAttribute("content")).to.equal(
+                        "Inner description"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<meta name="description" content="Inner description" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[1]")
+                    expect(existingTags).to.have.deep
+                        .property("[1]")
                         .that.is.an.instanceof(Element);
                     expect(secondTag).to.have.property("getAttribute");
-                    expect(secondTag.getAttribute("name")).to.equal("description");
-                    expect(secondTag.getAttribute("content")).to.equal("Inner duplicate description");
-                    expect(secondTag.outerHTML).to.equal(`<meta name="description" content="Inner duplicate description" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(secondTag.getAttribute("name")).to.equal(
+                        "description"
+                    );
+                    expect(secondTag.getAttribute("content")).to.equal(
+                        "Inner duplicate description"
+                    );
+                    expect(secondTag.outerHTML).to.equal(
+                        `<meta name="description" content="Inner duplicate description" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("does not render tag when primary attribute is null", (done) => {
+            it("does not render tag when primary attribute is null", done => {
                 ReactDOM.render(
                     <Helmet>
                         <meta
@@ -1400,7 +1546,9 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `meta[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     expect(existingTags).to.be.empty;
 
@@ -1410,25 +1558,40 @@ describe("Helmet - Declarative API", () => {
         });
 
         describe("link tags", () => {
-            it("updates link tags", (done) => {
+            it("updates link tags", done => {
                 ReactDOM.render(
                     <Helmet>
                         <link href="http://localhost/helmet" rel="canonical" />
-                        <link href="http://localhost/style.css" rel="stylesheet" type="text/css" />
+                        <link
+                            href="http://localhost/style.css"
+                            rel="stylesheet"
+                            type="text/css"
+                        />
                     </Helmet>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `link[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
 
                     expect(existingTags).to.not.equal(undefined);
 
-                    const filteredTags = [].slice.call(existingTags).filter((tag) => {
-                        return (tag.getAttribute("href") === "http://localhost/style.css" && tag.getAttribute("rel") === "stylesheet" && tag.getAttribute("type") === "text/css") ||
-                            (tag.getAttribute("href") === "http://localhost/helmet" && tag.getAttribute("rel") === "canonical");
-                    });
+                    const filteredTags = [].slice
+                        .call(existingTags)
+                        .filter(tag => {
+                            return (
+                                (tag.getAttribute("href") ===
+                                    "http://localhost/style.css" &&
+                                    tag.getAttribute("rel") === "stylesheet" &&
+                                    tag.getAttribute("type") === "text/css") ||
+                                (tag.getAttribute("href") ===
+                                    "http://localhost/helmet" &&
+                                    tag.getAttribute("rel") === "canonical")
+                            );
+                        });
 
                     expect(filteredTags.length).to.be.at.least(2);
 
@@ -1436,7 +1599,7 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("clears all link tags if none are specified", (done) => {
+            it("clears all link tags if none are specified", done => {
                 ReactDOM.render(
                     <Helmet>
                         <link href="http://localhost/helmet" rel="canonical" />
@@ -1445,14 +1608,15 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    ReactDOM.render(
-                        <Helmet />,
-                        container
-                    );
+                    ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
-                        const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
-                        const existingTags = Array.prototype.slice.call(tagNodes);
+                        const tagNodes = headElement.querySelectorAll(
+                            `link[${HELMET_ATTRIBUTE}]`
+                        );
+                        const existingTags = Array.prototype.slice.call(
+                            tagNodes
+                        );
 
                         expect(existingTags).to.not.equal(undefined);
                         expect(existingTags.length).to.equal(0);
@@ -1462,7 +1626,7 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("tags without 'href' or 'rel' are not accepted, even if they are valid for other tags", (done) => {
+            it("tags without 'href' or 'rel' are not accepted, even if they are valid for other tags", done => {
                 ReactDOM.render(
                     <Helmet>
                         <link httpEquiv="won't work" />
@@ -1471,7 +1635,9 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `link[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
 
                     expect(existingTags).to.not.equal(undefined);
@@ -1481,24 +1647,35 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("tags 'rel' and 'href' properly use 'rel' as the primary identification for this tag, regardless of ordering", (done) => {
+            it("tags 'rel' and 'href' properly use 'rel' as the primary identification for this tag, regardless of ordering", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet>
-                            <link href="http://localhost/helmet" rel="canonical" />
+                            <link
+                                href="http://localhost/helmet"
+                                rel="canonical"
+                            />
                         </Helmet>
                         <Helmet>
-                            <link rel="canonical" href="http://localhost/helmet/new" />
+                            <link
+                                rel="canonical"
+                                href="http://localhost/helmet/new"
+                            />
                         </Helmet>
                         <Helmet>
-                            <link href="http://localhost/helmet/newest" rel="canonical" />
+                            <link
+                                href="http://localhost/helmet/newest"
+                                rel="canonical"
+                            />
                         </Helmet>
                     </div>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `link[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
 
@@ -1506,19 +1683,23 @@ describe("Helmet - Declarative API", () => {
 
                     expect(existingTags.length).to.equal(1);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
                     expect(firstTag.getAttribute("rel")).to.equal("canonical");
-                    expect(firstTag.getAttribute("href")).to.equal("http://localhost/helmet/newest");
-                    expect(firstTag.outerHTML).to.equal(`<link href="http://localhost/helmet/newest" rel="canonical" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.getAttribute("href")).to.equal(
+                        "http://localhost/helmet/newest"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<link href="http://localhost/helmet/newest" rel="canonical" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("tags with rel='stylesheet' uses the href as the primary identification of the tag, regardless of ordering", (done) => {
+            it("tags with rel='stylesheet' uses the href as the primary identification of the tag, regardless of ordering", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet>
@@ -1542,7 +1723,9 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `link[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
                     const secondTag = existingTags[1];
@@ -1551,35 +1734,48 @@ describe("Helmet - Declarative API", () => {
 
                     expect(existingTags.length).to.equal(2);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
-                    expect(firstTag.getAttribute("href")).to.equal("http://localhost/style.css");
+                    expect(firstTag.getAttribute("href")).to.equal(
+                        "http://localhost/style.css"
+                    );
                     expect(firstTag.getAttribute("rel")).to.equal("stylesheet");
                     expect(firstTag.getAttribute("type")).to.equal("text/css");
                     expect(firstTag.getAttribute("media")).to.equal("all");
-                    expect(firstTag.outerHTML).to.equal(`<link href="http://localhost/style.css" rel="stylesheet" type="text/css" media="all" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.outerHTML).to.equal(
+                        `<link href="http://localhost/style.css" rel="stylesheet" type="text/css" media="all" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[1]")
+                    expect(existingTags).to.have.deep
+                        .property("[1]")
                         .that.is.an.instanceof(Element);
                     expect(secondTag).to.have.property("getAttribute");
-                    expect(secondTag.getAttribute("rel")).to.equal("stylesheet");
-                    expect(secondTag.getAttribute("href")).to.equal("http://localhost/inner.css");
+                    expect(secondTag.getAttribute("rel")).to.equal(
+                        "stylesheet"
+                    );
+                    expect(secondTag.getAttribute("href")).to.equal(
+                        "http://localhost/inner.css"
+                    );
                     expect(secondTag.getAttribute("type")).to.equal("text/css");
                     expect(secondTag.getAttribute("media")).to.equal("all");
-                    expect(secondTag.outerHTML).to.equal(`<link rel="stylesheet" href="http://localhost/inner.css" type="text/css" media="all" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(secondTag.outerHTML).to.equal(
+                        `<link rel="stylesheet" href="http://localhost/inner.css" type="text/css" media="all" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("sets link tags based on deepest nested component", (done) => {
+            it("sets link tags based on deepest nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet>
-                            <link rel="canonical" href="http://localhost/helmet" />
+                            <link
+                                rel="canonical"
+                                href="http://localhost/helmet"
+                            />
                             <link
                                 href="http://localhost/style.css"
                                 rel="stylesheet"
@@ -1588,7 +1784,10 @@ describe("Helmet - Declarative API", () => {
                             />
                         </Helmet>
                         <Helmet>
-                            <link rel="canonical" href="http://localhost/helmet/innercomponent" />
+                            <link
+                                rel="canonical"
+                                href="http://localhost/helmet/innercomponent"
+                            />
                             <link
                                 href="http://localhost/inner.css"
                                 rel="stylesheet"
@@ -1601,7 +1800,9 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `link[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
                     const secondTag = existingTags[1];
@@ -1611,49 +1812,66 @@ describe("Helmet - Declarative API", () => {
 
                     expect(existingTags.length).to.be.at.least(2);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
-                    expect(firstTag.getAttribute("href")).to.equal("http://localhost/style.css");
+                    expect(firstTag.getAttribute("href")).to.equal(
+                        "http://localhost/style.css"
+                    );
                     expect(firstTag.getAttribute("rel")).to.equal("stylesheet");
                     expect(firstTag.getAttribute("type")).to.equal("text/css");
                     expect(firstTag.getAttribute("media")).to.equal("all");
-                    expect(firstTag.outerHTML).to.equal(`<link href="http://localhost/style.css" rel="stylesheet" type="text/css" media="all" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.outerHTML).to.equal(
+                        `<link href="http://localhost/style.css" rel="stylesheet" type="text/css" media="all" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[1]")
+                    expect(existingTags).to.have.deep
+                        .property("[1]")
                         .that.is.an.instanceof(Element);
                     expect(secondTag).to.have.property("getAttribute");
-                    expect(secondTag.getAttribute("href")).to.equal("http://localhost/helmet/innercomponent");
+                    expect(secondTag.getAttribute("href")).to.equal(
+                        "http://localhost/helmet/innercomponent"
+                    );
                     expect(secondTag.getAttribute("rel")).to.equal("canonical");
-                    expect(secondTag.outerHTML).to.equal(`<link rel="canonical" href="http://localhost/helmet/innercomponent" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(secondTag.outerHTML).to.equal(
+                        `<link rel="canonical" href="http://localhost/helmet/innercomponent" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[2]")
+                    expect(existingTags).to.have.deep
+                        .property("[2]")
                         .that.is.an.instanceof(Element);
                     expect(thirdTag).to.have.property("getAttribute");
-                    expect(thirdTag.getAttribute("href")).to.equal("http://localhost/inner.css");
+                    expect(thirdTag.getAttribute("href")).to.equal(
+                        "http://localhost/inner.css"
+                    );
                     expect(thirdTag.getAttribute("rel")).to.equal("stylesheet");
                     expect(thirdTag.getAttribute("type")).to.equal("text/css");
                     expect(thirdTag.getAttribute("media")).to.equal("all");
-                    expect(thirdTag.outerHTML).to.equal(`<link href="http://localhost/inner.css" rel="stylesheet" type="text/css" media="all" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(thirdTag.outerHTML).to.equal(
+                        `<link href="http://localhost/inner.css" rel="stylesheet" type="text/css" media="all" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("allows duplicate link tags if specified in the same component", (done) => {
+            it("allows duplicate link tags if specified in the same component", done => {
                 ReactDOM.render(
                     <Helmet>
                         <link rel="canonical" href="http://localhost/helmet" />
-                        <link rel="canonical" href="http://localhost/helmet/component" />
+                        <link
+                            rel="canonical"
+                            href="http://localhost/helmet/component"
+                        />
                     </Helmet>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `link[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
                     const secondTag = existingTags[1];
@@ -1662,42 +1880,61 @@ describe("Helmet - Declarative API", () => {
 
                     expect(existingTags.length).to.be.at.least(2);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
                     expect(firstTag.getAttribute("rel")).to.equal("canonical");
-                    expect(firstTag.getAttribute("href")).to.equal("http://localhost/helmet");
-                    expect(firstTag.outerHTML).to.equal(`<link rel="canonical" href="http://localhost/helmet" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.getAttribute("href")).to.equal(
+                        "http://localhost/helmet"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<link rel="canonical" href="http://localhost/helmet" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[1]")
+                    expect(existingTags).to.have.deep
+                        .property("[1]")
                         .that.is.an.instanceof(Element);
                     expect(secondTag).to.have.property("getAttribute");
                     expect(secondTag.getAttribute("rel")).to.equal("canonical");
-                    expect(secondTag.getAttribute("href")).to.equal("http://localhost/helmet/component");
-                    expect(secondTag.outerHTML).to.equal(`<link rel="canonical" href="http://localhost/helmet/component" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(secondTag.getAttribute("href")).to.equal(
+                        "http://localhost/helmet/component"
+                    );
+                    expect(secondTag.outerHTML).to.equal(
+                        `<link rel="canonical" href="http://localhost/helmet/component" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("overrides duplicate link tags with a single link tag in a nested component", (done) => {
+            it("overrides duplicate link tags with a single link tag in a nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet>
-                            <link rel="canonical" href="http://localhost/helmet" />
-                            <link rel="canonical" href="http://localhost/helmet/component" />
+                            <link
+                                rel="canonical"
+                                href="http://localhost/helmet"
+                            />
+                            <link
+                                rel="canonical"
+                                href="http://localhost/helmet/component"
+                            />
                         </Helmet>
                         <Helmet>
-                            <link rel="canonical" href="http://localhost/helmet/innercomponent" />
+                            <link
+                                rel="canonical"
+                                href="http://localhost/helmet/innercomponent"
+                            />
                         </Helmet>
                     </div>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `link[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
 
@@ -1705,34 +1942,49 @@ describe("Helmet - Declarative API", () => {
 
                     expect(existingTags.length).to.be.equal(1);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
                     expect(firstTag.getAttribute("rel")).to.equal("canonical");
-                    expect(firstTag.getAttribute("href")).to.equal("http://localhost/helmet/innercomponent");
-                    expect(firstTag.outerHTML).to.equal(`<link rel="canonical" href="http://localhost/helmet/innercomponent" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.getAttribute("href")).to.equal(
+                        "http://localhost/helmet/innercomponent"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<link rel="canonical" href="http://localhost/helmet/innercomponent" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("overrides single link tag with duplicate link tags in a nested component", (done) => {
+            it("overrides single link tag with duplicate link tags in a nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet>
-                            <link rel="canonical" href="http://localhost/helmet" />
+                            <link
+                                rel="canonical"
+                                href="http://localhost/helmet"
+                            />
                         </Helmet>
                         <Helmet>
-                            <link rel="canonical" href="http://localhost/helmet/component" />
-                            <link rel="canonical" href="http://localhost/helmet/innercomponent" />
+                            <link
+                                rel="canonical"
+                                href="http://localhost/helmet/component"
+                            />
+                            <link
+                                rel="canonical"
+                                href="http://localhost/helmet/innercomponent"
+                            />
                         </Helmet>
                     </div>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `link[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
                     const secondTag = existingTags[1];
@@ -1741,50 +1993,67 @@ describe("Helmet - Declarative API", () => {
 
                     expect(existingTags.length).to.be.equal(2);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
                     expect(firstTag.getAttribute("rel")).to.equal("canonical");
-                    expect(firstTag.getAttribute("href")).to.equal("http://localhost/helmet/component");
-                    expect(firstTag.outerHTML).to.equal(`<link rel="canonical" href="http://localhost/helmet/component" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.getAttribute("href")).to.equal(
+                        "http://localhost/helmet/component"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<link rel="canonical" href="http://localhost/helmet/component" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[1]")
+                    expect(existingTags).to.have.deep
+                        .property("[1]")
                         .that.is.an.instanceof(Element);
                     expect(secondTag).to.have.property("getAttribute");
                     expect(secondTag.getAttribute("rel")).to.equal("canonical");
-                    expect(secondTag.getAttribute("href")).to.equal("http://localhost/helmet/innercomponent");
-                    expect(secondTag.outerHTML).to.equal(`<link rel="canonical" href="http://localhost/helmet/innercomponent" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(secondTag.getAttribute("href")).to.equal(
+                        "http://localhost/helmet/innercomponent"
+                    );
+                    expect(secondTag.outerHTML).to.equal(
+                        `<link rel="canonical" href="http://localhost/helmet/innercomponent" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("does not render tag when primary attribute is null", (done) => {
+            it("does not render tag when primary attribute is null", done => {
                 ReactDOM.render(
                     <Helmet>
                         <link rel="icon" sizes="192x192" href={null} />
-                        <link rel="canonical" href="http://localhost/helmet/component" />
+                        <link
+                            rel="canonical"
+                            href="http://localhost/helmet/component"
+                        />
                     </Helmet>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `link[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
 
                     expect(existingTags).to.not.equal(undefined);
                     expect(existingTags.length).to.be.equal(1);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
                     expect(firstTag.getAttribute("rel")).to.equal("canonical");
-                    expect(firstTag.getAttribute("href")).to.equal("http://localhost/helmet/component");
-                    expect(firstTag.outerHTML).to.equal(`<link rel="canonical" href="http://localhost/helmet/component" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.getAttribute("href")).to.equal(
+                        "http://localhost/helmet/component"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<link rel="canonical" href="http://localhost/helmet/component" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
@@ -1837,7 +2106,7 @@ describe("Helmet - Declarative API", () => {
         });
 
         describe("script tags", () => {
-            it("updates script tags", (done) => {
+            it("updates script tags", done => {
                 const scriptInnerHTML = `
                   {
                     "@context": "http://schema.org",
@@ -1847,23 +2116,45 @@ describe("Helmet - Declarative API", () => {
                 `;
                 ReactDOM.render(
                     <Helmet>
-                        <script src="http://localhost/test.js" type="text/javascript" />
-                        <script src="http://localhost/test2.js" type="text/javascript" />
-                        <script type="application/ld+json">{scriptInnerHTML}</script>
+                        <script
+                            src="http://localhost/test.js"
+                            type="text/javascript"
+                        />
+                        <script
+                            src="http://localhost/test2.js"
+                            type="text/javascript"
+                        />
+                        <script type="application/ld+json">
+                            {scriptInnerHTML}
+                        </script>
                     </Helmet>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const existingTags = headElement.getElementsByTagName("script");
+                    const existingTags = headElement.getElementsByTagName(
+                        "script"
+                    );
 
                     expect(existingTags).to.not.equal(undefined);
 
-                    const filteredTags = [].slice.call(existingTags).filter((tag) => {
-                        return (tag.getAttribute("src") === "http://localhost/test.js" && tag.getAttribute("type") === "text/javascript") ||
-                            (tag.getAttribute("src") === "http://localhost/test2.js" && tag.getAttribute("type") === "text/javascript") ||
-                            (tag.getAttribute("type") === "application/ld+json" && tag.innerHTML === scriptInnerHTML);
-                    });
+                    const filteredTags = [].slice
+                        .call(existingTags)
+                        .filter(tag => {
+                            return (
+                                (tag.getAttribute("src") ===
+                                    "http://localhost/test.js" &&
+                                    tag.getAttribute("type") ===
+                                        "text/javascript") ||
+                                (tag.getAttribute("src") ===
+                                    "http://localhost/test2.js" &&
+                                    tag.getAttribute("type") ===
+                                        "text/javascript") ||
+                                (tag.getAttribute("type") ===
+                                    "application/ld+json" &&
+                                    tag.innerHTML === scriptInnerHTML)
+                            );
+                        });
 
                     expect(filteredTags.length).to.be.at.least(3);
 
@@ -1871,22 +2162,24 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("clears all scripts tags if none are specified", (done) => {
+            it("clears all scripts tags if none are specified", done => {
                 ReactDOM.render(
                     <Helmet>
-                        <script src="http://localhost/test.js" type="text/javascript" />
+                        <script
+                            src="http://localhost/test.js"
+                            type="text/javascript"
+                        />
                     </Helmet>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    ReactDOM.render(
-                        <Helmet />,
-                        container
-                    );
+                    ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
-                        const existingTags = headElement.querySelectorAll(`script[${HELMET_ATTRIBUTE}]`);
+                        const existingTags = headElement.querySelectorAll(
+                            `script[${HELMET_ATTRIBUTE}]`
+                        );
 
                         expect(existingTags).to.not.equal(undefined);
                         expect(existingTags.length).to.equal(0);
@@ -1896,7 +2189,7 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("tags without 'src' are not accepted", (done) => {
+            it("tags without 'src' are not accepted", done => {
                 ReactDOM.render(
                     <Helmet>
                         <script property="won't work" />
@@ -1905,7 +2198,9 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const existingTags = headElement.querySelectorAll(`script[${HELMET_ATTRIBUTE}]`);
+                    const existingTags = headElement.querySelectorAll(
+                        `script[${HELMET_ATTRIBUTE}]`
+                    );
 
                     expect(existingTags).to.not.equal(undefined);
                     expect(existingTags.length).to.equal(0);
@@ -1914,19 +2209,27 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("sets script tags based on deepest nested component", (done) => {
+            it("sets script tags based on deepest nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet>
-                            <script src="http://localhost/test.js" type="text/javascript" />
-                            <script src="http://localhost/test2.js" type="text/javascript" />
+                            <script
+                                src="http://localhost/test.js"
+                                type="text/javascript"
+                            />
+                            <script
+                                src="http://localhost/test2.js"
+                                type="text/javascript"
+                            />
                         </Helmet>
                     </div>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`script[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `script[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
                     const secondTag = existingTags[1];
@@ -1935,27 +2238,39 @@ describe("Helmet - Declarative API", () => {
 
                     expect(existingTags.length).to.be.at.least(2);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
-                    expect(firstTag.getAttribute("src")).to.equal("http://localhost/test.js");
-                    expect(firstTag.getAttribute("type")).to.equal("text/javascript");
-                    expect(firstTag.outerHTML).to.equal(`<script src="http://localhost/test.js" type="text/javascript" ${HELMET_ATTRIBUTE}="true"></script>`);
+                    expect(firstTag.getAttribute("src")).to.equal(
+                        "http://localhost/test.js"
+                    );
+                    expect(firstTag.getAttribute("type")).to.equal(
+                        "text/javascript"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<script src="http://localhost/test.js" type="text/javascript" ${HELMET_ATTRIBUTE}="true"></script>`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[1]")
+                    expect(existingTags).to.have.deep
+                        .property("[1]")
                         .that.is.an.instanceof(Element);
                     expect(secondTag).to.have.property("getAttribute");
-                    expect(secondTag.getAttribute("src")).to.equal("http://localhost/test2.js");
-                    expect(secondTag.getAttribute("type")).to.equal("text/javascript");
-                    expect(secondTag.outerHTML).to.equal(`<script src="http://localhost/test2.js" type="text/javascript" ${HELMET_ATTRIBUTE}="true"></script>`);
+                    expect(secondTag.getAttribute("src")).to.equal(
+                        "http://localhost/test2.js"
+                    );
+                    expect(secondTag.getAttribute("type")).to.equal(
+                        "text/javascript"
+                    );
+                    expect(secondTag.outerHTML).to.equal(
+                        `<script src="http://localhost/test2.js" type="text/javascript" ${HELMET_ATTRIBUTE}="true"></script>`
+                    );
 
                     done();
                 });
             });
 
-            it("sets undefined attribute values to empty strings", (done) => {
+            it("sets undefined attribute values to empty strings", done => {
                 ReactDOM.render(
                     <Helmet>
                         <script src="foo.js" async={undefined} />
@@ -1964,18 +2279,22 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const existingTag = headElement.querySelector(`script[${HELMET_ATTRIBUTE}]`);
+                    const existingTag = headElement.querySelector(
+                        `script[${HELMET_ATTRIBUTE}]`
+                    );
 
                     expect(existingTag).to.not.equal(undefined);
-                    expect(existingTag.outerHTML)
-                        .to.be.a("string")
-                        .that.equals(`<script src="foo.js" async="" ${HELMET_ATTRIBUTE}="true"></script>`);
+                    expect(existingTag.outerHTML).to.be
+                        .a("string")
+                        .that.equals(
+                            `<script src="foo.js" async="" ${HELMET_ATTRIBUTE}="true"></script>`
+                        );
 
                     done();
                 });
             });
 
-            it("does not render tag when primary attribute (src) is null", (done) => {
+            it("does not render tag when primary attribute (src) is null", done => {
                 ReactDOM.render(
                     <Helmet>
                         <script src={undefined} type="text/javascript" />
@@ -1984,7 +2303,9 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`script[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `script[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     expect(existingTags).to.be.empty;
 
@@ -1992,7 +2313,7 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("does not render tag when primary attribute (innerHTML) is null", (done) => {
+            it("does not render tag when primary attribute (innerHTML) is null", done => {
                 ReactDOM.render(
                     <Helmet>
                         <script innerHTML={undefined} />
@@ -2001,7 +2322,9 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`script[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `script[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     expect(existingTags).to.be.empty;
 
@@ -2011,7 +2334,7 @@ describe("Helmet - Declarative API", () => {
         });
 
         describe("noscript tags", () => {
-            it("updates noscript tags", (done) => {
+            it("updates noscript tags", done => {
                 const noscriptInnerHTML = `<link rel="stylesheet" type="text/css" href="foo.css" />`;
                 ReactDOM.render(
                     <Helmet>
@@ -2021,17 +2344,22 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const existingTags = headElement.getElementsByTagName("noscript");
+                    const existingTags = headElement.getElementsByTagName(
+                        "noscript"
+                    );
 
                     expect(existingTags).to.not.equal(undefined);
                     expect(existingTags.length).to.equal(1);
-                    expect(existingTags[0].innerHTML === noscriptInnerHTML && existingTags[0].id === "bar");
+                    expect(
+                        existingTags[0].innerHTML === noscriptInnerHTML &&
+                            existingTags[0].id === "bar"
+                    );
 
                     done();
                 });
             });
 
-            it("clears all noscripts tags if none are specified", (done) => {
+            it("clears all noscripts tags if none are specified", done => {
                 ReactDOM.render(
                     <Helmet>
                         <noscript id="bar" />
@@ -2043,7 +2371,9 @@ describe("Helmet - Declarative API", () => {
                     ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
-                        const existingTags = headElement.querySelectorAll(`script[${HELMET_ATTRIBUTE}]`);
+                        const existingTags = headElement.querySelectorAll(
+                            `script[${HELMET_ATTRIBUTE}]`
+                        );
 
                         expect(existingTags).to.not.equal(undefined);
                         expect(existingTags.length).to.equal(0);
@@ -2053,7 +2383,7 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("tags without 'innerHTML' are not accepted", (done) => {
+            it("tags without 'innerHTML' are not accepted", done => {
                 ReactDOM.render(
                     <Helmet>
                         <noscript property="won't work" />
@@ -2062,7 +2392,9 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const existingTags = headElement.querySelectorAll(`noscript[${HELMET_ATTRIBUTE}]`);
+                    const existingTags = headElement.querySelectorAll(
+                        `noscript[${HELMET_ATTRIBUTE}]`
+                    );
 
                     expect(existingTags).to.not.equal(undefined);
                     expect(existingTags.length).to.equal(0);
@@ -2071,7 +2403,7 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("does not render tag when primary attribute is null", (done) => {
+            it("does not render tag when primary attribute is null", done => {
                 ReactDOM.render(
                     <Helmet>
                         <noscript>{undefined}</noscript>
@@ -2080,7 +2412,9 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`noscript[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `noscript[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     expect(existingTags).to.be.empty;
 
@@ -2090,7 +2424,7 @@ describe("Helmet - Declarative API", () => {
         });
 
         describe("style tags", () => {
-            it("updates style tags", (done) => {
+            it("updates style tags", done => {
                 const cssText1 = `
                     body {
                         background-color: green;
@@ -2111,35 +2445,38 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`style[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `style[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
 
-                    const [
-                        firstTag,
-                        secondTag
-                    ] = existingTags;
+                    const [firstTag, secondTag] = existingTags;
                     expect(existingTags).to.not.equal(undefined);
                     expect(existingTags.length).to.be.equal(2);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
                     expect(firstTag.getAttribute("type")).to.equal("text/css");
                     expect(firstTag.innerHTML).to.equal(cssText1);
-                    expect(firstTag.outerHTML).to.equal(`<style type="text/css" ${HELMET_ATTRIBUTE}="true">${cssText1}</style>`);
+                    expect(firstTag.outerHTML).to.equal(
+                        `<style type="text/css" ${HELMET_ATTRIBUTE}="true">${cssText1}</style>`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[1]")
+                    expect(existingTags).to.have.deep
+                        .property("[1]")
                         .that.is.an.instanceof(Element);
                     expect(secondTag.innerHTML).to.equal(cssText2);
-                    expect(secondTag.outerHTML).to.equal(`<style ${HELMET_ATTRIBUTE}="true">${cssText2}</style>`);
+                    expect(secondTag.outerHTML).to.equal(
+                        `<style ${HELMET_ATTRIBUTE}="true">${cssText2}</style>`
+                    );
 
                     done();
                 });
             });
 
-            it("clears all style tags if none are specified", (done) => {
+            it("clears all style tags if none are specified", done => {
                 const cssText = `
                     body {
                         background-color: green;
@@ -2153,13 +2490,12 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    ReactDOM.render(
-                        <Helmet />,
-                        container
-                    );
+                    ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
-                        const existingTags = headElement.querySelectorAll(`style[${HELMET_ATTRIBUTE}]`);
+                        const existingTags = headElement.querySelectorAll(
+                            `style[${HELMET_ATTRIBUTE}]`
+                        );
 
                         expect(existingTags).to.not.equal(undefined);
                         expect(existingTags.length).to.equal(0);
@@ -2169,7 +2505,7 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("tags without 'cssText' are not accepted", (done) => {
+            it("tags without 'cssText' are not accepted", done => {
                 ReactDOM.render(
                     <Helmet>
                         <style property="won't work" />
@@ -2178,7 +2514,9 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const existingTags = headElement.querySelectorAll(`style[${HELMET_ATTRIBUTE}]`);
+                    const existingTags = headElement.querySelectorAll(
+                        `style[${HELMET_ATTRIBUTE}]`
+                    );
 
                     expect(existingTags).to.not.equal(undefined);
                     expect(existingTags.length).to.equal(0);
@@ -2187,7 +2525,7 @@ describe("Helmet - Declarative API", () => {
                 });
             });
 
-            it("does not render tag when primary attribute is null", (done) => {
+            it("does not render tag when primary attribute is null", done => {
                 ReactDOM.render(
                     <Helmet>
                         <style>{undefined}</style>
@@ -2196,7 +2534,9 @@ describe("Helmet - Declarative API", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`style[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `style[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     expect(existingTags).to.be.empty;
 
@@ -2212,6 +2552,7 @@ describe("Helmet - Declarative API", () => {
         const stringifiedTitle = `<title ${HELMET_ATTRIBUTE}="true">Dangerous &lt;script&gt; include</title>`;
         const unEncodedStringifiedTitle = `<title ${HELMET_ATTRIBUTE}="true">This is text and & and '.</title>`;
         const stringifiedTitleWithItemprop = `<title ${HELMET_ATTRIBUTE}="true" itemprop="name">Title with Itemprop</title>`;
+        const stringifiedTitleWithTitleExpression = `<title ${HELMET_ATTRIBUTE}="true">Title: Some Great Title</title>`;
         const stringifiedBaseTag = `<base ${HELMET_ATTRIBUTE}="true" target="_blank" href="http://localhost/"/>`;
 
         const stringifiedMetaTags = [
@@ -2274,9 +2615,7 @@ describe("Helmet - Declarative API", () => {
 
         it("opts out of string encoding", () => {
             ReactDOM.render(
-                <Helmet
-                    encodeSpecialCharacters={false}
-                >
+                <Helmet encodeSpecialCharacters={false}>
                     <title>{"This is text and & and '."}</title>
                 </Helmet>,
                 container
@@ -2304,13 +2643,11 @@ describe("Helmet - Declarative API", () => {
 
             const titleComponent = head.title.toComponent();
 
-            expect(titleComponent)
-                .to.be.an("array")
-                .that.has.length.of(1);
+            expect(titleComponent).to.be.an("array").that.has.length.of(1);
 
             titleComponent.forEach(title => {
-                expect(title)
-                    .to.be.an("object")
+                expect(title).to.be
+                    .an("object")
                     .that.contains.property("type", "title");
             });
 
@@ -2320,11 +2657,9 @@ describe("Helmet - Declarative API", () => {
                 </div>
             );
 
-            expect(markup)
-                .to.be.a("string")
-                .that.equals(`<div>${
-                    stringifiedTitle
-                }</div>`);
+            expect(markup).to.be
+                .a("string")
+                .that.equals(`<div>${stringifiedTitle}</div>`);
         });
 
         it("renders title with itemprop name as React component", () => {
@@ -2342,13 +2677,11 @@ describe("Helmet - Declarative API", () => {
 
             const titleComponent = head.title.toComponent();
 
-            expect(titleComponent)
-                .to.be.an("array")
-                .that.has.length.of(1);
+            expect(titleComponent).to.be.an("array").that.has.length.of(1);
 
             titleComponent.forEach(title => {
-                expect(title)
-                    .to.be.an("object")
+                expect(title).to.be
+                    .an("object")
                     .that.contains.property("type", "title");
             });
 
@@ -2358,11 +2691,9 @@ describe("Helmet - Declarative API", () => {
                 </div>
             );
 
-            expect(markup)
-                .to.be.a("string")
-                .that.equals(`<div>${
-                    stringifiedTitleWithItemprop
-                }</div>`);
+            expect(markup).to.be
+                .a("string")
+                .that.equals(`<div>${stringifiedTitleWithItemprop}</div>`);
         });
 
         it("renders base tag as React component", () => {
@@ -2380,13 +2711,11 @@ describe("Helmet - Declarative API", () => {
 
             const baseComponent = head.base.toComponent();
 
-            expect(baseComponent)
-                .to.be.an("array")
-                .that.has.length.of(1);
+            expect(baseComponent).to.be.an("array").that.has.length.of(1);
 
             baseComponent.forEach(base => {
-                expect(base)
-                    .to.be.an("object")
+                expect(base).to.be
+                    .an("object")
                     .that.contains.property("type", "base");
             });
 
@@ -2396,18 +2725,21 @@ describe("Helmet - Declarative API", () => {
                 </div>
             );
 
-            expect(markup)
-                .to.be.a("string")
-                .that.equals(`<div>${
-                    stringifiedBaseTag
-                }</div>`);
+            expect(markup).to.be
+                .a("string")
+                .that.equals(`<div>${stringifiedBaseTag}</div>`);
         });
 
         it("renders meta tags as React components", () => {
             ReactDOM.render(
                 <Helmet>
                     <meta charSet="utf-8" />
-                    <meta name="description" content={"Test description & encoding of special characters like ' \" > < `"} />
+                    <meta
+                        name="description"
+                        content={
+                            "Test description & encoding of special characters like ' \" > < `"
+                        }
+                    />
                     <meta httpEquiv="content-type" content="text/html" />
                     <meta property="og:type" content="article" />
                     <meta itemProp="name" content="Test name itemprop" />
@@ -2422,13 +2754,11 @@ describe("Helmet - Declarative API", () => {
 
             const metaComponent = head.meta.toComponent();
 
-            expect(metaComponent)
-                .to.be.an("array")
-                .that.has.length.of(5);
+            expect(metaComponent).to.be.an("array").that.has.length.of(5);
 
             metaComponent.forEach(meta => {
-                expect(meta)
-                    .to.be.an("object")
+                expect(meta).to.be
+                    .an("object")
                     .that.contains.property("type", "meta");
             });
 
@@ -2438,18 +2768,20 @@ describe("Helmet - Declarative API", () => {
                 </div>
             );
 
-            expect(markup)
-                .to.be.a("string")
-                .that.equals(`<div>${
-                    stringifiedMetaTags
-                }</div>`);
+            expect(markup).to.be
+                .a("string")
+                .that.equals(`<div>${stringifiedMetaTags}</div>`);
         });
 
         it("renders link tags as React components", () => {
             ReactDOM.render(
                 <Helmet>
                     <link href="http://localhost/helmet" rel="canonical" />
-                    <link href="http://localhost/style.css" rel="stylesheet" type="text/css" />
+                    <link
+                        href="http://localhost/style.css"
+                        rel="stylesheet"
+                        type="text/css"
+                    />
                 </Helmet>,
                 container
             );
@@ -2461,13 +2793,11 @@ describe("Helmet - Declarative API", () => {
 
             const linkComponent = head.link.toComponent();
 
-            expect(linkComponent)
-                .to.be.an("array")
-                .that.has.length.of(2);
+            expect(linkComponent).to.be.an("array").that.has.length.of(2);
 
             linkComponent.forEach(link => {
-                expect(link)
-                    .to.be.an("object")
+                expect(link).to.be
+                    .an("object")
                     .that.contains.property("type", "link");
             });
 
@@ -2477,18 +2807,22 @@ describe("Helmet - Declarative API", () => {
                 </div>
             );
 
-            expect(markup)
-                .to.be.a("string")
-                .that.equals(`<div>${
-                    stringifiedLinkTags
-                }</div>`);
+            expect(markup).to.be
+                .a("string")
+                .that.equals(`<div>${stringifiedLinkTags}</div>`);
         });
 
         it("renders script tags as React components", () => {
             ReactDOM.render(
                 <Helmet>
-                    <script src="http://localhost/test.js" type="text/javascript" />
-                    <script src="http://localhost/test2.js" type="text/javascript" />
+                    <script
+                        src="http://localhost/test.js"
+                        type="text/javascript"
+                    />
+                    <script
+                        src="http://localhost/test2.js"
+                        type="text/javascript"
+                    />
                 </Helmet>,
                 container
             );
@@ -2500,13 +2834,11 @@ describe("Helmet - Declarative API", () => {
 
             const scriptComponent = head.script.toComponent();
 
-            expect(scriptComponent)
-                .to.be.an("array")
-                .that.has.length.of(2);
+            expect(scriptComponent).to.be.an("array").that.has.length.of(2);
 
             scriptComponent.forEach(script => {
-                expect(script)
-                    .to.be.an("object")
+                expect(script).to.be
+                    .an("object")
                     .that.contains.property("type", "script");
             });
 
@@ -2516,11 +2848,9 @@ describe("Helmet - Declarative API", () => {
                 </div>
             );
 
-            expect(markup)
-                .to.be.a("string")
-                .that.equals(`<div>${
-                    stringifiedScriptTags
-                }</div>`);
+            expect(markup).to.be
+                .a("string")
+                .that.equals(`<div>${stringifiedScriptTags}</div>`);
         });
 
         it("renders noscript tags as React components", () => {
@@ -2539,13 +2869,11 @@ describe("Helmet - Declarative API", () => {
 
             const noscriptComponent = head.noscript.toComponent();
 
-            expect(noscriptComponent)
-                .to.be.an("array")
-                .that.has.length.of(2);
+            expect(noscriptComponent).to.be.an("array").that.has.length.of(2);
 
             noscriptComponent.forEach(noscript => {
-                expect(noscript)
-                    .to.be.an("object")
+                expect(noscript).to.be
+                    .an("object")
                     .that.contains.property("type", "noscript");
             });
 
@@ -2555,11 +2883,9 @@ describe("Helmet - Declarative API", () => {
                 </div>
             );
 
-            expect(markup)
-                .to.be.a("string")
-                .that.equals(`<div>${
-                    stringifiedNoscriptTags
-                }</div>`);
+            expect(markup).to.be
+                .a("string")
+                .that.equals(`<div>${stringifiedNoscriptTags}</div>`);
         });
 
         it("renders style tags as React components", () => {
@@ -2578,9 +2904,7 @@ describe("Helmet - Declarative API", () => {
 
             const styleComponent = head.style.toComponent();
 
-            expect(styleComponent)
-                .to.be.an("array")
-                .that.has.length.of(2);
+            expect(styleComponent).to.be.an("array").that.has.length.of(2);
 
             const markup = ReactServer.renderToStaticMarkup(
                 <div>
@@ -2588,11 +2912,9 @@ describe("Helmet - Declarative API", () => {
                 </div>
             );
 
-            expect(markup)
-                .to.be.a("string")
-                .that.equals(`<div>${
-                    stringifiedStyleTags
-                }</div>`);
+            expect(markup).to.be
+                .a("string")
+                .that.equals(`<div>${stringifiedStyleTags}</div>`);
         });
 
         it("renders title tag as string", () => {
@@ -2608,11 +2930,35 @@ describe("Helmet - Declarative API", () => {
             expect(head.title).to.exist;
             expect(head.title).to.respondTo("toString");
 
-            expect(head.title.toString())
-                .to.be.a("string")
+            expect(head.title.toString()).to.be
+                .a("string")
                 .that.equals(stringifiedTitle);
         });
 
+        it("renders title and allows children containing expressions", done => {
+            const someValue = "Some Great Title";
+
+            ReactDOM.render(
+                <Helmet>
+                    <title>Title: {someValue}</title>
+                </Helmet>,
+                container
+            );
+
+            const head = Helmet.rewind();
+
+            expect(head.title).to.exist;
+            expect(head.title).to.respondTo("toString");
+
+            requestIdleCallback(() => {
+                expect(head.title.toString()).to.be
+                    .a("string")
+                    .that.equals(stringifiedTitleWithTitleExpression);
+
+                done();
+            });
+        });
+
         it("renders title with itemprop name as string", () => {
             ReactDOM.render(
                 <Helmet>
@@ -2627,8 +2973,8 @@ describe("Helmet - Declarative API", () => {
             expect(head.title).to.respondTo("toString");
 
             const titleString = head.title.toString();
-            expect(titleString)
-                .to.be.a("string")
+            expect(titleString).to.be
+                .a("string")
                 .that.equals(stringifiedTitleWithItemprop);
         });
 
@@ -2645,8 +2991,8 @@ describe("Helmet - Declarative API", () => {
             expect(head.base).to.exist;
             expect(head.base).to.respondTo("toString");
 
-            expect(head.base.toString())
-                .to.be.a("string")
+            expect(head.base.toString()).to.be
+                .a("string")
                 .that.equals(stringifiedBaseTag);
         });
 
@@ -2654,7 +3000,10 @@ describe("Helmet - Declarative API", () => {
             ReactDOM.render(
                 <Helmet>
                     <meta charSet="utf-8" />
-                    <meta name="description" content="Test description &amp; encoding of special characters like &#x27; &quot; &gt; &lt; `" />
+                    <meta
+                        name="description"
+                        content="Test description &amp; encoding of special characters like &#x27; &quot; &gt; &lt; `"
+                    />
                     <meta httpEquiv="content-type" content="text/html" />
                     <meta property="og:type" content="article" />
                     <meta itemProp="name" content="Test name itemprop" />
@@ -2667,8 +3016,8 @@ describe("Helmet - Declarative API", () => {
             expect(head.meta).to.exist;
             expect(head.meta).to.respondTo("toString");
 
-            expect(head.meta.toString())
-                .to.be.a("string")
+            expect(head.meta.toString()).to.be
+                .a("string")
                 .that.equals(stringifiedMetaTags);
         });
 
@@ -2676,7 +3025,11 @@ describe("Helmet - Declarative API", () => {
             ReactDOM.render(
                 <Helmet>
                     <link href="http://localhost/helmet" rel="canonical" />
-                    <link href="http://localhost/style.css" rel="stylesheet" type="text/css" />
+                    <link
+                        href="http://localhost/style.css"
+                        rel="stylesheet"
+                        type="text/css"
+                    />
                 </Helmet>,
                 container
             );
@@ -2686,16 +3039,22 @@ describe("Helmet - Declarative API", () => {
             expect(head.link).to.exist;
             expect(head.link).to.respondTo("toString");
 
-            expect(head.link.toString())
-                .to.be.a("string")
+            expect(head.link.toString()).to.be
+                .a("string")
                 .that.equals(stringifiedLinkTags);
         });
 
         it("renders script tags as string", () => {
             ReactDOM.render(
                 <Helmet>
-                    <script src="http://localhost/test.js" type="text/javascript" />
-                    <script src="http://localhost/test2.js" type="text/javascript" />
+                    <script
+                        src="http://localhost/test.js"
+                        type="text/javascript"
+                    />
+                    <script
+                        src="http://localhost/test2.js"
+                        type="text/javascript"
+                    />
                 </Helmet>,
                 container
             );
@@ -2705,8 +3064,8 @@ describe("Helmet - Declarative API", () => {
             expect(head.script).to.exist;
             expect(head.script).to.respondTo("toString");
 
-            expect(head.script.toString())
-                .to.be.a("string")
+            expect(head.script.toString()).to.be
+                .a("string")
                 .that.equals(stringifiedScriptTags);
         });
 
@@ -2724,8 +3083,8 @@ describe("Helmet - Declarative API", () => {
             expect(head.style).to.exist;
             expect(head.style).to.respondTo("toString");
 
-            expect(head.style.toString())
-                .to.be.a("string")
+            expect(head.style.toString()).to.be
+                .a("string")
                 .that.equals(stringifiedStyleTags);
         });
 
@@ -2746,8 +3105,8 @@ describe("Helmet - Declarative API", () => {
                 <html lang="en" {...attrs} />
             );
 
-            expect(markup)
-                .to.be.a("string")
+            expect(markup).to.be
+                .a("string")
                 .that.equals(`<html ${stringifiedHtmlAttributes}></html>`);
         });
 
@@ -2764,8 +3123,8 @@ describe("Helmet - Declarative API", () => {
             expect(head.htmlAttributes).to.exist;
             expect(head.htmlAttributes).to.respondTo("toString");
 
-            expect(head.htmlAttributes.toString())
-                .to.be.a("string")
+            expect(head.htmlAttributes.toString()).to.be
+                .a("string")
                 .that.equals(stringifiedHtmlAttributes);
         });
 
@@ -2786,8 +3145,8 @@ describe("Helmet - Declarative API", () => {
                 <body lang="en" {...attrs} />
             );
 
-            expect(markup)
-                .to.be.a("string")
+            expect(markup).to.be
+                .a("string")
                 .that.equals(`<body ${stringifiedBodyAttributes}></body>`);
         });
 
@@ -2804,8 +3163,8 @@ describe("Helmet - Declarative API", () => {
             expect(body.bodyAttributes).to.exist;
             expect(body.bodyAttributes).to.respondTo("toString");
 
-            expect(body.bodyAttributes.toString())
-                .to.be.a("string")
+            expect(body.bodyAttributes.toString()).to.be
+                .a("string")
                 .that.equals(stringifiedBodyAttributes);
         });
 
@@ -2827,16 +3186,13 @@ describe("Helmet - Declarative API", () => {
             expect(head.title).to.exist;
             expect(head.title).to.respondTo("toString");
 
-            expect(head.title.toString())
-                .to.be.a("string")
+            expect(head.title.toString()).to.be
+                .a("string")
                 .that.equals(stringifiedChineseTitle);
         });
 
         it("rewind() provides a fallback object for empty Helmet state", () => {
-            ReactDOM.render(
-                <div />,
-                container
-            );
+            ReactDOM.render(<div />, container);
 
             const head = Helmet.rewind();
 
@@ -2844,12 +3200,14 @@ describe("Helmet - Declarative API", () => {
             expect(head.htmlAttributes).to.respondTo("toString");
             expect(head.htmlAttributes.toString()).to.equal("");
             expect(head.htmlAttributes).to.respondTo("toComponent");
-            expect(head.htmlAttributes.toComponent()).to.be.an("object")
-                .that.is.empty;
+            expect(head.htmlAttributes.toComponent()).to.be.an("object").that.is
+                .empty;
 
             expect(head.title).to.exist;
             expect(head.title).to.respondTo("toString");
-            expect(head.title.toString()).to.equal(`<title ${HELMET_ATTRIBUTE}="true"></title>`);
+            expect(head.title.toString()).to.equal(
+                `<title ${HELMET_ATTRIBUTE}="true"></title>`
+            );
             expect(head.title).to.respondTo("toComponent");
 
             const markup = ReactServer.renderToStaticMarkup(
@@ -2858,51 +3216,47 @@ describe("Helmet - Declarative API", () => {
                 </div>
             );
 
-            expect(markup)
-                .to.be.a("string")
-                .that.equals(`<div><title ${HELMET_ATTRIBUTE}="true"></title></div>`);
+            expect(markup).to.be
+                .a("string")
+                .that.equals(
+                    `<div><title ${HELMET_ATTRIBUTE}="true"></title></div>`
+                );
 
             expect(head.base).to.exist;
             expect(head.base).to.respondTo("toString");
             expect(head.base.toString()).to.equal("");
             expect(head.base).to.respondTo("toComponent");
-            expect(head.base.toComponent()).to.be.an("array")
-                .that.is.empty;
+            expect(head.base.toComponent()).to.be.an("array").that.is.empty;
 
             expect(head.meta).to.exist;
             expect(head.meta).to.respondTo("toString");
             expect(head.meta.toString()).to.equal("");
             expect(head.meta).to.respondTo("toComponent");
-            expect(head.meta.toComponent()).to.be.an("array")
-                .that.is.empty;
+            expect(head.meta.toComponent()).to.be.an("array").that.is.empty;
 
             expect(head.link).to.exist;
             expect(head.link).to.respondTo("toString");
             expect(head.link.toString()).to.equal("");
             expect(head.link).to.respondTo("toComponent");
-            expect(head.link.toComponent()).to.be.an("array")
-                .that.is.empty;
+            expect(head.link.toComponent()).to.be.an("array").that.is.empty;
 
             expect(head.script).to.exist;
             expect(head.script).to.respondTo("toString");
             expect(head.script.toString()).to.equal("");
             expect(head.script).to.respondTo("toComponent");
-            expect(head.script.toComponent()).to.be.an("array")
-                .that.is.empty;
+            expect(head.script.toComponent()).to.be.an("array").that.is.empty;
 
             expect(head.noscript).to.exist;
             expect(head.noscript).to.respondTo("toString");
             expect(head.noscript.toString()).to.equal("");
             expect(head.noscript).to.respondTo("toComponent");
-            expect(head.noscript.toComponent()).to.be.an("array")
-                .that.is.empty;
+            expect(head.noscript.toComponent()).to.be.an("array").that.is.empty;
 
             expect(head.style).to.exist;
             expect(head.style).to.respondTo("toString");
             expect(head.style.toString()).to.equal("");
             expect(head.style).to.respondTo("toComponent");
-            expect(head.style.toComponent()).to.be.an("array")
-                .that.is.empty;
+            expect(head.style.toComponent()).to.be.an("array").that.is.empty;
         });
 
         it("does not render undefined attribute values", () => {
@@ -2916,9 +3270,11 @@ describe("Helmet - Declarative API", () => {
             const {script} = Helmet.rewind();
             const stringifiedScriptTag = script.toString();
 
-            expect(stringifiedScriptTag)
-                .to.be.a("string")
-                .that.equals(`<script ${HELMET_ATTRIBUTE}="true" src="foo.js" async></script>`);
+            expect(stringifiedScriptTag).to.be
+                .a("string")
+                .that.equals(
+                    `<script ${HELMET_ATTRIBUTE}="true" src="foo.js" async></script>`
+                );
         });
 
         context("renderStatic", () => {
@@ -2953,13 +3309,11 @@ describe("Helmet - Declarative API", () => {
 
                 const titleComponent = head.title.toComponent();
 
-                expect(titleComponent)
-                    .to.be.an("array")
-                    .that.has.length.of(1);
+                expect(titleComponent).to.be.an("array").that.has.length.of(1);
 
                 titleComponent.forEach(title => {
-                    expect(title)
-                        .to.be.an("object")
+                    expect(title).to.be
+                        .an("object")
                         .that.contains.property("type", "title");
                 });
 
@@ -2969,11 +3323,9 @@ describe("Helmet - Declarative API", () => {
                     </div>
                 );
 
-                expect(markup)
-                    .to.be.a("string")
-                    .that.equals(`<div>${
-                        stringifiedTitle
-                    }</div>`);
+                expect(markup).to.be
+                    .a("string")
+                    .that.equals(`<div>${stringifiedTitle}</div>`);
             });
         });
 
@@ -2996,7 +3348,7 @@ describe("Helmet - Declarative API", () => {
             );
         });
 
-        it("lets you read current state in peek() whether or not a DOM is present", (done) => {
+        it("lets you read current state in peek() whether or not a DOM is present", done => {
             ReactDOM.render(
                 <Helmet>
                     <title>Fancy title</title>
@@ -3014,42 +3366,50 @@ describe("Helmet - Declarative API", () => {
             });
         });
 
-        it("encodes special characters", (done) => {
+        it("encodes special characters", done => {
             ReactDOM.render(
                 <Helmet>
-                    <meta name="description" content={"This is \"quoted\" text and & and '."} />
+                    <meta
+                        name="description"
+                        content={'This is "quoted" text and & and \'.'}
+                    />
                 </Helmet>,
                 container
             );
 
             requestIdleCallback(() => {
-                const existingTags = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                const existingTags = headElement.querySelectorAll(
+                    `meta[${HELMET_ATTRIBUTE}]`
+                );
                 const existingTag = existingTags[0];
 
                 expect(existingTags).to.not.equal(undefined);
 
                 expect(existingTags.length).to.be.equal(1);
 
-                expect(existingTags)
-                    .to.have.deep.property("[0]")
+                expect(existingTags).to.have.deep
+                    .property("[0]")
                     .that.is.an.instanceof(Element);
                 expect(existingTag).to.have.property("getAttribute");
-                expect(existingTag.getAttribute("name")).to.equal("description");
-                expect(existingTag.getAttribute("content")).to.equal("This is \"quoted\" text and & and '.");
-                expect(existingTag.outerHTML).to.equal(`<meta name="description" content="This is &quot;quoted&quot; text and &amp; and '." ${HELMET_ATTRIBUTE}="true">`);
+                expect(existingTag.getAttribute("name")).to.equal(
+                    "description"
+                );
+                expect(existingTag.getAttribute("content")).to.equal(
+                    'This is "quoted" text and & and \'.'
+                );
+                expect(existingTag.outerHTML).to.equal(
+                    `<meta name="description" content="This is &quot;quoted&quot; text and &amp; and '." ${HELMET_ATTRIBUTE}="true">`
+                );
 
                 done();
             });
         });
 
-        it("does not change the DOM if it recevies identical props", (done) => {
+        it("does not change the DOM if it recevies identical props", done => {
             const spy = sinon.spy();
             ReactDOM.render(
                 <Helmet onChangeClientState={spy}>
-                    <meta
-                        name="description"
-                        content="Test description"
-                    />
+                    <meta name="description" content="Test description" />
                     <title>Test Title</title>
                 </Helmet>,
                 container
@@ -3058,13 +3418,8 @@ describe("Helmet - Declarative API", () => {
             requestIdleCallback(() => {
                 // Re-rendering will pass new props to an already mounted Helmet
                 ReactDOM.render(
-                    <Helmet
-                        onChangeClientState={spy}
-                    >
-                        <meta
-                            name="description"
-                            content="Test description"
-                        />
+                    <Helmet onChangeClientState={spy}>
+                        <meta name="description" content="Test description" />
                         <title>Test Title</title>
                     </Helmet>,
                     container
@@ -3078,13 +3433,16 @@ describe("Helmet - Declarative API", () => {
             });
         });
 
-        it("does not write the DOM if the client and server are identical", (done) => {
+        it("does not write the DOM if the client and server are identical", done => {
             headElement.innerHTML = `<script ${HELMET_ATTRIBUTE}="true" src="http://localhost/test.js" type="text/javascript" />`;
 
             const spy = sinon.spy();
             ReactDOM.render(
                 <Helmet onChangeClientState={spy}>
-                    <script src="http://localhost/test.js" type="text/javascript" />
+                    <script
+                        src="http://localhost/test.js"
+                        type="text/javascript"
+                    />
                 </Helmet>,
                 container
             );
@@ -3101,7 +3459,7 @@ describe("Helmet - Declarative API", () => {
             });
         });
 
-        it("only adds new tags and preserves tags when rendering additional Helmet instances", (done) => {
+        it("only adds new tags and preserves tags when rendering additional Helmet instances", done => {
             const spy = sinon.spy();
             let addedTags;
             let removedTags;
@@ -3112,10 +3470,7 @@ describe("Helmet - Declarative API", () => {
                         rel="stylesheet"
                         type="text/css"
                     />
-                    <meta
-                        name="description"
-                        content="Test description"
-                    />
+                    <meta name="description" content="Test description" />
                 </Helmet>,
                 container
             );
@@ -3127,10 +3482,14 @@ describe("Helmet - Declarative API", () => {
 
                 expect(addedTags).to.have.property("metaTags");
                 expect(addedTags.metaTags).to.have.deep.property("[0]");
-                expect(addedTags.metaTags[0].outerHTML).to.equal(`<meta name="description" content="Test description" data-react-helmet="true">`);
+                expect(addedTags.metaTags[0].outerHTML).to.equal(
+                    `<meta name="description" content="Test description" data-react-helmet="true">`
+                );
                 expect(addedTags).to.have.property("linkTags");
                 expect(addedTags.linkTags).to.have.deep.property("[0]");
-                expect(addedTags.linkTags[0].outerHTML).to.equal(`<link href="http://localhost/style.css" rel="stylesheet" type="text/css" data-react-helmet="true">`);
+                expect(addedTags.linkTags[0].outerHTML).to.equal(
+                    `<link href="http://localhost/style.css" rel="stylesheet" type="text/css" data-react-helmet="true">`
+                );
                 expect(removedTags).to.be.empty;
 
                 // Re-rendering will pass new props to an already mounted Helmet
@@ -3146,10 +3505,7 @@ describe("Helmet - Declarative API", () => {
                             rel="stylesheet"
                             type="text/css"
                         />
-                        <meta
-                            name="description"
-                            content="New description"
-                        />
+                        <meta name="description" content="New description" />
                     </Helmet>,
                     container
                 );
@@ -3161,13 +3517,19 @@ describe("Helmet - Declarative API", () => {
 
                     expect(addedTags).to.have.property("metaTags");
                     expect(addedTags.metaTags).to.have.deep.property("[0]");
-                    expect(addedTags.metaTags[0].outerHTML).to.equal(`<meta name="description" content="New description" data-react-helmet="true">`);
+                    expect(addedTags.metaTags[0].outerHTML).to.equal(
+                        `<meta name="description" content="New description" data-react-helmet="true">`
+                    );
                     expect(addedTags).to.have.property("linkTags");
                     expect(addedTags.linkTags).to.have.deep.property("[0]");
-                    expect(addedTags.linkTags[0].outerHTML).to.equal(`<link href="http://localhost/style2.css" rel="stylesheet" type="text/css" data-react-helmet="true">`);
+                    expect(addedTags.linkTags[0].outerHTML).to.equal(
+                        `<link href="http://localhost/style2.css" rel="stylesheet" type="text/css" data-react-helmet="true">`
+                    );
                     expect(removedTags).to.have.property("metaTags");
                     expect(removedTags.metaTags).to.have.deep.property("[0]");
-                    expect(removedTags.metaTags[0].outerHTML).to.equal(`<meta name="description" content="Test description" data-react-helmet="true">`);
+                    expect(removedTags.metaTags[0].outerHTML).to.equal(
+                        `<meta name="description" content="Test description" data-react-helmet="true">`
+                    );
                     expect(removedTags).to.not.have.property("linkTags");
 
                     done();
@@ -3175,7 +3537,7 @@ describe("Helmet - Declarative API", () => {
             });
         });
 
-        it("does not accept nested Helmets", (done) => {
+        it("does not accept nested Helmets", done => {
             const warn = sinon.stub(console, "warn");
 
             ReactDOM.render(
@@ -3193,7 +3555,9 @@ describe("Helmet - Declarative API", () => {
                 expect(warn.called).to.be.true;
 
                 const [warning] = warn.getCall(0).args;
-                expect(warning).to.equal("You may be attempting to nest <Helmet> components within each other, which is not allowed. Refer to our API for more information.");
+                expect(warning).to.equal(
+                    "You may be attempting to nest <Helmet> components within each other, which is not allowed. Refer to our API for more information."
+                );
 
                 warn.restore();
 
@@ -3201,7 +3565,7 @@ describe("Helmet - Declarative API", () => {
             });
         });
 
-        it("warns on invalid elements", (done) => {
+        it("warns on invalid elements", done => {
             const warn = sinon.stub(console, "warn");
 
             ReactDOM.render(
@@ -3219,14 +3583,16 @@ describe("Helmet - Declarative API", () => {
                 expect(warn.called).to.be.true;
 
                 const [warning] = warn.getCall(0).args;
-                expect(warning).to.equal("Only elements types base, body, head, html, link, meta, noscript, script, style, title are allowed. Helmet does not support rendering <div> elements. Refer to our API for more information.");
+                expect(warning).to.equal(
+                    "Only elements types base, body, head, html, link, meta, noscript, script, style, title are allowed. Helmet does not support rendering <div> elements. Refer to our API for more information."
+                );
 
                 warn.restore();
                 done();
             });
         });
 
-        it("warns on invalid self-closing elements", (done) => {
+        it("warns on invalid self-closing elements", done => {
             const warn = sinon.stub(console, "warn");
 
             ReactDOM.render(
@@ -3242,7 +3608,9 @@ describe("Helmet - Declarative API", () => {
                 expect(warn.called).to.be.true;
 
                 const [warning] = warn.getCall(0).args;
-                expect(warning).to.equal("Only elements types base, body, head, html, link, meta, noscript, script, style, title are allowed. Helmet does not support rendering <div> elements. Refer to our API for more information.");
+                expect(warning).to.equal(
+                    "Only elements types base, body, head, html, link, meta, noscript, script, style, title are allowed. Helmet does not support rendering <div> elements. Refer to our API for more information."
+                );
 
                 warn.restore();
                 done();
@@ -3250,21 +3618,26 @@ describe("Helmet - Declarative API", () => {
         });
 
         it("throws on invalid strings as children", () => {
-            const renderInvalid = () => (
+            const renderInvalid = () =>
                 ReactDOM.render(
                     <Helmet>
                         <title>Test Title</title>
-                        <link href="http://localhost/helmet" rel="canonical">{`test`}</link>
+                        <link
+                            href="http://localhost/helmet"
+                            rel="canonical"
+                        >{`test`}</link>
                     </Helmet>,
                     container
-                )
-            );
+                );
 
-            expect(renderInvalid).to.throw(Error, "<link /> elements are self-closing and can not contain children. Refer to our API for more information.");
+            expect(renderInvalid).to.throw(
+                Error,
+                "<link /> elements are self-closing and can not contain children. Refer to our API for more information."
+            );
         });
 
         it("throws on invalid children", () => {
-            const renderInvalid = () => (
+            const renderInvalid = () =>
                 ReactDOM.render(
                     <Helmet>
                         <title>Test Title</title>
@@ -3273,13 +3646,15 @@ describe("Helmet - Declarative API", () => {
                         </script>
                     </Helmet>,
                     container
-                )
-            );
+                );
 
-            expect(renderInvalid).to.throw(Error, "Helmet expects a string as a child of <script>. Did you forget to wrap your children in braces? ( <script>{``}</script> ) Refer to our API for more information.");
+            expect(renderInvalid).to.throw(
+                Error,
+                "Helmet expects a string as a child of <script>. Did you forget to wrap your children in braces? ( <script>{``}</script> ) Refer to our API for more information."
+            );
         });
 
-        it("handles undefined children", (done) => {
+        it("handles undefined children", done => {
             const charSet = undefined;
 
             ReactDOM.render(
@@ -3297,48 +3672,53 @@ describe("Helmet - Declarative API", () => {
             });
         });
 
-        it("recognizes valid tags regardless of attribute ordering", (done) => {
+        it("recognizes valid tags regardless of attribute ordering", done => {
             ReactDOM.render(
                 <Helmet>
-                    <meta
-                        content="Test Description"
-                        name="description"
-                    />
+                    <meta content="Test Description" name="description" />
                 </Helmet>,
                 container
             );
 
             requestIdleCallback(() => {
-                const existingTags = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                const existingTags = headElement.querySelectorAll(
+                    `meta[${HELMET_ATTRIBUTE}]`
+                );
                 const existingTag = existingTags[0];
 
                 expect(existingTags).to.not.equal(undefined);
 
                 expect(existingTags.length).to.be.equal(1);
 
-                expect(existingTags)
-                    .to.have.deep.property("[0]")
+                expect(existingTags).to.have.deep
+                    .property("[0]")
                     .that.is.an.instanceof(Element);
                 expect(existingTag).to.have.property("getAttribute");
-                expect(existingTag.getAttribute("name")).to.equal("description");
-                expect(existingTag.getAttribute("content")).to.equal("Test Description");
-                expect(existingTag.outerHTML).to.equal(`<meta content="Test Description" name="description" ${HELMET_ATTRIBUTE}="true">`);
+                expect(existingTag.getAttribute("name")).to.equal(
+                    "description"
+                );
+                expect(existingTag.getAttribute("content")).to.equal(
+                    "Test Description"
+                );
+                expect(existingTag.outerHTML).to.equal(
+                    `<meta content="Test Description" name="description" ${HELMET_ATTRIBUTE}="true">`
+                );
 
                 done();
             });
         });
 
-        it("requestIdleCallback works as expected", (done) => {
-            requestIdleCallback((cb) => {
+        it("requestIdleCallback works as expected", done => {
+            requestIdleCallback(cb => {
                 expect(cb).to.exist;
 
-                expect(cb)
-                    .to.have.property("didTimeout")
+                expect(cb).to.have
+                    .property("didTimeout")
                     .that.is.a("boolean")
                     .that.equals(false);
 
-                expect(cb)
-                    .to.have.property("timeRemaining")
+                expect(cb).to.have
+                    .property("timeRemaining")
                     .that.is.a("function");
 
                 const time = cb.timeRemaining();
diff --git a/test/HelmetTest.js b/test/HelmetTest.js
index d3b82874..43d02ff2 100644
--- a/test/HelmetTest.js
+++ b/test/HelmetTest.js
@@ -15,7 +15,8 @@ describe("Helmet", () => {
     const container = document.createElement("div");
 
     beforeEach(() => {
-        headElement = headElement || document.head || document.querySelector("head");
+        headElement =
+            headElement || document.head || document.querySelector("head");
 
         // resets DOM after each run
         headElement.innerHTML = "";
@@ -27,12 +28,9 @@ describe("Helmet", () => {
 
     describe("api", () => {
         describe("title", () => {
-            it("updates page title", (done) => {
+            it("updates page title", done => {
                 ReactDOM.render(
-                    <Helmet
-                        defaultTitle={"Fallback"}
-                        title={"Test Title"}
-                    />,
+                    <Helmet defaultTitle={"Fallback"} title={"Test Title"} />,
                     container
                 );
 
@@ -43,7 +41,7 @@ describe("Helmet", () => {
                 });
             });
 
-            it("updates page title with multiple children", (done) => {
+            it("updates page title with multiple children", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet title={"Test Title"} />
@@ -60,7 +58,7 @@ describe("Helmet", () => {
                 });
             });
 
-            it("sets title based on deepest nested component", (done) => {
+            it("sets title based on deepest nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet title={"Main Title"} />
@@ -76,7 +74,7 @@ describe("Helmet", () => {
                 });
             });
 
-            it("sets title using deepest nested component with a defined title", (done) => {
+            it("sets title using deepest nested component with a defined title", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet title={"Main Title"} />
@@ -92,12 +90,14 @@ describe("Helmet", () => {
                 });
             });
 
-            it("uses defaultTitle if no title is defined", (done) => {
+            it("uses defaultTitle if no title is defined", done => {
                 ReactDOM.render(
                     <Helmet
                         defaultTitle={"Fallback"}
                         title={""}
-                        titleTemplate={"This is a %s of the titleTemplate feature"}
+                        titleTemplate={
+                            "This is a %s of the titleTemplate feature"
+                        }
                     />,
                     container
                 );
@@ -109,67 +109,83 @@ describe("Helmet", () => {
                 });
             });
 
-            it("uses a titleTemplate if defined", (done) => {
+            it("uses a titleTemplate if defined", done => {
                 ReactDOM.render(
                     <Helmet
                         defaultTitle={"Fallback"}
                         title={"Test"}
-                        titleTemplate={"This is a %s of the titleTemplate feature"}
+                        titleTemplate={
+                            "This is a %s of the titleTemplate feature"
+                        }
                     />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    expect(document.title).to.equal("This is a Test of the titleTemplate feature");
+                    expect(document.title).to.equal(
+                        "This is a Test of the titleTemplate feature"
+                    );
 
                     done();
                 });
             });
 
-            it("replaces multiple title strings in titleTemplate", (done) => {
+            it("replaces multiple title strings in titleTemplate", done => {
                 ReactDOM.render(
                     <Helmet
                         title={"Test"}
-                        titleTemplate={"This is a %s of the titleTemplate feature. Another %s."}
+                        titleTemplate={
+                            "This is a %s of the titleTemplate feature. Another %s."
+                        }
                     />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    expect(document.title).to.equal("This is a Test of the titleTemplate feature. Another Test.");
+                    expect(document.title).to.equal(
+                        "This is a Test of the titleTemplate feature. Another Test."
+                    );
 
                     done();
                 });
             });
 
-            it("uses a titleTemplate based on deepest nested component", (done) => {
+            it("uses a titleTemplate based on deepest nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet
                             title={"Test"}
-                            titleTemplate={"This is a %s of the titleTemplate feature"}
+                            titleTemplate={
+                                "This is a %s of the titleTemplate feature"
+                            }
                         />
                         <Helmet
                             title={"Second Test"}
-                            titleTemplate={"A %s using nested titleTemplate attributes"}
+                            titleTemplate={
+                                "A %s using nested titleTemplate attributes"
+                            }
                         />
                     </div>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    expect(document.title).to.equal("A Second Test using nested titleTemplate attributes");
+                    expect(document.title).to.equal(
+                        "A Second Test using nested titleTemplate attributes"
+                    );
 
                     done();
                 });
             });
 
-            it("merges deepest component title with nearest upstream titleTemplate", (done) => {
+            it("merges deepest component title with nearest upstream titleTemplate", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet
                             title={"Test"}
-                            titleTemplate={"This is a %s of the titleTemplate feature"}
+                            titleTemplate={
+                                "This is a %s of the titleTemplate feature"
+                            }
                         />
                         <Helmet title={"Second Test"} />
                     </div>,
@@ -177,30 +193,35 @@ describe("Helmet", () => {
                 );
 
                 requestIdleCallback(() => {
-                    expect(document.title).to.equal("This is a Second Test of the titleTemplate feature");
+                    expect(document.title).to.equal(
+                        "This is a Second Test of the titleTemplate feature"
+                    );
 
                     done();
                 });
             });
 
-            it("renders dollar characters in a title correctly when titleTemplate present", (done) => {
+            it("renders dollar characters in a title correctly when titleTemplate present", done => {
                 const dollarTitle = "te$t te$$t te$$$t te$$$$t";
 
                 ReactDOM.render(
-                    <Helmet title={dollarTitle}
-                            titleTemplate={"This is a %s"}
+                    <Helmet
+                        title={dollarTitle}
+                        titleTemplate={"This is a %s"}
                     />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    expect(document.title).to.equal("This is a te$t te$$t te$$$t te$$$$t");
+                    expect(document.title).to.equal(
+                        "This is a te$t te$$t te$$$t te$$$$t"
+                    );
 
                     done();
                 });
             });
 
-            it("does not encode all characters with HTML character entity equivalents", (done) => {
+            it("does not encode all characters with HTML character entity equivalents", done => {
                 const chineseTitle = "膣膗 鍆錌雔";
 
                 ReactDOM.render(
@@ -217,7 +238,7 @@ describe("Helmet", () => {
                 });
             });
 
-            it("page title with prop itemprop", (done) => {
+            it("page title with prop itemprop", done => {
                 ReactDOM.render(
                     <Helmet
                         defaultTitle={"Fallback"}
@@ -242,7 +263,7 @@ describe("Helmet", () => {
                 headElement.innerHTML = `<title>Test Title</title>`;
             });
 
-            it("update title attributes", (done) => {
+            it("update title attributes", done => {
                 ReactDOM.render(
                     <Helmet
                         titleAttributes={{
@@ -255,24 +276,26 @@ describe("Helmet", () => {
                 requestIdleCallback(() => {
                     const titleTag = document.getElementsByTagName("title")[0];
                     expect(titleTag.getAttribute("itemprop")).to.equal("name");
-                    expect(titleTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("itemprop");
+                    expect(titleTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                        "itemprop"
+                    );
 
                     done();
                 });
             });
 
-            it("sets attributes based on the deepest nested component", (done) => {
+            it("sets attributes based on the deepest nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet
                             titleAttributes={{
-                                "lang": "en",
-                                "hidden": undefined
+                                lang: "en",
+                                hidden: undefined
                             }}
                         />
                         <Helmet
                             titleAttributes={{
-                                "lang": "ja"
+                                lang: "ja"
                             }}
                         />
                     </div>,
@@ -283,17 +306,19 @@ describe("Helmet", () => {
                     const titleTag = document.getElementsByTagName("title")[0];
                     expect(titleTag.getAttribute("lang")).to.equal("ja");
                     expect(titleTag.getAttribute("hidden")).to.equal("");
-                    expect(titleTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("lang,hidden");
+                    expect(titleTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                        "lang,hidden"
+                    );
 
                     done();
                 });
             });
 
-            it("handles valueless attributes", (done) => {
+            it("handles valueless attributes", done => {
                 ReactDOM.render(
                     <Helmet
                         titleAttributes={{
-                            "hidden": undefined
+                            hidden: undefined
                         }}
                     />,
                     container
@@ -302,34 +327,37 @@ describe("Helmet", () => {
                 requestIdleCallback(() => {
                     const titleTag = document.getElementsByTagName("title")[0];
                     expect(titleTag.getAttribute("hidden")).to.equal("");
-                    expect(titleTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("hidden");
+                    expect(titleTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                        "hidden"
+                    );
 
                     done();
                 });
             });
 
-            it("clears title attributes that are handled within helmet", (done) => {
+            it("clears title attributes that are handled within helmet", done => {
                 ReactDOM.render(
                     <Helmet
                         titleAttributes={{
-                            "lang": "en",
-                            "hidden": undefined
+                            lang: "en",
+                            hidden: undefined
                         }}
                     />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    ReactDOM.render(
-                        <Helmet />,
-                        container
-                    );
+                    ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
-                        const titleTag = document.getElementsByTagName("title")[0];
+                        const titleTag = document.getElementsByTagName(
+                            "title"
+                        )[0];
                         expect(titleTag.getAttribute("lang")).to.be.null;
                         expect(titleTag.getAttribute("hidden")).to.be.null;
-                        expect(titleTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(null);
+                        expect(
+                            titleTag.getAttribute(HELMET_ATTRIBUTE)
+                        ).to.equal(null);
 
                         done();
                     });
@@ -338,12 +366,12 @@ describe("Helmet", () => {
         });
 
         describe("html attributes", () => {
-            it("updates html attributes", (done) => {
+            it("updates html attributes", done => {
                 ReactDOM.render(
                     <Helmet
                         htmlAttributes={{
-                            "class": "myClassName",
-                            "lang": "en"
+                            class: "myClassName",
+                            lang: "en"
                         }}
                         lang="en"
                     />,
@@ -352,25 +380,29 @@ describe("Helmet", () => {
 
                 requestIdleCallback(() => {
                     const htmlTag = document.getElementsByTagName("html")[0];
-                    expect(htmlTag.getAttribute("class")).to.equal("myClassName");
+                    expect(htmlTag.getAttribute("class")).to.equal(
+                        "myClassName"
+                    );
                     expect(htmlTag.getAttribute("lang")).to.equal("en");
-                    expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("class,lang");
+                    expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                        "class,lang"
+                    );
 
                     done();
                 });
             });
 
-            it("sets attributes based on the deepest nested component", (done) => {
+            it("sets attributes based on the deepest nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet
                             htmlAttributes={{
-                                "lang": "en"
+                                lang: "en"
                             }}
                         />
                         <Helmet
                             htmlAttributes={{
-                                "lang": "ja"
+                                lang: "ja"
                             }}
                         />
                     </div>,
@@ -380,17 +412,19 @@ describe("Helmet", () => {
                 requestIdleCallback(() => {
                     const htmlTag = document.getElementsByTagName("html")[0];
                     expect(htmlTag.getAttribute("lang")).to.equal("ja");
-                    expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("lang");
+                    expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                        "lang"
+                    );
 
                     done();
                 });
             });
 
-            it("handles valueless attributes", (done) => {
+            it("handles valueless attributes", done => {
                 ReactDOM.render(
                     <Helmet
                         htmlAttributes={{
-                            "amp": undefined
+                            amp: undefined
                         }}
                     />,
                     container
@@ -399,46 +433,49 @@ describe("Helmet", () => {
                 requestIdleCallback(() => {
                     const htmlTag = document.getElementsByTagName("html")[0];
                     expect(htmlTag.getAttribute("amp")).to.equal("");
-                    expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("amp");
+                    expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                        "amp"
+                    );
 
                     done();
                 });
             });
 
-            it("clears html attributes that are handled within helmet", (done) => {
+            it("clears html attributes that are handled within helmet", done => {
                 ReactDOM.render(
                     <Helmet
                         htmlAttributes={{
-                            "lang": "en",
-                            "amp": undefined
+                            lang: "en",
+                            amp: undefined
                         }}
                     />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    ReactDOM.render(
-                        <Helmet />,
-                        container
-                    );
+                    ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
-                        const htmlTag = document.getElementsByTagName("html")[0];
+                        const htmlTag = document.getElementsByTagName(
+                            "html"
+                        )[0];
                         expect(htmlTag.getAttribute("lang")).to.be.null;
                         expect(htmlTag.getAttribute("amp")).to.be.null;
-                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(null);
+                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                            null
+                        );
 
                         done();
                     });
                 });
             });
 
-            it("updates with multiple additions and removals - overwrite and new", (done) => {
+            it("updates with multiple additions and removals - overwrite and new", done => {
                 ReactDOM.render(
                     <Helmet
                         htmlAttributes={{
-                            "lang": "en",
-                            "amp": undefined
+                            lang: "en",
+                            amp: undefined
                         }}
                     />,
                     container
@@ -448,33 +485,39 @@ describe("Helmet", () => {
                     ReactDOM.render(
                         <Helmet
                             htmlAttributes={{
-                                "lang": "ja",
-                                "id": "html-tag",
-                                "title": "html tag"
+                                lang: "ja",
+                                id: "html-tag",
+                                title: "html tag"
                             }}
                         />,
                         container
                     );
 
                     requestIdleCallback(() => {
-                        const htmlTag = document.getElementsByTagName("html")[0];
+                        const htmlTag = document.getElementsByTagName(
+                            "html"
+                        )[0];
                         expect(htmlTag.getAttribute("amp")).to.equal(null);
                         expect(htmlTag.getAttribute("lang")).to.equal("ja");
                         expect(htmlTag.getAttribute("id")).to.equal("html-tag");
-                        expect(htmlTag.getAttribute("title")).to.equal("html tag");
-                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("lang,id,title");
+                        expect(htmlTag.getAttribute("title")).to.equal(
+                            "html tag"
+                        );
+                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                            "lang,id,title"
+                        );
 
                         done();
                     });
                 });
             });
 
-            it("updates with multiple additions and removals - all new", (done) => {
+            it("updates with multiple additions and removals - all new", done => {
                 ReactDOM.render(
                     <Helmet
                         htmlAttributes={{
-                            "lang": "en",
-                            "amp": undefined
+                            lang: "en",
+                            amp: undefined
                         }}
                     />,
                     container
@@ -484,20 +527,26 @@ describe("Helmet", () => {
                     ReactDOM.render(
                         <Helmet
                             htmlAttributes={{
-                                "id": "html-tag",
-                                "title": "html tag"
+                                id: "html-tag",
+                                title: "html tag"
                             }}
                         />,
                         container
                     );
 
                     requestIdleCallback(() => {
-                        const htmlTag = document.getElementsByTagName("html")[0];
+                        const htmlTag = document.getElementsByTagName(
+                            "html"
+                        )[0];
                         expect(htmlTag.getAttribute("amp")).to.equal(null);
                         expect(htmlTag.getAttribute("lang")).to.equal(null);
                         expect(htmlTag.getAttribute("id")).to.equal("html-tag");
-                        expect(htmlTag.getAttribute("title")).to.equal("html tag");
-                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("id,title");
+                        expect(htmlTag.getAttribute("title")).to.equal(
+                            "html tag"
+                        );
+                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                            "id,title"
+                        );
 
                         done();
                     });
@@ -510,60 +559,68 @@ describe("Helmet", () => {
                     htmlTag.setAttribute("test", "test");
                 });
 
-                it("attributes are not cleared", (done) => {
-                    ReactDOM.render(
-                        <Helmet />,
-                        container
-                    );
+                it("attributes are not cleared", done => {
+                    ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
-                        const htmlTag = document.getElementsByTagName("html")[0];
+                        const htmlTag = document.getElementsByTagName(
+                            "html"
+                        )[0];
                         expect(htmlTag.getAttribute("test")).to.equal("test");
-                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(null);
+                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                            null
+                        );
 
                         done();
                     });
                 });
 
-                it("attributes are overwritten if specified in helmet", (done) => {
+                it("attributes are overwritten if specified in helmet", done => {
                     ReactDOM.render(
                         <Helmet
                             htmlAttributes={{
-                                "test": "helmet-attr"
+                                test: "helmet-attr"
                             }}
                         />,
                         container
                     );
 
                     requestIdleCallback(() => {
-                        const htmlTag = document.getElementsByTagName("html")[0];
-                        expect(htmlTag.getAttribute("test")).to.equal("helmet-attr");
-                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal("test");
+                        const htmlTag = document.getElementsByTagName(
+                            "html"
+                        )[0];
+                        expect(htmlTag.getAttribute("test")).to.equal(
+                            "helmet-attr"
+                        );
+                        expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(
+                            "test"
+                        );
 
                         done();
                     });
                 });
 
-                it("attributes are cleared once managed in helmet", (done) => {
+                it("attributes are cleared once managed in helmet", done => {
                     ReactDOM.render(
                         <Helmet
                             htmlAttributes={{
-                                "test": "helmet-attr"
+                                test: "helmet-attr"
                             }}
                         />,
                         container
                     );
 
                     requestIdleCallback(() => {
-                        ReactDOM.render(
-                            <Helmet />,
-                            container
-                        );
+                        ReactDOM.render(<Helmet />, container);
 
                         requestIdleCallback(() => {
-                            const htmlTag = document.getElementsByTagName("html")[0];
+                            const htmlTag = document.getElementsByTagName(
+                                "html"
+                            )[0];
                             expect(htmlTag.getAttribute("test")).to.equal(null);
-                            expect(htmlTag.getAttribute(HELMET_ATTRIBUTE)).to.equal(null);
+                            expect(
+                                htmlTag.getAttribute(HELMET_ATTRIBUTE)
+                            ).to.equal(null);
 
                             done();
                         });
@@ -573,15 +630,25 @@ describe("Helmet", () => {
         });
 
         describe("onChangeClientState", () => {
-            it("when handling client state change, calls the function with new state, addedTags and removedTags ", (done) => {
+            it("when handling client state change, calls the function with new state, addedTags and removedTags ", done => {
                 const spy = sinon.spy();
                 ReactDOM.render(
                     <div>
                         <Helmet
-                            base={{"href": "http://mysite.com/"}}
-                            link={[{"href": "http://localhost/helmet", "rel": "canonical"}]}
-                            meta={[{"charset": "utf-8"}]}
-                            script={[{"src": "http://localhost/test.js", "type": "text/javascript"}]}
+                            base={{href: "http://mysite.com/"}}
+                            link={[
+                                {
+                                    href: "http://localhost/helmet",
+                                    rel: "canonical"
+                                }
+                            ]}
+                            meta={[{charset: "utf-8"}]}
+                            script={[
+                                {
+                                    src: "http://localhost/test.js",
+                                    type: "text/javascript"
+                                }
+                            ]}
                             title={"Main Title"}
                             onChangeClientState={spy}
                         />
@@ -596,26 +663,42 @@ describe("Helmet", () => {
                     const removedTags = spy.getCall(0).args[2];
 
                     expect(newState).to.contain({title: "Main Title"});
-                    expect(newState.baseTag).to.contain({href: "http://mysite.com/"});
-                    expect(newState.metaTags).to.contain({"charset": "utf-8"});
-                    expect(newState.linkTags).to.contain({"href": "http://localhost/helmet", "rel": "canonical"});
-                    expect(newState.scriptTags).to.contain({"src": "http://localhost/test.js", "type": "text/javascript"});
+                    expect(newState.baseTag).to.contain({
+                        href: "http://mysite.com/"
+                    });
+                    expect(newState.metaTags).to.contain({charset: "utf-8"});
+                    expect(newState.linkTags).to.contain({
+                        href: "http://localhost/helmet",
+                        rel: "canonical"
+                    });
+                    expect(newState.scriptTags).to.contain({
+                        src: "http://localhost/test.js",
+                        type: "text/javascript"
+                    });
 
                     expect(addedTags).to.have.property("baseTag");
                     expect(addedTags.baseTag).to.have.deep.property("[0]");
-                    expect(addedTags.baseTag[0].outerHTML).to.equal(`<base href="http://mysite.com/" data-react-helmet="true">`);
+                    expect(addedTags.baseTag[0].outerHTML).to.equal(
+                        `<base href="http://mysite.com/" data-react-helmet="true">`
+                    );
 
                     expect(addedTags).to.have.property("metaTags");
                     expect(addedTags.metaTags).to.have.deep.property("[0]");
-                    expect(addedTags.metaTags[0].outerHTML).to.equal(`<meta charset="utf-8" data-react-helmet="true">`);
+                    expect(addedTags.metaTags[0].outerHTML).to.equal(
+                        `<meta charset="utf-8" data-react-helmet="true">`
+                    );
 
                     expect(addedTags).to.have.property("linkTags");
                     expect(addedTags.linkTags).to.have.deep.property("[0]");
-                    expect(addedTags.linkTags[0].outerHTML).to.equal(`<link href="http://localhost/helmet" rel="canonical" data-react-helmet="true">`);
+                    expect(addedTags.linkTags[0].outerHTML).to.equal(
+                        `<link href="http://localhost/helmet" rel="canonical" data-react-helmet="true">`
+                    );
 
                     expect(addedTags).to.have.property("scriptTags");
                     expect(addedTags.scriptTags).to.have.deep.property("[0]");
-                    expect(addedTags.scriptTags[0].outerHTML).to.equal(`<script src="http://localhost/test.js" type="text/javascript" data-react-helmet="true"></script>`);
+                    expect(addedTags.scriptTags[0].outerHTML).to.equal(
+                        `<script src="http://localhost/test.js" type="text/javascript" data-react-helmet="true"></script>`
+                    );
 
                     expect(removedTags).to.be.empty;
 
@@ -623,11 +706,14 @@ describe("Helmet", () => {
                 });
             });
 
-            it("calls the deepest defined callback with the deepest state", (done) => {
+            it("calls the deepest defined callback with the deepest state", done => {
                 const spy = sinon.spy();
                 ReactDOM.render(
                     <div>
-                        <Helmet title={"Main Title"} onChangeClientState={spy} />
+                        <Helmet
+                            title={"Main Title"}
+                            onChangeClientState={spy}
+                        />
                         <Helmet title={"Deeper Title"} />
                     </div>,
                     container
@@ -635,7 +721,9 @@ describe("Helmet", () => {
 
                 requestIdleCallback(() => {
                     expect(spy.callCount).to.equal(1);
-                    expect(spy.getCall(0).args[0]).to.contain({title: "Deeper Title"});
+                    expect(spy.getCall(0).args[0]).to.contain({
+                        title: "Deeper Title"
+                    });
 
                     done();
                 });
@@ -643,22 +731,27 @@ describe("Helmet", () => {
         });
 
         describe("base tag", () => {
-            it("updates base tag", (done) => {
+            it("updates base tag", done => {
                 ReactDOM.render(
-                    <Helmet
-                        base={{"href": "http://mysite.com/"}}
-                    />,
+                    <Helmet base={{href: "http://mysite.com/"}} />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const existingTags = headElement.querySelectorAll(`base[${HELMET_ATTRIBUTE}]`);
+                    const existingTags = headElement.querySelectorAll(
+                        `base[${HELMET_ATTRIBUTE}]`
+                    );
 
                     expect(existingTags).to.not.equal(undefined);
 
-                    const filteredTags = [].slice.call(existingTags).filter((tag) => {
-                        return tag.getAttribute("href") === "http://mysite.com/";
-                    });
+                    const filteredTags = [].slice
+                        .call(existingTags)
+                        .filter(tag => {
+                            return (
+                                tag.getAttribute("href") ===
+                                "http://mysite.com/"
+                            );
+                        });
 
                     expect(filteredTags.length).to.equal(1);
 
@@ -666,22 +759,19 @@ describe("Helmet", () => {
                 });
             });
 
-            it("clears the base tag if one is not specified", (done) => {
+            it("clears the base tag if one is not specified", done => {
                 ReactDOM.render(
-                    <Helmet
-                        base={{"href": "http://mysite.com/"}}
-                    />,
+                    <Helmet base={{href: "http://mysite.com/"}} />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    ReactDOM.render(
-                        <Helmet />,
-                        container
-                    );
+                    ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
-                        const existingTags = headElement.querySelectorAll(`base[${HELMET_ATTRIBUTE}]`);
+                        const existingTags = headElement.querySelectorAll(
+                            `base[${HELMET_ATTRIBUTE}]`
+                        );
 
                         expect(existingTags).to.not.equal(undefined);
                         expect(existingTags.length).to.equal(0);
@@ -691,16 +781,16 @@ describe("Helmet", () => {
                 });
             });
 
-            it("tags without 'href' are not accepted", (done) => {
+            it("tags without 'href' are not accepted", done => {
                 ReactDOM.render(
-                    <Helmet
-                        base={{"property": "won't work"}}
-                    />,
+                    <Helmet base={{property: "won't work"}} />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const existingTags = headElement.querySelectorAll(`base[${HELMET_ATTRIBUTE}]`);
+                    const existingTags = headElement.querySelectorAll(
+                        `base[${HELMET_ATTRIBUTE}]`
+                    );
 
                     expect(existingTags).to.not.equal(undefined);
                     expect(existingTags.length).to.equal(0);
@@ -709,48 +799,49 @@ describe("Helmet", () => {
                 });
             });
 
-            it("sets base tag based on deepest nested component", (done) => {
+            it("sets base tag based on deepest nested component", done => {
                 ReactDOM.render(
                     <div>
-                        <Helmet
-                            base={{"href": "http://mysite.com/"}}
-                        />
-                        <Helmet
-                            base={{"href": "http://mysite.com/public"}}
-                        />
+                        <Helmet base={{href: "http://mysite.com/"}} />
+                        <Helmet base={{href: "http://mysite.com/public"}} />
                     </div>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const existingTags = headElement.querySelectorAll(`base[${HELMET_ATTRIBUTE}]`);
-                    const firstTag = Array.prototype.slice.call(existingTags)[0];
+                    const existingTags = headElement.querySelectorAll(
+                        `base[${HELMET_ATTRIBUTE}]`
+                    );
+                    const firstTag = Array.prototype.slice.call(
+                        existingTags
+                    )[0];
 
                     expect(existingTags).to.not.equal(undefined);
 
                     expect(existingTags.length).to.be.equal(1);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
-                    expect(firstTag.getAttribute("href")).to.equal("http://mysite.com/public");
-                    expect(firstTag.outerHTML).to.equal(`<base href="http://mysite.com/public" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.getAttribute("href")).to.equal(
+                        "http://mysite.com/public"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<base href="http://mysite.com/public" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("does not render tag when primary attribute is null", (done) => {
-                ReactDOM.render(
-                    <Helmet
-                        base={{"href": undefined}}
-                    />,
-                    container
-                );
+            it("does not render tag when primary attribute is null", done => {
+                ReactDOM.render(<Helmet base={{href: undefined}} />, container);
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`base[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `base[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     expect(existingTags).to.be.empty;
 
@@ -760,32 +851,48 @@ describe("Helmet", () => {
         });
 
         describe("meta tags", () => {
-            it("updates meta tags", (done) => {
+            it("updates meta tags", done => {
                 ReactDOM.render(
                     <Helmet
                         meta={[
-                            {"charset": "utf-8"},
-                            {"name": "description", "content": "Test description"},
-                            {"http-equiv": "content-type", "content": "text/html"},
-                            {"property": "og:type", "content": "article"},
-                            {"itemprop": "name", "content": "Test name itemprop"}
+                            {charset: "utf-8"},
+                            {name: "description", content: "Test description"},
+                            {
+                                "http-equiv": "content-type",
+                                content: "text/html"
+                            },
+                            {property: "og:type", content: "article"},
+                            {itemprop: "name", content: "Test name itemprop"}
                         ]}
                     />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `meta[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
 
                     expect(existingTags).to.not.equal(undefined);
 
-                    const filteredTags = [].slice.call(existingTags).filter((tag) => {
-                        return tag.getAttribute("charset") === "utf-8" ||
-                            (tag.getAttribute("name") === "description" && tag.getAttribute("content") === "Test description") ||
-                            (tag.getAttribute("http-equiv") === "content-type" && tag.getAttribute("content") === "text/html") ||
-                            (tag.getAttribute("itemprop") === "name" && tag.getAttribute("content") === "Test name itemprop");
-                    });
+                    const filteredTags = [].slice
+                        .call(existingTags)
+                        .filter(tag => {
+                            return (
+                                tag.getAttribute("charset") === "utf-8" ||
+                                (tag.getAttribute("name") === "description" &&
+                                    tag.getAttribute("content") ===
+                                        "Test description") ||
+                                (tag.getAttribute("http-equiv") ===
+                                    "content-type" &&
+                                    tag.getAttribute("content") ===
+                                        "text/html") ||
+                                (tag.getAttribute("itemprop") === "name" &&
+                                    tag.getAttribute("content") ===
+                                        "Test name itemprop")
+                            );
+                        });
 
                     expect(filteredTags.length).to.be.at.least(4);
 
@@ -793,22 +900,23 @@ describe("Helmet", () => {
                 });
             });
 
-            it("clears all meta tags if none are specified", (done) => {
+            it("clears all meta tags if none are specified", done => {
                 ReactDOM.render(
                     <Helmet
-                        meta={[{"name": "description", "content": "Test description"}]}
+                        meta={[
+                            {name: "description", content: "Test description"}
+                        ]}
                     />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    ReactDOM.render(
-                        <Helmet />,
-                        container
-                    );
+                    ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
-                        const existingTags = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                        const existingTags = headElement.querySelectorAll(
+                            `meta[${HELMET_ATTRIBUTE}]`
+                        );
 
                         expect(existingTags).to.not.equal(undefined);
                         expect(existingTags.length).to.equal(0);
@@ -818,16 +926,16 @@ describe("Helmet", () => {
                 });
             });
 
-            it("tags without 'name', 'http-equiv', 'property', 'charset', or 'itemprop' are not accepted", (done) => {
+            it("tags without 'name', 'http-equiv', 'property', 'charset', or 'itemprop' are not accepted", done => {
                 ReactDOM.render(
-                    <Helmet
-                        meta={[{"href": "won't work"}]}
-                    />,
+                    <Helmet meta={[{href: "won't work"}]} />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const existingTags = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                    const existingTags = headElement.querySelectorAll(
+                        `meta[${HELMET_ATTRIBUTE}]`
+                    );
 
                     expect(existingTags).to.not.equal(undefined);
                     expect(existingTags.length).to.equal(0);
@@ -836,19 +944,25 @@ describe("Helmet", () => {
                 });
             });
 
-            it("sets meta tags based on deepest nested component", (done) => {
+            it("sets meta tags based on deepest nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet
                             meta={[
-                                {"charset": "utf-8"},
-                                {"name": "description", "content": "Test description"}
+                                {charset: "utf-8"},
+                                {
+                                    name: "description",
+                                    content: "Test description"
+                                }
                             ]}
                         />
                         <Helmet
                             meta={[
-                                {"name": "description", "content": "Inner description"},
-                                {"name": "keywords", "content": "test,meta,tags"}
+                                {
+                                    name: "description",
+                                    content: "Inner description"
+                                },
+                                {name: "keywords", content: "test,meta,tags"}
                             ]}
                         />
                     </div>,
@@ -856,7 +970,9 @@ describe("Helmet", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `meta[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
 
                     const firstTag = existingTags[0];
@@ -867,46 +983,63 @@ describe("Helmet", () => {
 
                     expect(existingTags.length).to.be.equal(3);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
                     expect(firstTag.getAttribute("charset")).to.equal("utf-8");
-                    expect(firstTag.outerHTML).to.equal(`<meta charset="utf-8" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.outerHTML).to.equal(
+                        `<meta charset="utf-8" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[1]")
+                    expect(existingTags).to.have.deep
+                        .property("[1]")
                         .that.is.an.instanceof(Element);
                     expect(secondTag).to.have.property("getAttribute");
-                    expect(secondTag.getAttribute("name")).to.equal("description");
-                    expect(secondTag.getAttribute("content")).to.equal("Inner description");
-                    expect(secondTag.outerHTML).to.equal(`<meta name="description" content="Inner description" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(secondTag.getAttribute("name")).to.equal(
+                        "description"
+                    );
+                    expect(secondTag.getAttribute("content")).to.equal(
+                        "Inner description"
+                    );
+                    expect(secondTag.outerHTML).to.equal(
+                        `<meta name="description" content="Inner description" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[2]")
+                    expect(existingTags).to.have.deep
+                        .property("[2]")
                         .that.is.an.instanceof(Element);
                     expect(thirdTag).to.have.property("getAttribute");
                     expect(thirdTag.getAttribute("name")).to.equal("keywords");
-                    expect(thirdTag.getAttribute("content")).to.equal("test,meta,tags");
-                    expect(thirdTag.outerHTML).to.equal(`<meta name="keywords" content="test,meta,tags" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(thirdTag.getAttribute("content")).to.equal(
+                        "test,meta,tags"
+                    );
+                    expect(thirdTag.outerHTML).to.equal(
+                        `<meta name="keywords" content="test,meta,tags" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("allows duplicate meta tags if specified in the same component", (done) => {
+            it("allows duplicate meta tags if specified in the same component", done => {
                 ReactDOM.render(
                     <Helmet
                         meta={[
-                            {"name": "description", "content": "Test description"},
-                            {"name": "description", "content": "Duplicate description"}
+                            {name: "description", content: "Test description"},
+                            {
+                                name: "description",
+                                content: "Duplicate description"
+                            }
                         ]}
                     />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `meta[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
                     const secondTag = existingTags[1];
@@ -915,38 +1048,59 @@ describe("Helmet", () => {
 
                     expect(existingTags.length).to.equal(2);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
-                    expect(firstTag.getAttribute("name")).to.equal("description");
-                    expect(firstTag.getAttribute("content")).to.equal("Test description");
-                    expect(firstTag.outerHTML).to.equal(`<meta name="description" content="Test description" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.getAttribute("name")).to.equal(
+                        "description"
+                    );
+                    expect(firstTag.getAttribute("content")).to.equal(
+                        "Test description"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<meta name="description" content="Test description" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[1]")
+                    expect(existingTags).to.have.deep
+                        .property("[1]")
                         .that.is.an.instanceof(Element);
                     expect(secondTag).to.have.property("getAttribute");
-                    expect(secondTag.getAttribute("name")).to.equal("description");
-                    expect(secondTag.getAttribute("content")).to.equal("Duplicate description");
-                    expect(secondTag.outerHTML).to.equal(`<meta name="description" content="Duplicate description" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(secondTag.getAttribute("name")).to.equal(
+                        "description"
+                    );
+                    expect(secondTag.getAttribute("content")).to.equal(
+                        "Duplicate description"
+                    );
+                    expect(secondTag.outerHTML).to.equal(
+                        `<meta name="description" content="Duplicate description" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("overrides duplicate meta tags with single meta tag in a nested component", (done) => {
+            it("overrides duplicate meta tags with single meta tag in a nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet
                             meta={[
-                                {"name": "description", "content": "Test description"},
-                                {"name": "description", "content": "Duplicate description"}
+                                {
+                                    name: "description",
+                                    content: "Test description"
+                                },
+                                {
+                                    name: "description",
+                                    content: "Duplicate description"
+                                }
                             ]}
                         />
                         <Helmet
                             meta={[
-                                {"name": "description", "content": "Inner description"}
+                                {
+                                    name: "description",
+                                    content: "Inner description"
+                                }
                             ]}
                         />
                     </div>,
@@ -954,7 +1108,9 @@ describe("Helmet", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `meta[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
 
@@ -962,30 +1118,45 @@ describe("Helmet", () => {
 
                     expect(existingTags.length).to.equal(1);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
-                    expect(firstTag.getAttribute("name")).to.equal("description");
-                    expect(firstTag.getAttribute("content")).to.equal("Inner description");
-                    expect(firstTag.outerHTML).to.equal(`<meta name="description" content="Inner description" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.getAttribute("name")).to.equal(
+                        "description"
+                    );
+                    expect(firstTag.getAttribute("content")).to.equal(
+                        "Inner description"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<meta name="description" content="Inner description" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("overrides single meta tag with duplicate meta tags in a nested component", (done) => {
+            it("overrides single meta tag with duplicate meta tags in a nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet
                             meta={[
-                                {"name": "description", "content": "Test description"}
+                                {
+                                    name: "description",
+                                    content: "Test description"
+                                }
                             ]}
                         />
                         <Helmet
                             meta={[
-                                {"name": "description", "content": "Inner description"},
-                                {"name": "description", "content": "Inner duplicate description"}
+                                {
+                                    name: "description",
+                                    content: "Inner description"
+                                },
+                                {
+                                    name: "description",
+                                    content: "Inner duplicate description"
+                                }
                             ]}
                         />
                     </div>,
@@ -993,7 +1164,9 @@ describe("Helmet", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `meta[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
                     const secondTag = existingTags[1];
@@ -1002,38 +1175,55 @@ describe("Helmet", () => {
 
                     expect(existingTags.length).to.equal(2);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
-                    expect(firstTag.getAttribute("name")).to.equal("description");
-                    expect(firstTag.getAttribute("content")).to.equal("Inner description");
-                    expect(firstTag.outerHTML).to.equal(`<meta name="description" content="Inner description" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.getAttribute("name")).to.equal(
+                        "description"
+                    );
+                    expect(firstTag.getAttribute("content")).to.equal(
+                        "Inner description"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<meta name="description" content="Inner description" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[1]")
+                    expect(existingTags).to.have.deep
+                        .property("[1]")
                         .that.is.an.instanceof(Element);
                     expect(secondTag).to.have.property("getAttribute");
-                    expect(secondTag.getAttribute("name")).to.equal("description");
-                    expect(secondTag.getAttribute("content")).to.equal("Inner duplicate description");
-                    expect(secondTag.outerHTML).to.equal(`<meta name="description" content="Inner duplicate description" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(secondTag.getAttribute("name")).to.equal(
+                        "description"
+                    );
+                    expect(secondTag.getAttribute("content")).to.equal(
+                        "Inner duplicate description"
+                    );
+                    expect(secondTag.outerHTML).to.equal(
+                        `<meta name="description" content="Inner duplicate description" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("does not render tag when primary attribute is null", (done) => {
+            it("does not render tag when primary attribute is null", done => {
                 ReactDOM.render(
                     <Helmet
                         meta={[
-                            {"name": undefined, "content": "Inner duplicate description"}
+                            {
+                                name: undefined,
+                                content: "Inner duplicate description"
+                            }
                         ]}
                     />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `meta[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     expect(existingTags).to.be.empty;
 
@@ -1041,19 +1231,19 @@ describe("Helmet", () => {
                 });
             });
 
-            it("fails gracefully when meta is wrong shape", (done) => {
+            it("fails gracefully when meta is wrong shape", done => {
                 const error = sinon.stub(console, "error");
                 const warn = sinon.stub(console, "warn");
 
                 ReactDOM.render(
-                    <Helmet
-                        meta={{"name": "title", "content": "some title"}}
-                    />,
+                    <Helmet meta={{name: "title", content: "some title"}} />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `meta[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     expect(existingTags).to.be.empty;
 
@@ -1061,7 +1251,9 @@ describe("Helmet", () => {
                     expect(warn.called).to.be.true;
 
                     const [warning] = warn.getCall(0).args;
-                    expect(warning).to.equal(`Helmet: meta should be of type "Array". Instead found type "object"`);
+                    expect(warning).to.equal(
+                        `Helmet: meta should be of type "Array". Instead found type "object"`
+                    );
 
                     error.restore();
                     warn.restore();
@@ -1072,27 +1264,42 @@ describe("Helmet", () => {
         });
 
         describe("link tags", () => {
-            it("updates link tags", (done) => {
+            it("updates link tags", done => {
                 ReactDOM.render(
                     <Helmet
                         link={[
-                            {"href": "http://localhost/helmet", "rel": "canonical"},
-                            {"href": "http://localhost/style.css", "rel": "stylesheet", "type": "text/css"}
+                            {href: "http://localhost/helmet", rel: "canonical"},
+                            {
+                                href: "http://localhost/style.css",
+                                rel: "stylesheet",
+                                type: "text/css"
+                            }
                         ]}
                     />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `link[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
 
                     expect(existingTags).to.not.equal(undefined);
 
-                    const filteredTags = [].slice.call(existingTags).filter((tag) => {
-                        return (tag.getAttribute("href") === "http://localhost/style.css" && tag.getAttribute("rel") === "stylesheet" && tag.getAttribute("type") === "text/css") ||
-                            (tag.getAttribute("href") === "http://localhost/helmet" && tag.getAttribute("rel") === "canonical");
-                    });
+                    const filteredTags = [].slice
+                        .call(existingTags)
+                        .filter(tag => {
+                            return (
+                                (tag.getAttribute("href") ===
+                                    "http://localhost/style.css" &&
+                                    tag.getAttribute("rel") === "stylesheet" &&
+                                    tag.getAttribute("type") === "text/css") ||
+                                (tag.getAttribute("href") ===
+                                    "http://localhost/helmet" &&
+                                    tag.getAttribute("rel") === "canonical")
+                            );
+                        });
 
                     expect(filteredTags.length).to.be.at.least(2);
 
@@ -1100,25 +1307,26 @@ describe("Helmet", () => {
                 });
             });
 
-            it("clears all link tags if none are specified", (done) => {
+            it("clears all link tags if none are specified", done => {
                 ReactDOM.render(
                     <Helmet
                         link={[
-                            {"href": "http://localhost/helmet", "rel": "canonical"}
+                            {href: "http://localhost/helmet", rel: "canonical"}
                         ]}
                     />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    ReactDOM.render(
-                        <Helmet />,
-                        container
-                    );
+                    ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
-                        const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
-                        const existingTags = Array.prototype.slice.call(tagNodes);
+                        const tagNodes = headElement.querySelectorAll(
+                            `link[${HELMET_ATTRIBUTE}]`
+                        );
+                        const existingTags = Array.prototype.slice.call(
+                            tagNodes
+                        );
 
                         expect(existingTags).to.not.equal(undefined);
                         expect(existingTags.length).to.equal(0);
@@ -1128,16 +1336,16 @@ describe("Helmet", () => {
                 });
             });
 
-            it("tags without 'href' or 'rel' are not accepted, even if they are valid for other tags", (done) => {
+            it("tags without 'href' or 'rel' are not accepted, even if they are valid for other tags", done => {
                 ReactDOM.render(
-                    <Helmet
-                        link={[{"http-equiv": "won't work"}]}
-                    />,
+                    <Helmet link={[{"http-equiv": "won't work"}]} />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `link[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
 
                     expect(existingTags).to.not.equal(undefined);
@@ -1147,24 +1355,41 @@ describe("Helmet", () => {
                 });
             });
 
-            it("tags 'rel' and 'href' properly use 'rel' as the primary identification for this tag, regardless of ordering", (done) => {
+            it("tags 'rel' and 'href' properly use 'rel' as the primary identification for this tag, regardless of ordering", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet
-                            link={[{"href": "http://localhost/helmet", "rel": "canonical"}]}
+                            link={[
+                                {
+                                    href: "http://localhost/helmet",
+                                    rel: "canonical"
+                                }
+                            ]}
                         />
                         <Helmet
-                            link={[{"rel": "canonical", "href": "http://localhost/helmet/new"}]}
+                            link={[
+                                {
+                                    rel: "canonical",
+                                    href: "http://localhost/helmet/new"
+                                }
+                            ]}
                         />
                         <Helmet
-                            link={[{"href": "http://localhost/helmet/newest", "rel": "canonical"}]}
+                            link={[
+                                {
+                                    href: "http://localhost/helmet/newest",
+                                    rel: "canonical"
+                                }
+                            ]}
                         />
                     </div>,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `link[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
 
@@ -1172,29 +1397,43 @@ describe("Helmet", () => {
 
                     expect(existingTags.length).to.equal(1);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
                     expect(firstTag.getAttribute("rel")).to.equal("canonical");
-                    expect(firstTag.getAttribute("href")).to.equal("http://localhost/helmet/newest");
-                    expect(firstTag.outerHTML).to.equal(`<link href="http://localhost/helmet/newest" rel="canonical" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.getAttribute("href")).to.equal(
+                        "http://localhost/helmet/newest"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<link href="http://localhost/helmet/newest" rel="canonical" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("tags with rel='stylesheet' uses the href as the primary identification of the tag, regardless of ordering", (done) => {
+            it("tags with rel='stylesheet' uses the href as the primary identification of the tag, regardless of ordering", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet
                             link={[
-                                {"href": "http://localhost/style.css", "rel": "stylesheet", "type": "text/css", "media": "all"}
+                                {
+                                    href: "http://localhost/style.css",
+                                    rel: "stylesheet",
+                                    type: "text/css",
+                                    media: "all"
+                                }
                             ]}
                         />
                         <Helmet
                             link={[
-                                {"rel": "stylesheet", "href": "http://localhost/inner.css", "type": "text/css", "media": "all"}
+                                {
+                                    rel: "stylesheet",
+                                    href: "http://localhost/inner.css",
+                                    type: "text/css",
+                                    media: "all"
+                                }
                             ]}
                         />
                     </div>,
@@ -1202,7 +1441,9 @@ describe("Helmet", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `link[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
                     const secondTag = existingTags[1];
@@ -1211,43 +1452,70 @@ describe("Helmet", () => {
 
                     expect(existingTags.length).to.equal(2);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
-                    expect(firstTag.getAttribute("href")).to.equal("http://localhost/style.css");
+                    expect(firstTag.getAttribute("href")).to.equal(
+                        "http://localhost/style.css"
+                    );
                     expect(firstTag.getAttribute("rel")).to.equal("stylesheet");
                     expect(firstTag.getAttribute("type")).to.equal("text/css");
                     expect(firstTag.getAttribute("media")).to.equal("all");
-                    expect(firstTag.outerHTML).to.equal(`<link href="http://localhost/style.css" rel="stylesheet" type="text/css" media="all" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.outerHTML).to.equal(
+                        `<link href="http://localhost/style.css" rel="stylesheet" type="text/css" media="all" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[1]")
+                    expect(existingTags).to.have.deep
+                        .property("[1]")
                         .that.is.an.instanceof(Element);
                     expect(secondTag).to.have.property("getAttribute");
-                    expect(secondTag.getAttribute("rel")).to.equal("stylesheet");
-                    expect(secondTag.getAttribute("href")).to.equal("http://localhost/inner.css");
+                    expect(secondTag.getAttribute("rel")).to.equal(
+                        "stylesheet"
+                    );
+                    expect(secondTag.getAttribute("href")).to.equal(
+                        "http://localhost/inner.css"
+                    );
                     expect(secondTag.getAttribute("type")).to.equal("text/css");
                     expect(secondTag.getAttribute("media")).to.equal("all");
-                    expect(secondTag.outerHTML).to.equal(`<link rel="stylesheet" href="http://localhost/inner.css" type="text/css" media="all" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(secondTag.outerHTML).to.equal(
+                        `<link rel="stylesheet" href="http://localhost/inner.css" type="text/css" media="all" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("sets link tags based on deepest nested component", (done) => {
+            it("sets link tags based on deepest nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet
                             link={[
-                                {"rel": "canonical", "href": "http://localhost/helmet"},
-                                {"href": "http://localhost/style.css", "rel": "stylesheet", "type": "text/css", "media": "all"}
+                                {
+                                    rel: "canonical",
+                                    href: "http://localhost/helmet"
+                                },
+                                {
+                                    href: "http://localhost/style.css",
+                                    rel: "stylesheet",
+                                    type: "text/css",
+                                    media: "all"
+                                }
                             ]}
                         />
                         <Helmet
                             link={[
-                                {"rel": "canonical", "href": "http://localhost/helmet/innercomponent"},
-                                {"href": "http://localhost/inner.css", "rel": "stylesheet", "type": "text/css", "media": "all"}
+                                {
+                                    rel: "canonical",
+                                    href:
+                                        "http://localhost/helmet/innercomponent"
+                                },
+                                {
+                                    href: "http://localhost/inner.css",
+                                    rel: "stylesheet",
+                                    type: "text/css",
+                                    media: "all"
+                                }
                             ]}
                         />
                     </div>,
@@ -1255,7 +1523,9 @@ describe("Helmet", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `link[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
                     const secondTag = existingTags[1];
@@ -1265,51 +1535,68 @@ describe("Helmet", () => {
 
                     expect(existingTags.length).to.be.at.least(2);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
-                    expect(firstTag.getAttribute("href")).to.equal("http://localhost/style.css");
+                    expect(firstTag.getAttribute("href")).to.equal(
+                        "http://localhost/style.css"
+                    );
                     expect(firstTag.getAttribute("rel")).to.equal("stylesheet");
                     expect(firstTag.getAttribute("type")).to.equal("text/css");
                     expect(firstTag.getAttribute("media")).to.equal("all");
-                    expect(firstTag.outerHTML).to.equal(`<link href="http://localhost/style.css" rel="stylesheet" type="text/css" media="all" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.outerHTML).to.equal(
+                        `<link href="http://localhost/style.css" rel="stylesheet" type="text/css" media="all" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[1]")
+                    expect(existingTags).to.have.deep
+                        .property("[1]")
                         .that.is.an.instanceof(Element);
                     expect(secondTag).to.have.property("getAttribute");
-                    expect(secondTag.getAttribute("href")).to.equal("http://localhost/helmet/innercomponent");
+                    expect(secondTag.getAttribute("href")).to.equal(
+                        "http://localhost/helmet/innercomponent"
+                    );
                     expect(secondTag.getAttribute("rel")).to.equal("canonical");
-                    expect(secondTag.outerHTML).to.equal(`<link rel="canonical" href="http://localhost/helmet/innercomponent" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(secondTag.outerHTML).to.equal(
+                        `<link rel="canonical" href="http://localhost/helmet/innercomponent" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[2]")
+                    expect(existingTags).to.have.deep
+                        .property("[2]")
                         .that.is.an.instanceof(Element);
                     expect(thirdTag).to.have.property("getAttribute");
-                    expect(thirdTag.getAttribute("href")).to.equal("http://localhost/inner.css");
+                    expect(thirdTag.getAttribute("href")).to.equal(
+                        "http://localhost/inner.css"
+                    );
                     expect(thirdTag.getAttribute("rel")).to.equal("stylesheet");
                     expect(thirdTag.getAttribute("type")).to.equal("text/css");
                     expect(thirdTag.getAttribute("media")).to.equal("all");
-                    expect(thirdTag.outerHTML).to.equal(`<link href="http://localhost/inner.css" rel="stylesheet" type="text/css" media="all" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(thirdTag.outerHTML).to.equal(
+                        `<link href="http://localhost/inner.css" rel="stylesheet" type="text/css" media="all" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("allows duplicate link tags if specified in the same component", (done) => {
+            it("allows duplicate link tags if specified in the same component", done => {
                 ReactDOM.render(
                     <Helmet
                         link={[
-                            {"rel": "canonical", "href": "http://localhost/helmet"},
-                            {"rel": "canonical", "href": "http://localhost/helmet/component"}
+                            {rel: "canonical", href: "http://localhost/helmet"},
+                            {
+                                rel: "canonical",
+                                href: "http://localhost/helmet/component"
+                            }
                         ]}
                     />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `link[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
                     const secondTag = existingTags[1];
@@ -1318,38 +1605,56 @@ describe("Helmet", () => {
 
                     expect(existingTags.length).to.be.at.least(2);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
                     expect(firstTag.getAttribute("rel")).to.equal("canonical");
-                    expect(firstTag.getAttribute("href")).to.equal("http://localhost/helmet");
-                    expect(firstTag.outerHTML).to.equal(`<link rel="canonical" href="http://localhost/helmet" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.getAttribute("href")).to.equal(
+                        "http://localhost/helmet"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<link rel="canonical" href="http://localhost/helmet" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[1]")
+                    expect(existingTags).to.have.deep
+                        .property("[1]")
                         .that.is.an.instanceof(Element);
                     expect(secondTag).to.have.property("getAttribute");
                     expect(secondTag.getAttribute("rel")).to.equal("canonical");
-                    expect(secondTag.getAttribute("href")).to.equal("http://localhost/helmet/component");
-                    expect(secondTag.outerHTML).to.equal(`<link rel="canonical" href="http://localhost/helmet/component" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(secondTag.getAttribute("href")).to.equal(
+                        "http://localhost/helmet/component"
+                    );
+                    expect(secondTag.outerHTML).to.equal(
+                        `<link rel="canonical" href="http://localhost/helmet/component" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("overrides duplicate link tags with a single link tag in a nested component", (done) => {
+            it("overrides duplicate link tags with a single link tag in a nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet
                             link={[
-                                {"rel": "canonical", "href": "http://localhost/helmet"},
-                                {"rel": "canonical", "href": "http://localhost/helmet/component"}
+                                {
+                                    rel: "canonical",
+                                    href: "http://localhost/helmet"
+                                },
+                                {
+                                    rel: "canonical",
+                                    href: "http://localhost/helmet/component"
+                                }
                             ]}
                         />
                         <Helmet
                             link={[
-                                {"rel": "canonical", "href": "http://localhost/helmet/innercomponent"}
+                                {
+                                    rel: "canonical",
+                                    href:
+                                        "http://localhost/helmet/innercomponent"
+                                }
                             ]}
                         />
                     </div>,
@@ -1357,7 +1662,9 @@ describe("Helmet", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `link[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
 
@@ -1365,30 +1672,44 @@ describe("Helmet", () => {
 
                     expect(existingTags.length).to.be.equal(1);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
                     expect(firstTag.getAttribute("rel")).to.equal("canonical");
-                    expect(firstTag.getAttribute("href")).to.equal("http://localhost/helmet/innercomponent");
-                    expect(firstTag.outerHTML).to.equal(`<link rel="canonical" href="http://localhost/helmet/innercomponent" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.getAttribute("href")).to.equal(
+                        "http://localhost/helmet/innercomponent"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<link rel="canonical" href="http://localhost/helmet/innercomponent" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("overrides single link tag with duplicate link tags in a nested component", (done) => {
+            it("overrides single link tag with duplicate link tags in a nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet
                             link={[
-                                {"rel": "canonical", "href": "http://localhost/helmet"}
+                                {
+                                    rel: "canonical",
+                                    href: "http://localhost/helmet"
+                                }
                             ]}
                         />
                         <Helmet
                             link={[
-                                {"rel": "canonical", "href": "http://localhost/helmet/component"},
-                                {"rel": "canonical", "href": "http://localhost/helmet/innercomponent"}
+                                {
+                                    rel: "canonical",
+                                    href: "http://localhost/helmet/component"
+                                },
+                                {
+                                    rel: "canonical",
+                                    href:
+                                        "http://localhost/helmet/innercomponent"
+                                }
                             ]}
                         />
                     </div>,
@@ -1396,7 +1717,9 @@ describe("Helmet", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `link[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
                     const secondTag = existingTags[1];
@@ -1405,52 +1728,69 @@ describe("Helmet", () => {
 
                     expect(existingTags.length).to.be.equal(2);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
                     expect(firstTag.getAttribute("rel")).to.equal("canonical");
-                    expect(firstTag.getAttribute("href")).to.equal("http://localhost/helmet/component");
-                    expect(firstTag.outerHTML).to.equal(`<link rel="canonical" href="http://localhost/helmet/component" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.getAttribute("href")).to.equal(
+                        "http://localhost/helmet/component"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<link rel="canonical" href="http://localhost/helmet/component" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[1]")
+                    expect(existingTags).to.have.deep
+                        .property("[1]")
                         .that.is.an.instanceof(Element);
                     expect(secondTag).to.have.property("getAttribute");
                     expect(secondTag.getAttribute("rel")).to.equal("canonical");
-                    expect(secondTag.getAttribute("href")).to.equal("http://localhost/helmet/innercomponent");
-                    expect(secondTag.outerHTML).to.equal(`<link rel="canonical" href="http://localhost/helmet/innercomponent" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(secondTag.getAttribute("href")).to.equal(
+                        "http://localhost/helmet/innercomponent"
+                    );
+                    expect(secondTag.outerHTML).to.equal(
+                        `<link rel="canonical" href="http://localhost/helmet/innercomponent" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
             });
 
-            it("does not render tag when primary attribute is null", (done) => {
+            it("does not render tag when primary attribute is null", done => {
                 ReactDOM.render(
                     <Helmet
                         link={[
-                            {"rel": "icon", "sizes": "192x192", "href": null},
-                            {"rel": "canonical", "href": "http://localhost/helmet/component"}
+                            {rel: "icon", sizes: "192x192", href: null},
+                            {
+                                rel: "canonical",
+                                href: "http://localhost/helmet/component"
+                            }
                         ]}
                     />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`link[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `link[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
 
                     expect(existingTags).to.not.equal(undefined);
                     expect(existingTags.length).to.be.equal(1);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
                     expect(firstTag.getAttribute("rel")).to.equal("canonical");
-                    expect(firstTag.getAttribute("href")).to.equal("http://localhost/helmet/component");
-                    expect(firstTag.outerHTML).to.equal(`<link rel="canonical" href="http://localhost/helmet/component" ${HELMET_ATTRIBUTE}="true">`);
+                    expect(firstTag.getAttribute("href")).to.equal(
+                        "http://localhost/helmet/component"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<link rel="canonical" href="http://localhost/helmet/component" ${HELMET_ATTRIBUTE}="true">`
+                    );
 
                     done();
                 });
@@ -1458,7 +1798,7 @@ describe("Helmet", () => {
         });
 
         describe("script tags", () => {
-            it("updates script tags", (done) => {
+            it("updates script tags", done => {
                 const scriptInnerHTML = `
                   {
                     "@context": "http://schema.org",
@@ -1469,8 +1809,14 @@ describe("Helmet", () => {
                 ReactDOM.render(
                     <Helmet
                         script={[
-                            {"src": "http://localhost/test.js", "type": "text/javascript"},
-                            {"src": "http://localhost/test2.js", "type": "text/javascript"},
+                            {
+                                src: "http://localhost/test.js",
+                                type: "text/javascript"
+                            },
+                            {
+                                src: "http://localhost/test2.js",
+                                type: "text/javascript"
+                            },
                             {
                                 type: "application/ld+json",
                                 innerHTML: scriptInnerHTML
@@ -1481,15 +1827,29 @@ describe("Helmet", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const existingTags = headElement.getElementsByTagName("script");
+                    const existingTags = headElement.getElementsByTagName(
+                        "script"
+                    );
 
                     expect(existingTags).to.not.equal(undefined);
 
-                    const filteredTags = [].slice.call(existingTags).filter((tag) => {
-                        return (tag.getAttribute("src") === "http://localhost/test.js" && tag.getAttribute("type") === "text/javascript") ||
-                            (tag.getAttribute("src") === "http://localhost/test2.js" && tag.getAttribute("type") === "text/javascript") ||
-                            (tag.getAttribute("type") === "application/ld+json" && tag.innerHTML === scriptInnerHTML);
-                    });
+                    const filteredTags = [].slice
+                        .call(existingTags)
+                        .filter(tag => {
+                            return (
+                                (tag.getAttribute("src") ===
+                                    "http://localhost/test.js" &&
+                                    tag.getAttribute("type") ===
+                                        "text/javascript") ||
+                                (tag.getAttribute("src") ===
+                                    "http://localhost/test2.js" &&
+                                    tag.getAttribute("type") ===
+                                        "text/javascript") ||
+                                (tag.getAttribute("type") ===
+                                    "application/ld+json" &&
+                                    tag.innerHTML === scriptInnerHTML)
+                            );
+                        });
 
                     expect(filteredTags.length).to.be.at.least(3);
 
@@ -1497,24 +1857,26 @@ describe("Helmet", () => {
                 });
             });
 
-            it("clears all scripts tags if none are specified", (done) => {
+            it("clears all scripts tags if none are specified", done => {
                 ReactDOM.render(
                     <Helmet
                         script={[
-                            {"src": "http://localhost/test.js", "type": "text/javascript"}
+                            {
+                                src: "http://localhost/test.js",
+                                type: "text/javascript"
+                            }
                         ]}
                     />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    ReactDOM.render(
-                        <Helmet />,
-                        container
-                    );
+                    ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
-                        const existingTags = headElement.querySelectorAll(`script[${HELMET_ATTRIBUTE}]`);
+                        const existingTags = headElement.querySelectorAll(
+                            `script[${HELMET_ATTRIBUTE}]`
+                        );
 
                         expect(existingTags).to.not.equal(undefined);
                         expect(existingTags.length).to.equal(0);
@@ -1524,16 +1886,16 @@ describe("Helmet", () => {
                 });
             });
 
-            it("tags without 'src' are not accepted", (done) => {
+            it("tags without 'src' are not accepted", done => {
                 ReactDOM.render(
-                    <Helmet
-                        script={[{"property": "won't work"}]}
-                    />,
+                    <Helmet script={[{property: "won't work"}]} />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const existingTags = headElement.querySelectorAll(`script[${HELMET_ATTRIBUTE}]`);
+                    const existingTags = headElement.querySelectorAll(
+                        `script[${HELMET_ATTRIBUTE}]`
+                    );
 
                     expect(existingTags).to.not.equal(undefined);
                     expect(existingTags.length).to.equal(0);
@@ -1542,17 +1904,23 @@ describe("Helmet", () => {
                 });
             });
 
-            it("sets script tags based on deepest nested component", (done) => {
+            it("sets script tags based on deepest nested component", done => {
                 ReactDOM.render(
                     <div>
                         <Helmet
                             script={[
-                                {"src": "http://localhost/test.js", "type": "text/javascript"}
+                                {
+                                    src: "http://localhost/test.js",
+                                    type: "text/javascript"
+                                }
                             ]}
                         />
                         <Helmet
                             script={[
-                                {"src": "http://localhost/test2.js", "type": "text/javascript"}
+                                {
+                                    src: "http://localhost/test2.js",
+                                    type: "text/javascript"
+                                }
                             ]}
                         />
                     </div>,
@@ -1560,7 +1928,9 @@ describe("Helmet", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`script[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `script[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     const firstTag = existingTags[0];
                     const secondTag = existingTags[1];
@@ -1569,27 +1939,39 @@ describe("Helmet", () => {
 
                     expect(existingTags.length).to.be.at.least(2);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
-                    expect(firstTag.getAttribute("src")).to.equal("http://localhost/test.js");
-                    expect(firstTag.getAttribute("type")).to.equal("text/javascript");
-                    expect(firstTag.outerHTML).to.equal(`<script src="http://localhost/test.js" type="text/javascript" ${HELMET_ATTRIBUTE}="true"></script>`);
+                    expect(firstTag.getAttribute("src")).to.equal(
+                        "http://localhost/test.js"
+                    );
+                    expect(firstTag.getAttribute("type")).to.equal(
+                        "text/javascript"
+                    );
+                    expect(firstTag.outerHTML).to.equal(
+                        `<script src="http://localhost/test.js" type="text/javascript" ${HELMET_ATTRIBUTE}="true"></script>`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[1]")
+                    expect(existingTags).to.have.deep
+                        .property("[1]")
                         .that.is.an.instanceof(Element);
                     expect(secondTag).to.have.property("getAttribute");
-                    expect(secondTag.getAttribute("src")).to.equal("http://localhost/test2.js");
-                    expect(secondTag.getAttribute("type")).to.equal("text/javascript");
-                    expect(secondTag.outerHTML).to.equal(`<script src="http://localhost/test2.js" type="text/javascript" ${HELMET_ATTRIBUTE}="true"></script>`);
+                    expect(secondTag.getAttribute("src")).to.equal(
+                        "http://localhost/test2.js"
+                    );
+                    expect(secondTag.getAttribute("type")).to.equal(
+                        "text/javascript"
+                    );
+                    expect(secondTag.outerHTML).to.equal(
+                        `<script src="http://localhost/test2.js" type="text/javascript" ${HELMET_ATTRIBUTE}="true"></script>`
+                    );
 
                     done();
                 });
             });
 
-            it("sets undefined attribute values to empty strings", (done) => {
+            it("sets undefined attribute values to empty strings", done => {
                 ReactDOM.render(
                     <Helmet
                         script={[
@@ -1603,18 +1985,22 @@ describe("Helmet", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const existingTag = headElement.querySelector(`script[${HELMET_ATTRIBUTE}]`);
+                    const existingTag = headElement.querySelector(
+                        `script[${HELMET_ATTRIBUTE}]`
+                    );
 
                     expect(existingTag).to.not.equal(undefined);
-                    expect(existingTag.outerHTML)
-                        .to.be.a("string")
-                        .that.equals(`<script src="foo.js" async="" ${HELMET_ATTRIBUTE}="true"></script>`);
+                    expect(existingTag.outerHTML).to.be
+                        .a("string")
+                        .that.equals(
+                            `<script src="foo.js" async="" ${HELMET_ATTRIBUTE}="true"></script>`
+                        );
 
                     done();
                 });
             });
 
-            it("does not render tag when primary attribute (src) is null", (done) => {
+            it("does not render tag when primary attribute (src) is null", done => {
                 ReactDOM.render(
                     <Helmet
                         script={[
@@ -1628,7 +2014,9 @@ describe("Helmet", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`script[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `script[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     expect(existingTags).to.be.empty;
 
@@ -1636,7 +2024,7 @@ describe("Helmet", () => {
                 });
             });
 
-            it("does not render tag when primary attribute (innerHTML) is null", (done) => {
+            it("does not render tag when primary attribute (innerHTML) is null", done => {
                 ReactDOM.render(
                     <Helmet
                         script={[
@@ -1649,7 +2037,9 @@ describe("Helmet", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`script[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `script[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     expect(existingTags).to.be.empty;
 
@@ -1659,32 +2049,41 @@ describe("Helmet", () => {
         });
 
         describe("noscript tags", () => {
-            it("updates noscript tags", (done) => {
+            it("updates noscript tags", done => {
                 const noscriptInnerHTML = `<link rel="stylesheet" type="text/css" href="foo.css" />`;
                 ReactDOM.render(
-                    <Helmet noscript={[{id: "bar", innerHTML: noscriptInnerHTML}]} />,
+                    <Helmet
+                        noscript={[{id: "bar", innerHTML: noscriptInnerHTML}]}
+                    />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const existingTags = headElement.getElementsByTagName("noscript");
+                    const existingTags = headElement.getElementsByTagName(
+                        "noscript"
+                    );
 
                     expect(existingTags).to.not.equal(undefined);
                     expect(existingTags.length).to.equal(1);
-                    expect(existingTags[0].innerHTML === noscriptInnerHTML && existingTags[0].id === "bar");
+                    expect(
+                        existingTags[0].innerHTML === noscriptInnerHTML &&
+                            existingTags[0].id === "bar"
+                    );
 
                     done();
                 });
             });
 
-            it("clears all noscripts tags if none are specified", (done) => {
+            it("clears all noscripts tags if none are specified", done => {
                 ReactDOM.render(<Helmet noscript={[{id: "bar"}]} />, container);
 
                 requestIdleCallback(() => {
                     ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
-                        const existingTags = headElement.querySelectorAll(`script[${HELMET_ATTRIBUTE}]`);
+                        const existingTags = headElement.querySelectorAll(
+                            `script[${HELMET_ATTRIBUTE}]`
+                        );
 
                         expect(existingTags).to.not.equal(undefined);
                         expect(existingTags.length).to.equal(0);
@@ -1694,14 +2093,16 @@ describe("Helmet", () => {
                 });
             });
 
-            it("tags without 'innerHTML' are not accepted", (done) => {
+            it("tags without 'innerHTML' are not accepted", done => {
                 ReactDOM.render(
-                    <Helmet noscript={[{"property": "won't work"}]} />,
+                    <Helmet noscript={[{property: "won't work"}]} />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const existingTags = headElement.querySelectorAll(`noscript[${HELMET_ATTRIBUTE}]`);
+                    const existingTags = headElement.querySelectorAll(
+                        `noscript[${HELMET_ATTRIBUTE}]`
+                    );
 
                     expect(existingTags).to.not.equal(undefined);
                     expect(existingTags.length).to.equal(0);
@@ -1710,7 +2111,7 @@ describe("Helmet", () => {
                 });
             });
 
-            it("does not render tag when primary attribute is null", (done) => {
+            it("does not render tag when primary attribute is null", done => {
                 ReactDOM.render(
                     <Helmet
                         noscript={[
@@ -1723,7 +2124,9 @@ describe("Helmet", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`noscript[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `noscript[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     expect(existingTags).to.be.empty;
 
@@ -1733,7 +2136,7 @@ describe("Helmet", () => {
         });
 
         describe("style tags", () => {
-            it("updates style tags", (done) => {
+            it("updates style tags", done => {
                 const cssText1 = `
                     body {
                         background-color: green;
@@ -1760,35 +2163,38 @@ describe("Helmet", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`style[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `style[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
 
-                    const [
-                        firstTag,
-                        secondTag
-                    ] = existingTags;
+                    const [firstTag, secondTag] = existingTags;
                     expect(existingTags).to.not.equal(undefined);
                     expect(existingTags.length).to.be.equal(2);
 
-                    expect(existingTags)
-                        .to.have.deep.property("[0]")
+                    expect(existingTags).to.have.deep
+                        .property("[0]")
                         .that.is.an.instanceof(Element);
                     expect(firstTag).to.have.property("getAttribute");
                     expect(firstTag.getAttribute("type")).to.equal("text/css");
                     expect(firstTag.innerHTML).to.equal(cssText1);
-                    expect(firstTag.outerHTML).to.equal(`<style type="text/css" ${HELMET_ATTRIBUTE}="true">${cssText1}</style>`);
+                    expect(firstTag.outerHTML).to.equal(
+                        `<style type="text/css" ${HELMET_ATTRIBUTE}="true">${cssText1}</style>`
+                    );
 
-                    expect(existingTags)
-                        .to.have.deep.property("[1]")
+                    expect(existingTags).to.have.deep
+                        .property("[1]")
                         .that.is.an.instanceof(Element);
                     expect(secondTag.innerHTML).to.equal(cssText2);
-                    expect(secondTag.outerHTML).to.equal(`<style ${HELMET_ATTRIBUTE}="true">${cssText2}</style>`);
+                    expect(secondTag.outerHTML).to.equal(
+                        `<style ${HELMET_ATTRIBUTE}="true">${cssText2}</style>`
+                    );
 
                     done();
                 });
             });
 
-            it("clears all style tags if none are specified", (done) => {
+            it("clears all style tags if none are specified", done => {
                 const cssText = `
                     body {
                         background-color: green;
@@ -1807,13 +2213,12 @@ describe("Helmet", () => {
                 );
 
                 requestIdleCallback(() => {
-                    ReactDOM.render(
-                        <Helmet />,
-                        container
-                    );
+                    ReactDOM.render(<Helmet />, container);
 
                     requestIdleCallback(() => {
-                        const existingTags = headElement.querySelectorAll(`style[${HELMET_ATTRIBUTE}]`);
+                        const existingTags = headElement.querySelectorAll(
+                            `style[${HELMET_ATTRIBUTE}]`
+                        );
 
                         expect(existingTags).to.not.equal(undefined);
                         expect(existingTags.length).to.equal(0);
@@ -1823,16 +2228,16 @@ describe("Helmet", () => {
                 });
             });
 
-            it("tags without 'cssText' are not accepted", (done) => {
+            it("tags without 'cssText' are not accepted", done => {
                 ReactDOM.render(
-                    <Helmet
-                        style={[{"property": "won't work"}]}
-                    />,
+                    <Helmet style={[{property: "won't work"}]} />,
                     container
                 );
 
                 requestIdleCallback(() => {
-                    const existingTags = headElement.querySelectorAll(`style[${HELMET_ATTRIBUTE}]`);
+                    const existingTags = headElement.querySelectorAll(
+                        `style[${HELMET_ATTRIBUTE}]`
+                    );
 
                     expect(existingTags).to.not.equal(undefined);
                     expect(existingTags.length).to.equal(0);
@@ -1841,7 +2246,7 @@ describe("Helmet", () => {
                 });
             });
 
-            it("does not render tag when primary attribute is null", (done) => {
+            it("does not render tag when primary attribute is null", done => {
                 ReactDOM.render(
                     <Helmet
                         style={[
@@ -1854,7 +2259,9 @@ describe("Helmet", () => {
                 );
 
                 requestIdleCallback(() => {
-                    const tagNodes = headElement.querySelectorAll(`style[${HELMET_ATTRIBUTE}]`);
+                    const tagNodes = headElement.querySelectorAll(
+                        `style[${HELMET_ATTRIBUTE}]`
+                    );
                     const existingTags = Array.prototype.slice.call(tagNodes);
                     expect(existingTags).to.be.empty;
 
@@ -1915,9 +2322,7 @@ describe("Helmet", () => {
 
         it("encodes special characters in title", () => {
             ReactDOM.render(
-                <Helmet
-                    title="Dangerous <script> include"
-                />,
+                <Helmet title="Dangerous <script> include" />,
                 container
             );
 
@@ -1947,9 +2352,7 @@ describe("Helmet", () => {
 
         it("renders title as React component", () => {
             ReactDOM.render(
-                <Helmet
-                    title={"Dangerous <script> include"}
-                />,
+                <Helmet title={"Dangerous <script> include"} />,
                 container
             );
 
@@ -1960,13 +2363,11 @@ describe("Helmet", () => {
 
             const titleComponent = head.title.toComponent();
 
-            expect(titleComponent)
-                .to.be.an("array")
-                .that.has.length.of(1);
+            expect(titleComponent).to.be.an("array").that.has.length.of(1);
 
             titleComponent.forEach(title => {
-                expect(title)
-                    .to.be.an("object")
+                expect(title).to.be
+                    .an("object")
                     .that.contains.property("type", "title");
             });
 
@@ -1976,11 +2377,9 @@ describe("Helmet", () => {
                 </div>
             );
 
-            expect(markup)
-                .to.be.a("string")
-                .that.equals(`<div>${
-                    stringifiedTitle
-                }</div>`);
+            expect(markup).to.be
+                .a("string")
+                .that.equals(`<div>${stringifiedTitle}</div>`);
         });
 
         it("renders title with itemprop name as React component", () => {
@@ -1999,13 +2398,11 @@ describe("Helmet", () => {
 
             const titleComponent = head.title.toComponent();
 
-            expect(titleComponent)
-                .to.be.an("array")
-                .that.has.length.of(1);
+            expect(titleComponent).to.be.an("array").that.has.length.of(1);
 
             titleComponent.forEach(title => {
-                expect(title)
-                    .to.be.an("object")
+                expect(title).to.be
+                    .an("object")
                     .that.contains.property("type", "title");
             });
 
@@ -2015,18 +2412,14 @@ describe("Helmet", () => {
                 </div>
             );
 
-            expect(markup)
-                .to.be.a("string")
-                .that.equals(`<div>${
-                    stringifiedTitleWithItemprop
-                }</div>`);
+            expect(markup).to.be
+                .a("string")
+                .that.equals(`<div>${stringifiedTitleWithItemprop}</div>`);
         });
 
         it("renders base tag as React component", () => {
             ReactDOM.render(
-                <Helmet
-                    base={{"target": "_blank", "href": "http://localhost/"}}
-                />,
+                <Helmet base={{target: "_blank", href: "http://localhost/"}} />,
                 container
             );
 
@@ -2037,13 +2430,11 @@ describe("Helmet", () => {
 
             const baseComponent = head.base.toComponent();
 
-            expect(baseComponent)
-                .to.be.an("array")
-                .that.has.length.of(1);
+            expect(baseComponent).to.be.an("array").that.has.length.of(1);
 
             baseComponent.forEach(base => {
-                expect(base)
-                    .to.be.an("object")
+                expect(base).to.be
+                    .an("object")
                     .that.contains.property("type", "base");
             });
 
@@ -2053,22 +2444,24 @@ describe("Helmet", () => {
                 </div>
             );
 
-            expect(markup)
-                .to.be.a("string")
-                .that.equals(`<div>${
-                    stringifiedBaseTag
-                }</div>`);
+            expect(markup).to.be
+                .a("string")
+                .that.equals(`<div>${stringifiedBaseTag}</div>`);
         });
 
         it("renders meta tags as React components", () => {
             ReactDOM.render(
                 <Helmet
                     meta={[
-                        {"charset": "utf-8"},
-                        {"name": "description", "content": "Test description & encoding of special characters like ' \" > < `"},
-                        {"http-equiv": "content-type", "content": "text/html"},
-                        {"property": "og:type", "content": "article"},
-                        {"itemprop": "name", "content": "Test name itemprop"}
+                        {charset: "utf-8"},
+                        {
+                            name: "description",
+                            content:
+                                "Test description & encoding of special characters like ' \" > < `"
+                        },
+                        {"http-equiv": "content-type", content: "text/html"},
+                        {property: "og:type", content: "article"},
+                        {itemprop: "name", content: "Test name itemprop"}
                     ]}
                 />,
                 container
@@ -2081,13 +2474,11 @@ describe("Helmet", () => {
 
             const metaComponent = head.meta.toComponent();
 
-            expect(metaComponent)
-                .to.be.an("array")
-                .that.has.length.of(5);
+            expect(metaComponent).to.be.an("array").that.has.length.of(5);
 
             metaComponent.forEach(meta => {
-                expect(meta)
-                    .to.be.an("object")
+                expect(meta).to.be
+                    .an("object")
                     .that.contains.property("type", "meta");
             });
 
@@ -2097,19 +2488,21 @@ describe("Helmet", () => {
                 </div>
             );
 
-            expect(markup)
-                .to.be.a("string")
-                .that.equals(`<div>${
-                    stringifiedMetaTags
-                }</div>`);
+            expect(markup).to.be
+                .a("string")
+                .that.equals(`<div>${stringifiedMetaTags}</div>`);
         });
 
         it("renders link tags as React components", () => {
             ReactDOM.render(
                 <Helmet
                     link={[
-                        {"href": "http://localhost/helmet", "rel": "canonical"},
-                        {"href": "http://localhost/style.css", "rel": "stylesheet", "type": "text/css"}
+                        {href: "http://localhost/helmet", rel: "canonical"},
+                        {
+                            href: "http://localhost/style.css",
+                            rel: "stylesheet",
+                            type: "text/css"
+                        }
                     ]}
                 />,
                 container
@@ -2122,13 +2515,11 @@ describe("Helmet", () => {
 
             const linkComponent = head.link.toComponent();
 
-            expect(linkComponent)
-                .to.be.an("array")
-                .that.has.length.of(2);
+            expect(linkComponent).to.be.an("array").that.has.length.of(2);
 
             linkComponent.forEach(link => {
-                expect(link)
-                    .to.be.an("object")
+                expect(link).to.be
+                    .an("object")
                     .that.contains.property("type", "link");
             });
 
@@ -2138,19 +2529,23 @@ describe("Helmet", () => {
                 </div>
             );
 
-            expect(markup)
-                .to.be.a("string")
-                .that.equals(`<div>${
-                    stringifiedLinkTags
-                }</div>`);
+            expect(markup).to.be
+                .a("string")
+                .that.equals(`<div>${stringifiedLinkTags}</div>`);
         });
 
         it("renders script tags as React components", () => {
             ReactDOM.render(
                 <Helmet
                     script={[
-                        {"src": "http://localhost/test.js", "type": "text/javascript"},
-                        {"src": "http://localhost/test2.js", "type": "text/javascript"}
+                        {
+                            src: "http://localhost/test.js",
+                            type: "text/javascript"
+                        },
+                        {
+                            src: "http://localhost/test2.js",
+                            type: "text/javascript"
+                        }
                     ]}
                 />,
                 container
@@ -2163,13 +2558,11 @@ describe("Helmet", () => {
 
             const scriptComponent = head.script.toComponent();
 
-            expect(scriptComponent)
-                .to.be.an("array")
-                .that.has.length.of(2);
+            expect(scriptComponent).to.be.an("array").that.has.length.of(2);
 
             scriptComponent.forEach(script => {
-                expect(script)
-                    .to.be.an("object")
+                expect(script).to.be
+                    .an("object")
                     .that.contains.property("type", "script");
             });
 
@@ -2179,20 +2572,26 @@ describe("Helmet", () => {
                 </div>
             );
 
-            expect(markup)
-                .to.be.a("string")
-                .that.equals(`<div>${
-                    stringifiedScriptTags
-                }</div>`);
+            expect(markup).to.be
+                .a("string")
+                .that.equals(`<div>${stringifiedScriptTags}</div>`);
         });
 
         it("renders noscript tags as React components", () => {
             ReactDOM.render(
                 <Helmet
-                  noscript={[
-                    {id: "foo", innerHTML: '<link rel="stylesheet" type="text/css" href="/style.css" />'},
-                    {id: "bar", innerHTML: '<link rel="stylesheet" type="text/css" href="/style2.css" />'}
-                  ]}
+                    noscript={[
+                        {
+                            id: "foo",
+                            innerHTML:
+                                '<link rel="stylesheet" type="text/css" href="/style.css" />'
+                        },
+                        {
+                            id: "bar",
+                            innerHTML:
+                                '<link rel="stylesheet" type="text/css" href="/style2.css" />'
+                        }
+                    ]}
                 />,
                 container
             );
@@ -2204,13 +2603,11 @@ describe("Helmet", () => {
 
             const noscriptComponent = head.noscript.toComponent();
 
-            expect(noscriptComponent)
-                .to.be.an("array")
-                .that.has.length.of(2);
+            expect(noscriptComponent).to.be.an("array").that.has.length.of(2);
 
             noscriptComponent.forEach(noscript => {
-                expect(noscript)
-                    .to.be.an("object")
+                expect(noscript).to.be
+                    .an("object")
                     .that.contains.property("type", "noscript");
             });
 
@@ -2220,11 +2617,9 @@ describe("Helmet", () => {
                 </div>
             );
 
-            expect(markup)
-                .to.be.a("string")
-                .that.equals(`<div>${
-                    stringifiedNoscriptTags
-                }</div>`);
+            expect(markup).to.be
+                .a("string")
+                .that.equals(`<div>${stringifiedNoscriptTags}</div>`);
         });
 
         it("renders style tags as React components", () => {
@@ -2232,12 +2627,12 @@ describe("Helmet", () => {
                 <Helmet
                     style={[
                         {
-                            "type": "text/css",
-                            "cssText": `body {background-color: green;}`
+                            type: "text/css",
+                            cssText: `body {background-color: green;}`
                         },
                         {
-                            "type": "text/css",
-                            "cssText": `p {font-size: 12px;}`
+                            type: "text/css",
+                            cssText: `p {font-size: 12px;}`
                         }
                     ]}
                 />,
@@ -2251,9 +2646,7 @@ describe("Helmet", () => {
 
             const styleComponent = head.style.toComponent();
 
-            expect(styleComponent)
-                .to.be.an("array")
-                .that.has.length.of(2);
+            expect(styleComponent).to.be.an("array").that.has.length.of(2);
 
             const markup = ReactServer.renderToStaticMarkup(
                 <div>
@@ -2261,18 +2654,14 @@ describe("Helmet", () => {
                 </div>
             );
 
-            expect(markup)
-                .to.be.a("string")
-                .that.equals(`<div>${
-                    stringifiedStyleTags
-                }</div>`);
+            expect(markup).to.be
+                .a("string")
+                .that.equals(`<div>${stringifiedStyleTags}</div>`);
         });
 
         it("renders title tag as string", () => {
             ReactDOM.render(
-                <Helmet
-                    title={"Dangerous <script> include"}
-                />,
+                <Helmet title={"Dangerous <script> include"} />,
                 container
             );
 
@@ -2281,8 +2670,8 @@ describe("Helmet", () => {
             expect(head.title).to.exist;
             expect(head.title).to.respondTo("toString");
 
-            expect(head.title.toString())
-                .to.be.a("string")
+            expect(head.title.toString()).to.be
+                .a("string")
                 .that.equals(stringifiedTitle);
         });
 
@@ -2301,16 +2690,14 @@ describe("Helmet", () => {
             expect(head.title).to.respondTo("toString");
 
             const titleString = head.title.toString();
-            expect(titleString)
-                .to.be.a("string")
+            expect(titleString).to.be
+                .a("string")
                 .that.equals(stringifiedTitleWithItemprop);
         });
 
         it("renders base tags as string", () => {
             ReactDOM.render(
-                <Helmet
-                    base={{"target": "_blank", "href": "http://localhost/"}}
-                />,
+                <Helmet base={{target: "_blank", href: "http://localhost/"}} />,
                 container
             );
 
@@ -2319,8 +2706,8 @@ describe("Helmet", () => {
             expect(head.base).to.exist;
             expect(head.base).to.respondTo("toString");
 
-            expect(head.base.toString())
-                .to.be.a("string")
+            expect(head.base.toString()).to.be
+                .a("string")
                 .that.equals(stringifiedBaseTag);
         });
 
@@ -2328,11 +2715,15 @@ describe("Helmet", () => {
             ReactDOM.render(
                 <Helmet
                     meta={[
-                        {"charset": "utf-8"},
-                        {"name": "description", "content": "Test description & encoding of special characters like ' \" > < `"},
-                        {"http-equiv": "content-type", "content": "text/html"},
-                        {"property": "og:type", "content": "article"},
-                        {"itemprop": "name", "content": "Test name itemprop"}
+                        {charset: "utf-8"},
+                        {
+                            name: "description",
+                            content:
+                                "Test description & encoding of special characters like ' \" > < `"
+                        },
+                        {"http-equiv": "content-type", content: "text/html"},
+                        {property: "og:type", content: "article"},
+                        {itemprop: "name", content: "Test name itemprop"}
                     ]}
                 />,
                 container
@@ -2343,8 +2734,8 @@ describe("Helmet", () => {
             expect(head.meta).to.exist;
             expect(head.meta).to.respondTo("toString");
 
-            expect(head.meta.toString())
-                .to.be.a("string")
+            expect(head.meta.toString()).to.be
+                .a("string")
                 .that.equals(stringifiedMetaTags);
         });
 
@@ -2352,8 +2743,12 @@ describe("Helmet", () => {
             ReactDOM.render(
                 <Helmet
                     link={[
-                        {"href": "http://localhost/helmet", "rel": "canonical"},
-                        {"href": "http://localhost/style.css", "rel": "stylesheet", "type": "text/css"}
+                        {href: "http://localhost/helmet", rel: "canonical"},
+                        {
+                            href: "http://localhost/style.css",
+                            rel: "stylesheet",
+                            type: "text/css"
+                        }
                     ]}
                 />,
                 container
@@ -2364,8 +2759,8 @@ describe("Helmet", () => {
             expect(head.link).to.exist;
             expect(head.link).to.respondTo("toString");
 
-            expect(head.link.toString())
-                .to.be.a("string")
+            expect(head.link.toString()).to.be
+                .a("string")
                 .that.equals(stringifiedLinkTags);
         });
 
@@ -2373,8 +2768,14 @@ describe("Helmet", () => {
             ReactDOM.render(
                 <Helmet
                     script={[
-                        {"src": "http://localhost/test.js", "type": "text/javascript"},
-                        {"src": "http://localhost/test2.js", "type": "text/javascript"}
+                        {
+                            src: "http://localhost/test.js",
+                            type: "text/javascript"
+                        },
+                        {
+                            src: "http://localhost/test2.js",
+                            type: "text/javascript"
+                        }
                     ]}
                 />,
                 container
@@ -2385,8 +2786,8 @@ describe("Helmet", () => {
             expect(head.script).to.exist;
             expect(head.script).to.respondTo("toString");
 
-            expect(head.script.toString())
-                .to.be.a("string")
+            expect(head.script.toString()).to.be
+                .a("string")
                 .that.equals(stringifiedScriptTags);
         });
 
@@ -2395,12 +2796,12 @@ describe("Helmet", () => {
                 <Helmet
                     style={[
                         {
-                            "type": "text/css",
-                            "cssText": `body {background-color: green;}`
+                            type: "text/css",
+                            cssText: `body {background-color: green;}`
                         },
                         {
-                            "type": "text/css",
-                            "cssText": `p {font-size: 12px;}`
+                            type: "text/css",
+                            cssText: `p {font-size: 12px;}`
                         }
                     ]}
                 />,
@@ -2412,8 +2813,8 @@ describe("Helmet", () => {
             expect(head.style).to.exist;
             expect(head.style).to.respondTo("toString");
 
-            expect(head.style.toString())
-                .to.be.a("string")
+            expect(head.style.toString()).to.be
+                .a("string")
                 .that.equals(stringifiedStyleTags);
         });
 
@@ -2437,8 +2838,8 @@ describe("Helmet", () => {
                 <html lang="en" {...attrs} />
             );
 
-            expect(markup)
-                .to.be.a("string")
+            expect(markup).to.be
+                .a("string")
                 .that.equals(`<html ${stringifiedHtmlAttributes}></html>`);
         });
 
@@ -2458,8 +2859,8 @@ describe("Helmet", () => {
             expect(head.htmlAttributes).to.exist;
             expect(head.htmlAttributes).to.respondTo("toString");
 
-            expect(head.htmlAttributes.toString())
-                .to.be.a("string")
+            expect(head.htmlAttributes.toString()).to.be
+                .a("string")
                 .that.equals(stringifiedHtmlAttributes);
         });
 
@@ -2479,16 +2880,13 @@ describe("Helmet", () => {
             expect(head.title).to.exist;
             expect(head.title).to.respondTo("toString");
 
-            expect(head.title.toString())
-                .to.be.a("string")
+            expect(head.title.toString()).to.be
+                .a("string")
                 .that.equals(stringifiedChineseTitle);
         });
 
         it("rewind() provides a fallback object for empty Helmet state", () => {
-            ReactDOM.render(
-                <div />,
-                container
-            );
+            ReactDOM.render(<div />, container);
 
             const head = Helmet.rewind();
 
@@ -2496,12 +2894,14 @@ describe("Helmet", () => {
             expect(head.htmlAttributes).to.respondTo("toString");
             expect(head.htmlAttributes.toString()).to.equal("");
             expect(head.htmlAttributes).to.respondTo("toComponent");
-            expect(head.htmlAttributes.toComponent()).to.be.an("object")
-                .that.is.empty;
+            expect(head.htmlAttributes.toComponent()).to.be.an("object").that.is
+                .empty;
 
             expect(head.title).to.exist;
             expect(head.title).to.respondTo("toString");
-            expect(head.title.toString()).to.equal(`<title ${HELMET_ATTRIBUTE}="true"></title>`);
+            expect(head.title.toString()).to.equal(
+                `<title ${HELMET_ATTRIBUTE}="true"></title>`
+            );
             expect(head.title).to.respondTo("toComponent");
 
             const markup = ReactServer.renderToStaticMarkup(
@@ -2510,51 +2910,47 @@ describe("Helmet", () => {
                 </div>
             );
 
-            expect(markup)
-                .to.be.a("string")
-                .that.equals(`<div><title ${HELMET_ATTRIBUTE}="true"></title></div>`);
+            expect(markup).to.be
+                .a("string")
+                .that.equals(
+                    `<div><title ${HELMET_ATTRIBUTE}="true"></title></div>`
+                );
 
             expect(head.base).to.exist;
             expect(head.base).to.respondTo("toString");
             expect(head.base.toString()).to.equal("");
             expect(head.base).to.respondTo("toComponent");
-            expect(head.base.toComponent()).to.be.an("array")
-                .that.is.empty;
+            expect(head.base.toComponent()).to.be.an("array").that.is.empty;
 
             expect(head.meta).to.exist;
             expect(head.meta).to.respondTo("toString");
             expect(head.meta.toString()).to.equal("");
             expect(head.meta).to.respondTo("toComponent");
-            expect(head.meta.toComponent()).to.be.an("array")
-                .that.is.empty;
+            expect(head.meta.toComponent()).to.be.an("array").that.is.empty;
 
             expect(head.link).to.exist;
             expect(head.link).to.respondTo("toString");
             expect(head.link.toString()).to.equal("");
             expect(head.link).to.respondTo("toComponent");
-            expect(head.link.toComponent()).to.be.an("array")
-                .that.is.empty;
+            expect(head.link.toComponent()).to.be.an("array").that.is.empty;
 
             expect(head.script).to.exist;
             expect(head.script).to.respondTo("toString");
             expect(head.script.toString()).to.equal("");
             expect(head.script).to.respondTo("toComponent");
-            expect(head.script.toComponent()).to.be.an("array")
-                .that.is.empty;
+            expect(head.script.toComponent()).to.be.an("array").that.is.empty;
 
             expect(head.noscript).to.exist;
             expect(head.noscript).to.respondTo("toString");
             expect(head.noscript.toString()).to.equal("");
             expect(head.noscript).to.respondTo("toComponent");
-            expect(head.noscript.toComponent()).to.be.an("array")
-                .that.is.empty;
+            expect(head.noscript.toComponent()).to.be.an("array").that.is.empty;
 
             expect(head.style).to.exist;
             expect(head.style).to.respondTo("toString");
             expect(head.style.toString()).to.equal("");
             expect(head.style).to.respondTo("toComponent");
-            expect(head.style.toComponent()).to.be.an("array")
-                .that.is.empty;
+            expect(head.style.toComponent()).to.be.an("array").that.is.empty;
         });
 
         it("does not render undefined attribute values", () => {
@@ -2573,9 +2969,11 @@ describe("Helmet", () => {
             const {script} = Helmet.rewind();
             const stringifiedScriptTag = script.toString();
 
-            expect(stringifiedScriptTag)
-                .to.be.a("string")
-                .that.equals(`<script ${HELMET_ATTRIBUTE}="true" src="foo.js" async></script>`);
+            expect(stringifiedScriptTag).to.be
+                .a("string")
+                .that.equals(
+                    `<script ${HELMET_ATTRIBUTE}="true" src="foo.js" async></script>`
+                );
         });
         after(() => {
             Helmet.canUseDOM = true;
@@ -2584,25 +2982,15 @@ describe("Helmet", () => {
 
     describe("misc", () => {
         it("throws in rewind() when a DOM is present", () => {
-            ReactDOM.render(
-                <Helmet
-                    title={"Fancy title"}
-                />,
-                container
-            );
+            ReactDOM.render(<Helmet title={"Fancy title"} />, container);
 
             expect(Helmet.rewind).to.throw(
                 "You may only call rewind() on the server. Call peek() to read the current state."
             );
         });
 
-        it("lets you read current state in peek() whether or not a DOM is present", (done) => {
-            ReactDOM.render(
-                <Helmet
-                    title={"Fancy title"}
-                />,
-                container
-            );
+        it("lets you read current state in peek() whether or not a DOM is present", done => {
+            ReactDOM.render(<Helmet title={"Fancy title"} />, container);
 
             requestIdleCallback(() => {
                 expect(Helmet.peek().title).to.be.equal("Fancy title");
@@ -2614,41 +3002,52 @@ describe("Helmet", () => {
             });
         });
 
-        it("encodes special characters", (done) => {
+        it("encodes special characters", done => {
             ReactDOM.render(
                 <Helmet
                     meta={[
-                        {"name": "description", "content": "This is \"quoted\" text and & and '."}
+                        {
+                            name: "description",
+                            content: 'This is "quoted" text and & and \'.'
+                        }
                     ]}
                 />,
                 container
             );
 
             requestIdleCallback(() => {
-                const existingTags = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                const existingTags = headElement.querySelectorAll(
+                    `meta[${HELMET_ATTRIBUTE}]`
+                );
                 const existingTag = existingTags[0];
 
                 expect(existingTags).to.not.equal(undefined);
 
                 expect(existingTags.length).to.be.equal(1);
 
-                expect(existingTags)
-                    .to.have.deep.property("[0]")
+                expect(existingTags).to.have.deep
+                    .property("[0]")
                     .that.is.an.instanceof(Element);
                 expect(existingTag).to.have.property("getAttribute");
-                expect(existingTag.getAttribute("name")).to.equal("description");
-                expect(existingTag.getAttribute("content")).to.equal("This is \"quoted\" text and & and '.");
-                expect(existingTag.outerHTML).to.equal(`<meta name="description" content="This is &quot;quoted&quot; text and &amp; and '." ${HELMET_ATTRIBUTE}="true">`);
+                expect(existingTag.getAttribute("name")).to.equal(
+                    "description"
+                );
+                expect(existingTag.getAttribute("content")).to.equal(
+                    'This is "quoted" text and & and \'.'
+                );
+                expect(existingTag.outerHTML).to.equal(
+                    `<meta name="description" content="This is &quot;quoted&quot; text and &amp; and '." ${HELMET_ATTRIBUTE}="true">`
+                );
 
                 done();
             });
         });
 
-        it("does not change the DOM if it recevies identical props", (done) => {
+        it("does not change the DOM if it recevies identical props", done => {
             const spy = sinon.spy();
             ReactDOM.render(
                 <Helmet
-                    meta={[{"name": "description", "content": "Test description"}]}
+                    meta={[{name: "description", content: "Test description"}]}
                     title={"Test Title"}
                     onChangeClientState={spy}
                 />,
@@ -2659,7 +3058,9 @@ describe("Helmet", () => {
                 // Re-rendering will pass new props to an already mounted Helmet
                 ReactDOM.render(
                     <Helmet
-                        meta={[{"name": "description", "content": "Test description"}]}
+                        meta={[
+                            {name: "description", content: "Test description"}
+                        ]}
                         title={"Test Title"}
                         onChangeClientState={spy}
                     />,
@@ -2674,13 +3075,18 @@ describe("Helmet", () => {
             });
         });
 
-        it("does not write the DOM if the client and server are identical", (done) => {
+        it("does not write the DOM if the client and server are identical", done => {
             headElement.innerHTML = `<script ${HELMET_ATTRIBUTE}="true" src="http://localhost/test.js" type="text/javascript" />`;
 
             const spy = sinon.spy();
             ReactDOM.render(
                 <Helmet
-                    script={[{"src": "http://localhost/test.js", "type": "text/javascript"}]}
+                    script={[
+                        {
+                            src: "http://localhost/test.js",
+                            type: "text/javascript"
+                        }
+                    ]}
                     onChangeClientState={spy}
                 />,
                 container
@@ -2698,14 +3104,20 @@ describe("Helmet", () => {
             });
         });
 
-        it("only adds new tags and preserves tags when rendering additional Helmet instances", (done) => {
+        it("only adds new tags and preserves tags when rendering additional Helmet instances", done => {
             const spy = sinon.spy();
             let addedTags;
             let removedTags;
             ReactDOM.render(
                 <Helmet
-                    link={[{"href": "http://localhost/style.css", "rel": "stylesheet", "type": "text/css"}]}
-                    meta={[{"name": "description", "content": "Test description"}]}
+                    link={[
+                        {
+                            href: "http://localhost/style.css",
+                            rel: "stylesheet",
+                            type: "text/css"
+                        }
+                    ]}
+                    meta={[{name: "description", content: "Test description"}]}
                     onChangeClientState={spy}
                 />,
                 container
@@ -2718,20 +3130,34 @@ describe("Helmet", () => {
 
                 expect(addedTags).to.have.property("metaTags");
                 expect(addedTags.metaTags).to.have.deep.property("[0]");
-                expect(addedTags.metaTags[0].outerHTML).to.equal(`<meta name="description" content="Test description" data-react-helmet="true">`);
+                expect(addedTags.metaTags[0].outerHTML).to.equal(
+                    `<meta name="description" content="Test description" data-react-helmet="true">`
+                );
                 expect(addedTags).to.have.property("linkTags");
                 expect(addedTags.linkTags).to.have.deep.property("[0]");
-                expect(addedTags.linkTags[0].outerHTML).to.equal(`<link href="http://localhost/style.css" rel="stylesheet" type="text/css" data-react-helmet="true">`);
+                expect(addedTags.linkTags[0].outerHTML).to.equal(
+                    `<link href="http://localhost/style.css" rel="stylesheet" type="text/css" data-react-helmet="true">`
+                );
                 expect(removedTags).to.be.empty;
 
                 // Re-rendering will pass new props to an already mounted Helmet
                 ReactDOM.render(
                     <Helmet
                         link={[
-                            {"href": "http://localhost/style.css", "rel": "stylesheet", "type": "text/css"},
-                            {"href": "http://localhost/style2.css", "rel": "stylesheet", "type": "text/css"}
+                            {
+                                href: "http://localhost/style.css",
+                                rel: "stylesheet",
+                                type: "text/css"
+                            },
+                            {
+                                href: "http://localhost/style2.css",
+                                rel: "stylesheet",
+                                type: "text/css"
+                            }
+                        ]}
+                        meta={[
+                            {name: "description", content: "New description"}
                         ]}
-                        meta={[{"name": "description", "content": "New description"}]}
                         onChangeClientState={spy}
                     />,
                     container
@@ -2744,13 +3170,19 @@ describe("Helmet", () => {
 
                     expect(addedTags).to.have.property("metaTags");
                     expect(addedTags.metaTags).to.have.deep.property("[0]");
-                    expect(addedTags.metaTags[0].outerHTML).to.equal(`<meta name="description" content="New description" data-react-helmet="true">`);
+                    expect(addedTags.metaTags[0].outerHTML).to.equal(
+                        `<meta name="description" content="New description" data-react-helmet="true">`
+                    );
                     expect(addedTags).to.have.property("linkTags");
                     expect(addedTags.linkTags).to.have.deep.property("[0]");
-                    expect(addedTags.linkTags[0].outerHTML).to.equal(`<link href="http://localhost/style2.css" rel="stylesheet" type="text/css" data-react-helmet="true">`);
+                    expect(addedTags.linkTags[0].outerHTML).to.equal(
+                        `<link href="http://localhost/style2.css" rel="stylesheet" type="text/css" data-react-helmet="true">`
+                    );
                     expect(removedTags).to.have.property("metaTags");
                     expect(removedTags.metaTags).to.have.deep.property("[0]");
-                    expect(removedTags.metaTags[0].outerHTML).to.equal(`<meta name="description" content="Test description" data-react-helmet="true">`);
+                    expect(removedTags.metaTags[0].outerHTML).to.equal(
+                        `<meta name="description" content="Test description" data-react-helmet="true">`
+                    );
                     expect(removedTags).to.not.have.property("linkTags");
 
                     done();
@@ -2758,16 +3190,12 @@ describe("Helmet", () => {
             });
         });
 
-        it("does not accept nested Helmets", (done) => {
+        it("does not accept nested Helmets", done => {
             const warn = sinon.stub(console, "warn");
 
             ReactDOM.render(
-                <Helmet
-                    title={"Test Title"}
-                >
-                    <Helmet
-                        title={"Title you'll never see"}
-                    />
+                <Helmet title={"Test Title"}>
+                    <Helmet title={"Title you'll never see"} />
                 </Helmet>,
                 container
             );
@@ -2777,52 +3205,62 @@ describe("Helmet", () => {
                 expect(warn.called).to.be.true;
 
                 const [warning] = warn.getCall(0).args;
-                expect(warning).to.equal("You may be attempting to nest <Helmet> components within each other, which is not allowed. Refer to our API for more information.");
+                expect(warning).to.equal(
+                    "You may be attempting to nest <Helmet> components within each other, which is not allowed. Refer to our API for more information."
+                );
 
                 warn.restore();
                 done();
             });
         });
 
-        it("recognizes valid tags regardless of attribute ordering", (done) => {
+        it("recognizes valid tags regardless of attribute ordering", done => {
             ReactDOM.render(
                 <Helmet
-                    meta={[{"content": "Test Description", "name": "description"}]}
+                    meta={[{content: "Test Description", name: "description"}]}
                 />,
                 container
             );
 
             requestIdleCallback(() => {
-                const existingTags = headElement.querySelectorAll(`meta[${HELMET_ATTRIBUTE}]`);
+                const existingTags = headElement.querySelectorAll(
+                    `meta[${HELMET_ATTRIBUTE}]`
+                );
                 const existingTag = existingTags[0];
 
                 expect(existingTags).to.not.equal(undefined);
 
                 expect(existingTags.length).to.be.equal(1);
 
-                expect(existingTags)
-                    .to.have.deep.property("[0]")
+                expect(existingTags).to.have.deep
+                    .property("[0]")
                     .that.is.an.instanceof(Element);
                 expect(existingTag).to.have.property("getAttribute");
-                expect(existingTag.getAttribute("name")).to.equal("description");
-                expect(existingTag.getAttribute("content")).to.equal("Test Description");
-                expect(existingTag.outerHTML).to.equal(`<meta content="Test Description" name="description" ${HELMET_ATTRIBUTE}="true">`);
+                expect(existingTag.getAttribute("name")).to.equal(
+                    "description"
+                );
+                expect(existingTag.getAttribute("content")).to.equal(
+                    "Test Description"
+                );
+                expect(existingTag.outerHTML).to.equal(
+                    `<meta content="Test Description" name="description" ${HELMET_ATTRIBUTE}="true">`
+                );
 
                 done();
             });
         });
 
-        it("requestIdleCallback works as expected", (done) => {
-            requestIdleCallback((cb) => {
+        it("requestIdleCallback works as expected", done => {
+            requestIdleCallback(cb => {
                 expect(cb).to.exist;
 
-                expect(cb)
-                    .to.have.property("didTimeout")
+                expect(cb).to.have
+                    .property("didTimeout")
                     .that.is.a("boolean")
                     .that.equals(false);
 
-                expect(cb)
-                    .to.have.property("timeRemaining")
+                expect(cb).to.have
+                    .property("timeRemaining")
                     .that.is.a("function");
 
                 const time = cb.timeRemaining();
diff --git a/yarn.lock b/yarn.lock
index 8f053f0e..1cb8be5d 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1928,6 +1928,12 @@ eslint-config-nfl@^11.1.0:
   version "11.1.0"
   resolved "https://registry.yarnpkg.com/eslint-config-nfl/-/eslint-config-nfl-11.1.0.tgz#71d4b39e0960a38c12979e0bc269c0573f81f39a"
 
+eslint-config-prettier@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/eslint-config-prettier/-/eslint-config-prettier-2.2.0.tgz#ca47663852789a75c10feba673e802cc1eff085f"
+  dependencies:
+    get-stdin "^5.0.1"
+
 eslint-import-resolver-node@^0.2.0:
   version "0.2.3"
   resolved "https://registry.yarnpkg.com/eslint-import-resolver-node/-/eslint-import-resolver-node-0.2.3.tgz#5add8106e8c928db2cba232bcd9efa846e3da16c"
@@ -1975,6 +1981,13 @@ eslint-plugin-mocha@^4.9.0:
   dependencies:
     ramda "^0.23.0"
 
+eslint-plugin-prettier@^2.1.2:
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-prettier/-/eslint-plugin-prettier-2.1.2.tgz#4b90f4ee7f92bfbe2e926017e1ca40eb628965ea"
+  dependencies:
+    fast-diff "^1.1.1"
+    jest-docblock "^20.0.1"
+
 eslint-plugin-react@^6.10.2:
   version "6.10.3"
   resolved "https://registry.yarnpkg.com/eslint-plugin-react/-/eslint-plugin-react-6.10.3.tgz#c5435beb06774e12c7db2f6abaddcbf900cd3f78"
@@ -2148,6 +2161,10 @@ extsprintf@1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.0.2.tgz#e1080e0658e300b06294990cc70e1502235fd550"
 
+fast-diff@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/fast-diff/-/fast-diff-1.1.1.tgz#0aea0e4e605b6a2189f0e936d4b7fbaf1b7cfd9b"
+
 fast-levenshtein@~2.0.4:
   version "2.0.6"
   resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917"
@@ -2363,6 +2380,10 @@ get-stdin@^4.0.1:
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/get-stdin/-/get-stdin-4.0.1.tgz#b968c6b0a04384324902e8bf1a5df32579a450fe"
 
+get-stdin@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/get-stdin/-/get-stdin-5.0.1.tgz#122e161591e21ff4c52530305693f20e6393a398"
+
 getpass@^0.1.1:
   version "0.1.6"
   resolved "https://registry.yarnpkg.com/getpass/-/getpass-0.1.6.tgz#283ffd9fc1256840875311c1b60e8c40187110e6"
@@ -2914,6 +2935,10 @@ istanbul@^0.4.0, istanbul@^0.4.5:
     which "^1.1.1"
     wordwrap "^1.0.0"
 
+jest-docblock@^20.0.1:
+  version "20.0.3"
+  resolved "https://registry.yarnpkg.com/jest-docblock/-/jest-docblock-20.0.3.tgz#17bea984342cc33d83c50fbe1545ea0efaa44712"
+
 jodid25519@^1.0.0:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/jodid25519/-/jodid25519-1.0.2.tgz#06d4912255093419477d425633606e0e90782967"
@@ -3825,6 +3850,10 @@ preserve@^0.2.0:
   version "0.2.0"
   resolved "https://registry.yarnpkg.com/preserve/-/preserve-0.2.0.tgz#815ed1f6ebc65926f865b310c0713bcb3315ce4b"
 
+prettier@^1.4.4:
+  version "1.4.4"
+  resolved "https://registry.yarnpkg.com/prettier/-/prettier-1.4.4.tgz#a8d1447b14c9bf67e6d420dcadd10fb9a4fad65a"
+
 private@^0.1.6:
   version "0.1.7"
   resolved "https://registry.yarnpkg.com/private/-/private-0.1.7.tgz#68ce5e8a1ef0a23bb570cc28537b5332aba63ef1"