Ajout hyphen

package-lock.json

@@ -4487,6 +4487,11 @@
         "readable-stream": "^2.0.0"
       }
     },
+    "fs": {
+      "version": "0.0.1-security",
+      "resolved": "https://registry.npmjs.org/fs/-/fs-0.0.1-security.tgz",
+      "integrity": "sha1-invTcYa23d84E/I4WLV+yq9eQdQ="
+    },
     "fs-constants": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz",

package.json

@@ -8,6 +8,7 @@
   },
   "dependencies": {
     "babel-runtime": "^6.26.0",
+    "fs": "0.0.1-security",
     "gridsome": "^0.7.0",
     "gridsome-source-strapi": "^0.1.3",
     "hyphenopoly": "^3.4.0",

src/pages/Index.vue

@@ -1,6 +1,5 @@
 <template>
 <Layout>
-  <!-- Mise en page -->
   <!-- introductions -->
   <div class="v-center grow">
     <div v-for="edge in $page.introductions.edges.slice().reverse()" :key="`introductions${edge.node.id}`">
@@ -49,18 +48,18 @@
     </div>
   </div>
   <!-- Chapitres -->
-  <div v-for="(edge,index) in $page.chapitres.edges.slice().reverse()" :key="`chapitre${edge.node.id}`">
+  <div  v-for="(edge,index) in $page.chapitres.edges.slice().reverse()" :key="`chapitre${edge.node.id}`">
     <div class="blank-page no-folio breakBeforeLeft" />
     <div v-if="edge.node.Rubrique">
       <div class="section-title">
         {{edge.node.Rubrique}}
       </div>
-      <h2 :id="`chapitres${edge.node.id}`" class="chapter-title ">{{edge.node.Titre}}</h2>
+      <VueMarkdown :id="`chapitres${edge.node.id}`" class="chapter-title ">{{edge.node.Titre}}</VueMarkdown>
     </div>
     <div v-else>
-      <h2 :id="`chapitres${edge.node.id}`" class="chapter-title">{{edge.node.Titre}}</h2>
+      <VueMarkdown :id="`chapitres${edge.node.id}`" class="chapter-title">{{edge.node.Titre}}</VueMarkdown>
     </div>
-    <VueMarkdown class="chapter-content justify">{{edge.node.Contenu}}
+    <VueMarkdown lang="en-us" class="hyphen chapter-content justify">{{edge.node.Contenu}}
     </VueMarkdown>
   </div>
   <!-- Page blanche -->
@@ -75,8 +74,8 @@
   <!-- Credits -->
   <div class="credits canbreak">
     <div class="credit" v-for="(edge,index) in $page.credits.edges.slice().reverse()" :key="`credits-${edge.node.id}`">
-      <h4 v-html="edge.node.Role"/>
-      <VueMarkdown lang="fr" class="section-content">{{ edge.node.Nom }}</VueMarkdown>
+      <h4 v-html="edge.node.Role" />
+      <VueMarkdown class="section-content">{{ edge.node.Nom }}</VueMarkdown>
     </div>
   </div>
   <div class="blank-page no-folio fill-green" />
@@ -143,10 +142,32 @@ export default {
         });
         allPromises.push(promise);
       });
-      Promise.all(allPromises).then(() => {
-        let previewer = new Previewer();
-        previewer.preview();
+
+      this.$nextTick(function() {
+        Promise.all(allPromises).then(() => {
+
+
+
+          let hyphenopoly = document.createElement('script'),
+            hyph = document.createElement('script');
+          hyphenopoly.setAttribute('src', 'lib/Hyphenopoly-master/Hyphenopoly_Loader.js')
+          hyph.setAttribute('src', 'lib/hyph.js')
+          document.head.appendChild(hyph)
+          document.head.appendChild(hyphenopoly)
+          hyph.onload = () => {
+            Hyphenopoly.handleEvent = {
+              hyphenopolyEnd: (e) => {
+                let previewer = new Previewer();
+                previewer.preview();
+              }
+            };
+
+          };
+
+        });
       });
+
+
     });
   }
 };

static/lib/Hyphenopoly-master/.eslintrc

@@ -0,0 +1,117 @@
+{
+  "parserOptions": {
+    "ecmaVersion": 2018
+  },
+  "env": {
+    "browser": true,
+    "es6": true
+  },
+  "plugins": [
+    "security"
+  ],
+  "extends": [
+    "eslint:all",
+    "plugin:security/recommended"
+  ],
+  "rules": {
+    "no-undef": "error",
+    "complexity": [
+      "error",
+      6
+    ],
+    "require-unicode-regexp": 0,
+    "require-jsdoc": [
+      "error",
+      {
+        "require": {
+          "FunctionDeclaration": true,
+          "MethodDefinition": true,
+          "ClassDeclaration": true,
+          "ArrowFunctionExpression": true,
+          "FunctionExpression": true
+        }
+      }
+    ],
+    "no-template-curly-in-string": 2,
+    "prefer-template": 0,
+    "wrap-iife": 1,
+    "max-lines": 0,
+    "max-lines-per-function": 0,
+    "max-len": [
+      1,
+      {
+        "ignoreStrings": true,
+        "ignoreTemplateLiterals": true
+      }
+    ],
+    "max-statements": 0,
+    "space-before-function-paren": [
+      1,
+      {
+        "anonymous": "always",
+        "named": "never",
+        "asyncArrow": "never"
+      }
+    ],
+    "padded-blocks": [
+      1,
+      "never"
+    ],
+    "id-length": [
+      1,
+      {
+        "min": 1
+      }
+    ],
+    "one-var": 0,
+    "func-names": [
+      1,
+      "as-needed"
+    ],
+    "func-style": [
+      1,
+      "declaration"
+    ],
+    "object-shorthand": 0,
+    "prefer-arrow-callback": 0,
+    "no-param-reassign": 0,
+    "no-extra-parens": 0,
+    "array-element-newline": [
+      1,
+      {
+        "multiline": true,
+        "minItems": 12
+      }
+    ],
+    "no-magic-numbers": 0,
+    "function-paren-newline": [
+      1,
+      "consistent"
+    ],
+    "function-call-argument-newline": [
+      1,
+      "consistent"
+    ],
+    "no-ternary": 0,
+    "no-nested-ternary": 0,
+    "prefer-destructuring": 0,
+    "max-params": [
+      1,
+      5
+    ],
+    "lines-around-comment": [
+      1,
+      {
+        "allowBlockStart": true
+      }
+    ],
+    "sort-keys": [
+      1,
+      "asc",
+      {
+        "caseSensitive": false
+      }
+    ]
+  },
+  "reportUnusedDisableDirectives": true
+}

static/lib/Hyphenopoly-master/.travis.yml

@@ -0,0 +1,6 @@
+language: node_js
+cache: bundler
+node_js:
+  - "10"
+notifications:
+  email: false

static/lib/Hyphenopoly-master/CHANGELOG.md

@@ -0,0 +1,153 @@
+# Version History
+
+## Version 3.4.0 (2019-12-26)
+### Added
+*   Option to disable mixed cased words (issue #91)
+
+### Fixed
+*   Refactor encloseHyphenateFunction and enclHyphenate
+*   bump devDependencies
+
+## Version 3.3.0 (2019-10-14)
+### Added
+*   Add configuration option `keepAlive` (issue #69)
+*   Add documentation for issue #89
+
+### Fixed
+*   Fixed issue where babelized Loader didn't work in iOS9 (issue #88)
+*   bump dev Dependencies (removed some unused eslint directives)
+
+## Version 3.2.1 (2019-08-29)
+Bugfix release, because I had to unpublish from npm
+
+## Version 3.2.0 (2019-08-29)
+### Fixed
+*   Fixed issue with SSL Certificates and FireFox 60.x ESR (issue #85)
+*   Fixed "a potential security vulnerability" in github-pages dependencies
+*   Fixed issue with Firefox 68, where feature detection in Hyphenopoly_Loader fails
+*   bump devDependencies
+
+### Changed
+*   OnCopy-eventHandler now also includes content with type "text/html" (besides "text/plain") (issue #87)
+
+## Version 3.1.2 (2019-07-24)
+### Fixed
+*   Fixed "Critical dependency: the request of a dependency is an expression" in webpack (issue #70)
+*   bump devDependencies
+
+## Version 3.1.1 (2019-06-28)
+### Fixed
+*   bump devDependencies
+
+### Changed
+*   doc: uild github page from docs folder
+*   tools: move eslint config from package.json to .eslintrc
+*   tools: remove manual replacement of mutable globals when compiling to wasm
+
+## Version 3.1.0 (2019-05-28)
+### Fixed
+*   Correctly reject hyphenator promises (issue #77)
+*   performance: reduce file size of Hyphenopoly_Loader.js
+*   update devDependencies
+
+### Added
+*   feature: get maindir and patterndir from currentScript
+
+## Version 3.0.2 (2019-04-28)
+### Security
+*   refactor(Loader): don't use innerHTML
+### Fixed
+*   performance: slightly improved hyphenEngine
+*   bump devDependencies
+
+## Version 3.0.1 (2019-04-04)
+### Fixed
+*   Improve the way how `registerOnCopy` builds a closure. This prevents a memory leak.
+*   Removed "use strict" from RunKit example.
+*   Adapt the initial sizes of wasm-memory in some special cases
+
+## Version 3.0.0 (2019-03-29)
+### Changed
+*   BREAKING CHANGE: implement new hyphenation pattern binary (.hpb) format (issue #61)
+    *   update patterns to new format and include left-/rightmin according to source
+    *   update hyphenEngine.asm/.wasm to consume new pattern format
+    *   implement .hpb-version-check in Hyphenopoly.js and hyphenopoly.module.js
+    *   fix issue #65
+
+### Added
+*   feat: tearDown event (issue #67)
+*   feat: loadError event (issue #59)
+*   feat: hyphenopoly.module is now browserifyable. Added new config option "loader"
+
+### Removed
+*   BREAKING CHANGE: remove `Hyphenopoly.setup.classnames` – use [selectors](https://github.com/mnater/Hyphenopoly/wiki/Global-Hyphenopoly-Object#new-with-version-260-selectors) instead
+
+## Version 2.8.0 (Feb 28, 2019)
+*   the error event now accepts a `lvl` field ("info"/"warn"/"error") and logs accordingly (issue #56)
+*   add list of supported languages in hyphenopoly.module.js (issue #57)
+*   improve loading of ressources (issue #58)
+
+## Version 2.7.0 (Feb 01, 2019)
+*   implement sync mode for node module (issue #43)
+*   implement sync mode for hyphenopoly.module.js (issue #47)
+*   fixed issue with Hyphenopoly.config sometimes not resolving (issue #52)
+*   enable viewport dependent hyphenation (issue #53)
+*   implement `Hyphenopoly.unhyphenate()` (needed for issue #53)
+*   get good grades in codacy.com
+
+## Version 2.6.1 (Jan 09, 2018)
+*   dontHyphenateClass is configurable (issue #48)
+*   fixed issue with StringDecoder in older node versions (issue #45)
+*   small refactorings for smaller codesize
+*   fixed a StateError in IE 11
+
+## Version 2.6.0 (Dec 01, 2018)
+*   improve hiding of elements while hyphenating (issue #40)
+*   fix several issues with lang-fallbacks (issue #41 and #44)
+*   new feature: use selectors instead of classnames (issue #42)
+*   updated german patterns (issue #45)
+
+## Version 2.5.1 (Nov 04, 2018)
+*   remove "Church Slavonic" patterns (see #38)
+*   fix issue #39
+
+## Version 2.5.0 (Oct 02, 2018)
+*   fix issues with very long word (#33 and #34)
+*   Hyphenopoly exposes [Hyphenators](https://github.com/mnater/Hyphenopoly/wiki/Hyphenators)
+*   fix issues with very long word (#33 and #34)
+*   hyphenopoly.module.js is now [easy to use with browserify](https://github.com/mnater/Hyphenopoly/wiki/browserify)
+
+## Version 2.4.0 (Sept 01, 2018)
+*   Implement fallback mechanism for language subtags where no patterns are available (e.g. en-au -> en-gb) [#29](https://github.com/mnater/Hyphenopoly/issues/29)
+*   updated patterns for Thai [#25](https://github.com/hyphenation/tex-hyphen/pull/25)
+
+## Version 2.3.0 (Juli 26, 2018)
+*   Don't use template strings [#28](https://github.com/mnater/Hyphenopoly/issues/28)
+*   run feature test for wasm support only if necessary
+*   define node >=8.3.0 as requirement (for util.TextDecoder)
+*   small refactorings
+
+## Version 2.2.0 (June 26, 2018)
+*   provide example.js for RunKit
+*   use tap instead of mocha
+*   [6f9e539](https://github.com/mnater/Hyphenopoly/commit/6f9e539a5dab2d1eff5bdeb0c7857c6fda9eb41e)
+*   bugfix: [#24](https://github.com/mnater/Hyphenopoly/issues/24): [aeefe6e](https://github.com/mnater/Hyphenopoly/commit/aeefe6e3a59e8356abc99ca490acabf6c3374d7b)
+
+## Version 2.1.0 (Mai 27, 2018)
+*   Configure Travis-CI
+*   bugfixes
+
+## Version 2.0.0 (Mai 27, 2018)
+*   Provide [node module](https://github.com/mnater/Hyphenopoly/wiki/Node-Module)
+*   default file locations better reflect usual installations [#19](https://github.com/mnater/Hyphenopoly/issues/19)
+*   Add ability to store results of feature tests (optional) [#22](https://github.com/mnater/Hyphenopoly/issues/22)
+*   better error handling (f4bbaa7759eed24208e5cd7c744f1131262abb20, 1c7b0b67666b507d6f6b02eea38460562a5835e4)
+*   correct implementation of e.preventDefault (df988788db6fb7120fc0c8a1cff1c91aac5a3998)
+*   fix string normalization (a3229f730f79ccdd3054cbac257b2345f5c8e11a)
+*   Better tooling: minify, eslint, testing (mocha), compiling [devDependencies](https://github.com/mnater/Hyphenopoly/wiki/Usage-of-devDependencies)
+
+## Version 1.0.1 (Mai 13, 2018)
+Prevent browsers to force layout on feature test in some cases.
+
+## Version 1.0.0 (Mai 12, 2018)
+First release

static/lib/Hyphenopoly-master/Hyphenopoly.js

@@ -0,0 +1,1196 @@
+/**
+ * @license Hyphenopoly 3.4.0 - client side hyphenation for webbrowsers
+ * ©2019  Mathias Nater, Zürich (mathiasnater at gmail dot com)
+ * https://github.com/mnater/Hyphenopoly
+ *
+ * Released under the MIT license
+ * http://mnater.github.io/Hyphenopoly/LICENSE
+ */
+
+/* globals asmHyphenEngine:readonly, Hyphenopoly:readonly */
+
+(function mainWrapper(w) {
+    "use strict";
+    const SOFTHYPHEN = String.fromCharCode(173);
+
+    /**
+     * Create Object without standard Object-prototype
+     * @returns {Object} empty object
+     */
+    function empty() {
+        return Object.create(null);
+    }
+
+    /**
+     * Polyfill Math.imul
+     * @param {number} a LHS
+     * @param {number} b RHS
+     * @returns {number} empty object
+     */
+    /* eslint-disable no-bitwise */
+    Math.imul = Math.imul || function imul(a, b) {
+        const aHi = (a >>> 16) & 0xffff;
+        const aLo = a & 0xffff;
+        const bHi = (b >>> 16) & 0xffff;
+        const bLo = b & 0xffff;
+
+        /*
+         * The shift by 0 fixes the sign on the high part.
+         * The final |0 converts the unsigned value into a signed value
+         */
+        return ((aLo * bLo) + ((((aHi * bLo) + (aLo * bHi)) << 16) >>> 0) | 0);
+    };
+    /* eslint-enable no-bitwise */
+
+    /**
+     * Set value and properties of object member
+     * Argument <props> is a bit pattern:
+     * 1. bit: configurable
+     * 2. bit: enumerable
+     * 3. bit writable
+     * e.g. 011(2) = 3(10) => configurable: f, enumerable: t, writable: t
+     * or   010(2) = 2(10) => configurable: f, enumerable: t, writable: f
+     * @param {any} val The value
+     * @param {number} props bitfield
+     * @returns {Object} Property object
+     */
+    function setProp(val, props) {
+        /* eslint-disable no-bitwise, sort-keys */
+        return {
+            "configurable": (props & 4) > 0,
+            "enumerable": (props & 2) > 0,
+            "writable": (props & 1) > 0,
+            "value": val
+        };
+        /* eslint-enable no-bitwise, sort-keys */
+    }
+
+    /**
+     * Register copy event on element
+     * @param {Object} el The element
+     * @returns {undefined}
+     */
+    function registerOnCopy(el) {
+        el.addEventListener(
+            "copy",
+            function oncopy(e) {
+                e.preventDefault();
+                const sel = w.getSelection();
+                const docFrag = sel.getRangeAt(0).cloneContents();
+                const div = document.createElement("div");
+                div.appendChild(docFrag);
+                const selectedHTML = div.innerHTML;
+                const selectedText = sel.toString();
+                /* eslint-disable security/detect-non-literal-regexp */
+                e.clipboardData.setData("text/plain", selectedText.replace(new RegExp(SOFTHYPHEN, "g"), ""));
+                e.clipboardData.setData("text/html", selectedHTML.replace(new RegExp(SOFTHYPHEN, "g"), ""));
+                /* eslint-enable security/detect-non-literal-regexp */
+            },
+            true
+        );
+    }
+
+    (function configurationFactory(H) {
+        const generalDefaults = Object.create(null, {
+            "defaultLanguage": setProp("en-us", 2),
+            "dontHyphenate": setProp((function createList() {
+                const r = empty();
+                const list = "abbr,acronym,audio,br,button,code,img,input,kbd,label,math,option,pre,samp,script,style,sub,sup,svg,textarea,var,video";
+                list.split(",").forEach(function add(value) {
+                /* eslint-disable security/detect-object-injection */
+                    r[value] = true;
+                /* eslint-enable security/detect-object-injection */
+                });
+                return r;
+            }()), 2),
+            "dontHyphenateClass": setProp("donthyphenate", 2),
+            "exceptions": setProp(empty(), 2),
+            "keepAlive": setProp(true, 2),
+            "normalize": setProp(false, 2),
+            "safeCopy": setProp(true, 2),
+            "timeout": setProp(1000, 2)
+        });
+
+        const settings = Object.create(generalDefaults);
+
+        const perClassDefaults = Object.create(null, {
+            "compound": setProp("hyphen", 2),
+            "hyphen": setProp(SOFTHYPHEN, 2),
+            "leftmin": setProp(0, 2),
+            "leftminPerLang": setProp(0, 2),
+            "minWordLength": setProp(6, 2),
+            "mixedCase": setProp(true, 2),
+            "orphanControl": setProp(1, 2),
+            "rightmin": setProp(0, 2),
+            "rightminPerLang": setProp(0, 2)
+        });
+
+        Object.keys(H.setup).forEach(function copySettings(key) {
+            if (key === "selectors") {
+                const selectors = Object.keys(H.setup.selectors);
+                Object.defineProperty(
+                    settings,
+                    "selectors",
+                    setProp(selectors, 2)
+                );
+                selectors.forEach(function copySelectors(sel) {
+                    const tmp = empty();
+                    /* eslint-disable security/detect-object-injection */
+                    Object.keys(H.setup.selectors[sel]).forEach(
+                        function copySelectorSettings(k) {
+                            tmp[k] = setProp(H.setup.selectors[sel][k], 2);
+                        }
+                    );
+                    /* eslint-enable security/detect-object-injection */
+                    Object.defineProperty(
+                        settings,
+                        sel,
+                        setProp(Object.create(perClassDefaults, tmp), 2)
+                    );
+                });
+            } else if (key === "dontHyphenate") {
+                const tmp = empty();
+                Object.keys(H.setup.dontHyphenate).forEach(
+                    function copyTagNames(k) {
+                        /* eslint-disable security/detect-object-injection */
+                        tmp[k] = setProp(H.setup.dontHyphenate[k], 2);
+                        /* eslint-enable security/detect-object-injection */
+                    }
+                );
+                Object.defineProperty(
+                    settings,
+                    key,
+                    setProp(
+                        Object.create(generalDefaults.dontHyphenate, tmp), 3
+                    )
+                );
+            } else {
+                /* eslint-disable security/detect-object-injection */
+                Object.defineProperty(
+                    settings,
+                    key,
+                    setProp(H.setup[key], 3)
+                );
+                /* eslint-enable security/detect-object-injection */
+            }
+        });
+        H.c = settings;
+    }(Hyphenopoly));
+
+    (function H9Y(H) {
+        const C = H.c;
+        let mainLanguage = null;
+        let elements = null;
+
+        /**
+         * Factory for elements
+         * @returns {Object} elements-object
+         */
+        function makeElementCollection() {
+            const list = new Map();
+
+            /*
+             * Counter counts the elements to be hyphenated.
+             * Needs to be an object (Pass by reference)
+             */
+            const counter = [0];
+
+            /**
+             * Add element to elements
+             * @param {object} el The element
+             * @param {string} lang The language of the element
+             * @param {string} sel The selector of the element
+             * @returns {Object} An element-object
+             */
+            function add(el, lang, sel) {
+                const elo = {
+                    "element": el,
+                    "selector": sel
+                };
+                if (!list.has(lang)) {
+                    list.set(lang, []);
+                }
+                list.get(lang).push(elo);
+                counter[0] += 1;
+                return elo;
+            }
+
+            /**
+             * Removes elements from the list and updates the counter
+             * @param {string} lang - The lang of the elements to remove
+             */
+            function rem(lang) {
+                let langCount = 0;
+                if (list.has(lang)) {
+                    langCount = list.get(lang).length;
+                    list.delete(lang);
+                    counter[0] -= langCount;
+                    if (counter[0] === 0) {
+                        H.events.dispatch("hyphenopolyEnd");
+                    }
+                }
+            }
+
+            /**
+             * Execute fn for each element
+             * @param {function} fn The function to execute
+             * @returns {undefined}
+             */
+            function each(fn) {
+                list.forEach(function eachElement(val, key) {
+                    fn(key, val);
+                });
+            }
+
+            return {
+                "add": add,
+                "counter": counter,
+                "each": each,
+                "list": list,
+                "rem": rem
+            };
+        }
+
+        /**
+         * Get language of element by searching its parents or fallback
+         * @param {Object} el The element
+         * @param {boolean} fallback Will falback to mainlanguage
+         * @returns {string|null} The language or null
+         */
+        function getLang(el, fallback) {
+            try {
+                return (el.getAttribute("lang"))
+                    ? el.getAttribute("lang").toLowerCase()
+                    : el.tagName.toLowerCase() === "html"
+                        ? fallback
+                            ? mainLanguage
+                            : null
+                        : getLang(el.parentNode, fallback);
+            } catch (ignore) {
+                return null;
+            }
+        }
+
+        /**
+         * Set mainLanguage
+         * @returns {undefined}
+         */
+        function autoSetMainLanguage() {
+            const el = w.document.getElementsByTagName("html")[0];
+            mainLanguage = getLang(el, false);
+            if (!mainLanguage && C.defaultLanguage !== "") {
+                mainLanguage = C.defaultLanguage;
+            }
+        }
+
+        /**
+         * Check if node is matched by a given selector
+         * @param {Node} n The Node to check
+         * @param {String} sel Selector(s)
+         * @returns {Boolean} true if matched, false if not matched
+         */
+        function nodeMatchedBy(n, sel) {
+            if (!n.matches) {
+                n.matches = n.msMatchesSelector || n.webkitMatchesSelector;
+            }
+            return n.matches(sel);
+        }
+
+        /**
+         * Collect elements that have a selector defined in C.selectors
+         * and add them to elements.
+         * @returns {undefined}
+         */
+        function collectElements() {
+            elements = makeElementCollection();
+
+            const dontHyphenateSelector = (function createSel() {
+                let s = "." + H.c.dontHyphenateClass;
+                let k = null;
+                for (k in C.dontHyphenate) {
+                    /* eslint-disable security/detect-object-injection */
+                    if (C.dontHyphenate[k]) {
+                        s += ", " + k;
+                    }
+                    /* eslint-enable security/detect-object-injection */
+                }
+                return s;
+            }());
+            const matchingSelectors = C.selectors.join(", ") + ", " + dontHyphenateSelector;
+
+            /**
+             * Get Language of Element or of one of its ancestors.
+             * @param {Object} el The element to scan
+             * @param {string} pLang The language of the parent element
+             * @returns {string} the language
+             */
+            function getElementLanguage(el, pLang) {
+                if (el.lang && typeof el.lang === "string") {
+                    return el.lang.toLowerCase();
+                } else if (pLang && pLang !== "") {
+                    return pLang.toLowerCase();
+                }
+                return getLang(el, true);
+            }
+
+            /**
+             * Recursively walk all elements in el, lending lang and selName
+             * add them to elements if necessary.
+             * @param {Object} el The element to scan
+             * @param {string} pLang The language of the oarent element
+             * @param {string} sel The selector of the parent element
+             * @param {boolean} isChild If el is a child element
+             * @returns {undefined}
+             */
+            function processElements(el, pLang, sel, isChild) {
+                isChild = isChild || false;
+                const eLang = getElementLanguage(el, pLang);
+                /* eslint-disable security/detect-object-injection */
+                if (H.cf.langs[eLang] === "H9Y") {
+                    elements.add(el, eLang, sel);
+                    if (!isChild && C.safeCopy) {
+                        registerOnCopy(el);
+                    }
+                } else if (!H.cf.langs[eLang]) {
+                    H.events.dispatch("error", {
+                        "lvl": "warn",
+                        "msg": "Element with '" + eLang + "' found, but '" + eLang + ".hpb' not loaded. Check language tags!"
+                    });
+                }
+                /* eslint-enable security/detect-object-injection */
+                const cn = el.childNodes;
+                Array.prototype.forEach.call(cn, function eachChildNode(n) {
+                    if (n.nodeType === 1 &&
+                        !nodeMatchedBy(n, matchingSelectors)) {
+                        processElements(n, eLang, sel, true);
+                    }
+                });
+            }
+            C.selectors.forEach(function eachSelector(sel) {
+                const nl = w.document.querySelectorAll(sel);
+                Array.prototype.forEach.call(nl, function eachNode(n) {
+                    processElements(n, getLang(n, true), sel, false);
+                });
+            });
+            H.elementsReady = true;
+        }
+
+        const wordHyphenatorPool = new Map();
+
+        /**
+         * Factory for hyphenatorFunctions for a specific language and class
+         * @param {Object} lo Language-Object
+         * @param {string} lang The language
+         * @param {string} sel The selector
+         * @returns {function} The hyphenate function
+         */
+        function createWordHyphenator(lo, lang, sel) {
+            /* eslint-disable-next-line security/detect-object-injection */
+            const classSettings = C[sel];
+            const hyphen = classSettings.hyphen;
+            lo.cache.set(sel, new Map());
+
+            /**
+             * HyphenateFunction for compound words
+             * @param {string} word The word
+             * @returns {string} The hyphenated compound word
+             */
+            function hyphenateCompound(word) {
+                const zeroWidthSpace = String.fromCharCode(8203);
+                let parts = null;
+                let wordHyphenator = null;
+                if (classSettings.compound === "auto" ||
+                    classSettings.compound === "all") {
+                    wordHyphenator = createWordHyphenator(lo, lang, sel);
+                    parts = word.split("-").map(function h7eParts(p) {
+                        if (p.length >= classSettings.minWordLength) {
+                            return wordHyphenator(p);
+                        }
+                        return p;
+                    });
+                    if (classSettings.compound === "auto") {
+                        word = parts.join("-");
+                    } else {
+                        word = parts.join("-" + zeroWidthSpace);
+                    }
+                } else {
+                    word = word.replace("-", "-" + zeroWidthSpace);
+                }
+                return word;
+            }
+
+            /**
+             * Checks if a string is mixed case
+             * @param {string} s The string
+             * @returns {boolean} true if s is mixed case
+             */
+            function isMixedCase(s) {
+                return Array.prototype.map.call(s, function mapper(c) {
+                    return (c === c.toLowerCase());
+                }).some(function checker(v, i, a) {
+                    return (v !== a[0]);
+                });
+            }
+
+            /* eslint-disable complexity */
+            /**
+             * HyphenateFunction for words (compound or not)
+             * @param {string} word The word
+             * @returns {string} The hyphenated word
+             */
+            function hyphenator(word) {
+                let hw = lo.cache.get(sel).get(word);
+                if (!classSettings.mixedCase && isMixedCase(word)) {
+                    hw = word;
+                }
+                if (!hw) {
+                    if (lo.exceptions.has(word)) {
+                        hw = lo.exceptions.get(word).replace(
+                            /-/g,
+                            classSettings.hyphen
+                        );
+                    } else if (word.indexOf("-") === -1) {
+                        if (word.length > 61) {
+                            H.events.dispatch("error", {
+                                "lvl": "warn",
+                                "msg": "found word longer than 61 characters"
+                            });
+                            hw = word;
+                        } else {
+                        /* eslint-disable security/detect-object-injection */
+                            hw = lo.hyphenateFunction(
+                                word,
+                                hyphen.charCodeAt(0),
+                                classSettings.leftminPerLang[lang],
+                                classSettings.rightminPerLang[lang]
+                            );
+                        /* eslint-enable security/detect-object-injection */
+                        }
+                    } else {
+                        hw = hyphenateCompound(word);
+                    }
+                    lo.cache.get(sel).set(word, hw);
+                }
+                return hw;
+            }
+            /* eslint-enable complexity */
+            wordHyphenatorPool.set(lang + "-" + sel, hyphenator);
+            return hyphenator;
+        }
+
+        const orphanControllerPool = new Map();
+
+        /**
+         * Factory for function that handles orphans
+         * @param {string} sel The selector
+         * @returns {function} The function created
+         */
+        function createOrphanController(sel) {
+            /**
+             * Function template
+             * @param {string} ignore unused result of replace
+             * @param {string} leadingWhiteSpace The leading whiteSpace
+             * @param {string} lastWord The last word
+             * @param {string} trailingWhiteSpace The trailing whiteSpace
+             * @returns {string} Treated end of text
+             */
+            function controlOrphans(
+                ignore,
+                leadingWhiteSpace,
+                lastWord,
+                trailingWhiteSpace
+            ) {
+                /* eslint-disable security/detect-object-injection */
+                const classSettings = C[sel];
+                /* eslint-enable security/detect-object-injection */
+                let h = classSettings.hyphen;
+                if (".\\+*?[^]$(){}=!<>|:-".indexOf(classSettings.hyphen) !== -1) {
+                    h = "\\" + classSettings.hyphen;
+                }
+                if (classSettings.orphanControl === 3 && leadingWhiteSpace === " ") {
+                    leadingWhiteSpace = String.fromCharCode(160);
+                }
+                /* eslint-disable security/detect-non-literal-regexp */
+                return leadingWhiteSpace + lastWord.replace(new RegExp(h, "g"), "") + trailingWhiteSpace;
+                /* eslint-enable security/detect-non-literal-regexp */
+            }
+            orphanControllerPool.set(sel, controlOrphans);
+            return controlOrphans;
+        }
+
+        /**
+         * Hyphenate an entitiy (text string or Element-Object)
+         * @param {string} lang - the language of the string
+         * @param {string} sel - the selectorName of settings
+         * @param {string} entity - the entity to be hyphenated
+         * @returns {string | null} hyphenated str according to setting of sel
+         */
+        function hyphenate(lang, sel, entity) {
+            const lo = H.languages.get(lang);
+            /* eslint-disable security/detect-object-injection */
+            const classSettings = C[sel];
+            /* eslint-enable security/detect-object-injection */
+            const minWordLength = classSettings.minWordLength;
+            const normalize = C.normalize &&
+                Boolean(String.prototype.normalize);
+            const poolKey = lang + "-" + sel;
+            const wordHyphenator = (wordHyphenatorPool.has(poolKey))
+                ? wordHyphenatorPool.get(poolKey)
+                : createWordHyphenator(lo, lang, sel);
+            const orphanController = (orphanControllerPool.has(sel))
+                ? orphanControllerPool.get(sel)
+                : createOrphanController(sel);
+            const re = lo.genRegExps.get(sel);
+
+            /**
+             * Hyphenate text according to setting in sel
+             * @param {string} text - the strint to be hyphenated
+             * @returns {string} hyphenated string according to setting of sel
+             */
+            function hyphenateText(text) {
+                let tn = null;
+                if (normalize) {
+                    tn = text.normalize("NFC").replace(re, wordHyphenator);
+                } else {
+                    tn = text.replace(re, wordHyphenator);
+                }
+                if (classSettings.orphanControl !== 1) {
+                    tn = tn.replace(
+                        // eslint-disable-next-line prefer-named-capture-group
+                        /(\u0020*)(\S+)(\s*)$/,
+                        orphanController
+                    );
+                }
+                return tn;
+            }
+
+            /**
+             * Hyphenate element according to setting in sel
+             * @param {object} el - the HTMLElement to be hyphenated
+             * @returns {undefined}
+             */
+            function hyphenateElement(el) {
+                H.events.dispatch("beforeElementHyphenation", {
+                    "el": el,
+                    "lang": lang
+                });
+                const cn = el.childNodes;
+                Array.prototype.forEach.call(cn, function eachChildNode(n) {
+                    if (
+                        n.nodeType === 3 &&
+                        n.data.length >= minWordLength
+                    ) {
+                        n.data = hyphenateText(n.data);
+                    }
+                });
+                elements.counter[0] -= 1;
+                H.events.dispatch("afterElementHyphenation", {
+                    "el": el,
+                    "lang": lang
+                });
+            }
+            let r = null;
+            if (typeof entity === "string") {
+                r = hyphenateText(entity);
+            } else if (entity instanceof HTMLElement) {
+                hyphenateElement(entity);
+            }
+            return r;
+        }
+
+        H.createHyphenator = function createHyphenator(lang) {
+            return function hyphenator(entity, sel) {
+                sel = sel || ".hyphenate";
+                return hyphenate(lang, sel, entity);
+            };
+        };
+
+        H.unhyphenate = function unhyphenate() {
+            elements.each(function eachLang(lang, els) {
+                els.forEach(function eachElem(elo) {
+                    const n = elo.element.firstChild;
+                    const h = C[elo.selector].hyphen;
+                    /* eslint-disable security/detect-non-literal-regexp */
+                    n.data = n.data.replace(new RegExp(h, "g"), "");
+                    /* eslint-enable security/detect-non-literal-regexp */
+                });
+            });
+        };
+
+        /**
+         * Hyphenate all elements with a given language
+         * @param {string} lang The language
+         * @param {Array} elArr Array of elements
+         * @returns {undefined}
+         */
+        function hyphenateLangElements(lang, elArr) {
+            if (elArr) {
+                elArr.forEach(function eachElem(elo) {
+                    hyphenate(lang, elo.selector, elo.element);
+                });
+            } else {
+                H.events.dispatch("error", {
+                    "lvl": "warn",
+                    "msg": "engine for language '" + lang + "' loaded, but no elements found."
+                });
+            }
+            if (elements.counter[0] === 0) {
+                H.events.dispatch("hyphenopolyEnd");
+            }
+        }
+
+        /**
+         * Convert exceptions to object
+         * @param {string} exc comma separated list of exceptions
+         * @returns {Object} Map of exceptions
+         */
+        function convertExceptions(exc) {
+            const r = new Map();
+            exc.split(", ").forEach(function eachExc(e) {
+                const key = e.replace(/-/g, "");
+                r.set(key, e);
+            });
+            return r;
+        }
+
+        /**
+         * Create lang Object
+         * @param {string} lang The language
+         * @returns {Object} The newly
+         */
+        function createLangObj(lang) {
+            if (!H.languages) {
+                H.languages = new Map();
+            }
+            if (!H.languages.has(lang)) {
+                H.languages.set(lang, empty());
+            }
+            return H.languages.get(lang);
+        }
+
+        /**
+         * Setup lo
+         * @param {string} lang The language
+         * @param {function} hyphenateFunction The hyphenateFunction
+         * @param {string} alphabet List of used characters
+         * @param {number} leftmin leftmin
+         * @param {number} rightmin rightmin
+         * @returns {undefined}
+         */
+        function prepareLanguagesObj(
+            lang,
+            hyphenateFunction,
+            alphabet,
+            leftmin,
+            rightmin
+        ) {
+            alphabet = alphabet.replace(/-/g, "");
+            const lo = createLangObj(lang);
+            if (!lo.engineReady) {
+                lo.cache = new Map();
+                /* eslint-disable security/detect-object-injection */
+                if (H.c.exceptions.global) {
+                    if (H.c.exceptions[lang]) {
+                        H.c.exceptions[lang] += ", " + H.c.exceptions.global;
+                    } else {
+                        H.c.exceptions[lang] = H.c.exceptions.global;
+                    }
+                }
+                if (H.c.exceptions[lang]) {
+                    lo.exceptions = convertExceptions(H.c.exceptions[lang]);
+                    delete H.c.exceptions[lang];
+                } else {
+                    lo.exceptions = new Map();
+                }
+                /* eslint-enable security/detect-object-injection */
+                lo.genRegExps = new Map();
+                lo.leftmin = leftmin;
+                lo.rightmin = rightmin;
+                lo.hyphenateFunction = hyphenateFunction;
+                C.selectors.forEach(function eachSelector(sel) {
+                    /* eslint-disable security/detect-object-injection */
+                    const classSettings = C[sel];
+                    /* eslint-enable security/detect-object-injection */
+                    if (classSettings.leftminPerLang === 0) {
+                        Object.defineProperty(
+                            classSettings,
+                            "leftminPerLang",
+                            setProp(empty(), 2)
+                        );
+                    }
+                    if (classSettings.rightminPerLang === 0) {
+                        Object.defineProperty(
+                            classSettings,
+                            "rightminPerLang",
+                            setProp(empty(), 2)
+                        );
+                    }
+                    /* eslint-disable security/detect-object-injection */
+                    if (classSettings.leftminPerLang[lang]) {
+                        classSettings.leftminPerLang[lang] = Math.max(
+                            lo.leftmin,
+                            classSettings.leftmin,
+                            classSettings.leftminPerLang[lang]
+                        );
+                    } else {
+                        classSettings.leftminPerLang[lang] = Math.max(
+                            lo.leftmin,
+                            classSettings.leftmin
+                        );
+                    }
+                    if (classSettings.rightminPerLang[lang]) {
+                        classSettings.rightminPerLang[lang] = Math.max(
+                            lo.rightmin,
+                            classSettings.rightmin,
+                            classSettings.rightminPerLang[lang]
+                        );
+                    } else {
+                        classSettings.rightminPerLang[lang] = Math.max(
+                            lo.rightmin,
+                            classSettings.rightmin
+                        );
+                    }
+                    /* eslint-enable security/detect-object-injection */
+
+                    /*
+                     * Find words with characters from `alphabet` and
+                     * `Zero Width Non-Joiner` and `-` with a min length.
+                     *
+                     * This regexp is not perfect. It also finds parts of words
+                     * that follow a character that is not in the `alphabet`.
+                     * Word delimiters are not taken in account.
+                     */
+                    /* eslint-disable security/detect-non-literal-regexp */
+                    lo.genRegExps.set(sel, new RegExp("[\\w" + alphabet + String.fromCharCode(8204) + "-]{" + classSettings.minWordLength + ",}", "gi"));
+                    /* eslint-enable security/detect-non-literal-regexp */
+                });
+                lo.engineReady = true;
+            }
+            Hyphenopoly.events.dispatch("engineReady", {"msg": lang});
+        }
+
+        /**
+         * Calculate heap size for (w)asm
+         * wasm page size: 65536 = 64 Ki
+         * asm: http://asmjs.org/spec/latest/#linking-0
+         * @param {number} targetSize The targetet Size
+         * @returns {number} The necessary heap size
+         */
+        function calculateHeapSize(targetSize) {
+            /* eslint-disable no-bitwise */
+            if (H.cf.wasm) {
+                return Math.ceil(targetSize / 65536) * 65536;
+            }
+            const exp = Math.ceil(Math.log(targetSize) * Math.LOG2E);
+            if (exp <= 12) {
+                return 1 << 12;
+            }
+            if (exp < 24) {
+                return 1 << exp;
+            }
+            return Math.ceil(targetSize / (1 << 24)) * (1 << 24);
+            /* eslint-enable no-bitwise */
+        }
+
+        /**
+         * Polyfill for TextDecoder
+         */
+        const decode = (function makeDecoder() {
+            if (w.TextDecoder) {
+                const utf16ledecoder = new TextDecoder("utf-16le");
+                return function decoder(ui16) {
+                    return utf16ledecoder.decode(ui16);
+                };
+            }
+            return function decoder(ui16) {
+                return String.fromCharCode.apply(null, ui16);
+            };
+        }());
+
+        /**
+         * Calculate Base Data
+         *
+         * Build Heap (the heap object's byteLength must be
+         * either 2^n for n in [12, 24)
+         * or 2^24 · n for n ≥ 1;)
+         *
+         * MEMORY LAYOUT:
+         *
+         * -------------------- <- Offset 0
+         * |   translateMap   |
+         * |        keys:     |
+         * |256 chars * 2Bytes|
+         * |         +        |
+         * |      values:     |
+         * |256 chars * 1Byte |
+         * -------------------- <- 768 Bytes
+         * |     alphabet     |
+         * |256 chars * 2Bytes|
+         * -------------------- <- valueStoreOffset (vs) = 1280
+         * |    valueStore    |
+         * |      1 Byte      |
+         * |* valueStoreLength|
+         * --------------------
+         * | align to 4Bytes  |
+         * -------------------- <- patternTrieOffset (pt)
+         * |    patternTrie   |
+         * |     4 Bytes      |
+         * |*patternTrieLength|
+         * -------------------- <- wordOffset (wo)
+         * |    wordStore     |
+         * |    Uint16[64]    | 128 bytes
+         * -------------------- <- translatedWordOffset (tw)
+         * | transl.WordStore |
+         * |    Uint8[64]     | 64 bytes
+         * -------------------- <- hyphenPointsOffset (hp)
+         * |   hyphenPoints   |
+         * |    Uint8[64]     | 64 bytes
+         * -------------------- <- hyphenatedWordOffset (hw)
+         * |  hyphenatedWord  |
+         * |   Uint16[128]    | 256 Bytes
+         * -------------------- <- hpbOffset (ho)      -
+         * |     HEADER       |                        |
+         * |    6*4 Bytes     |                        |
+         * |    24 Bytes      |                        |
+         * --------------------                        |
+         * |    PATTERN LIC   |                        |
+         * |  variable Length |                        |
+         * --------------------                        |
+         * | align to 4Bytes  |                        } this is the .hpb-file
+         * -------------------- <- hpbTranslateOffset  |
+         * |    TRANSLATE     |                        |
+         * | 2 + [0] * 2Bytes |                        |
+         * -------------------- <-hpbPatternsOffset(po)|
+         * |     PATTERNS     |                        |
+         * |  patternsLength  |                        |
+         * -------------------- <- heapEnd             -
+         * | align to 4Bytes  |
+         * -------------------- <- heapSize (hs)
+         * @param {Object} hpbBuf FileBuffer from .hpb-file
+         * @returns {Object} baseData-object
+         */
+        function calculateBaseData(hpbBuf) {
+            const hpbMetaData = new Uint32Array(hpbBuf).subarray(0, 8);
+            if (hpbMetaData[0] !== 40005736) {
+                /*
+                 * Pattern files must begin with "hpb2"
+                 * Get current utf8 values with
+                 * `new Uint8Array(Uint32Array.of(hpbMetaData[0]).buffer)`
+                 */
+                H.events.dispatch("error", {
+                    "lvl": "error",
+                    "msg": "Pattern file format error: " + new Uint8Array(Uint32Array.of(hpbMetaData[0]).buffer)
+                });
+                throw new Error("Pattern file format error!");
+            }
+            const valueStoreLength = hpbMetaData[7];
+            const valueStoreOffset = 1280;
+            const patternTrieOffset = valueStoreOffset + valueStoreLength +
+                (4 - ((valueStoreOffset + valueStoreLength) % 4));
+            const wordOffset = patternTrieOffset + (hpbMetaData[6] * 4);
+            return {
+                // Set hpbOffset
+                "ho": wordOffset + 512,
+                // Set hyphenPointsOffset
+                "hp": wordOffset + 192,
+                // Set heapSize
+                "hs": Math.max(calculateHeapSize(wordOffset + 512 + hpbMetaData[2] + hpbMetaData[3]), 32 * 1024 * 64),
+                // Set hyphenatedWordOffset
+                "hw": wordOffset + 256,
+                // Set leftmin
+                "lm": hpbMetaData[4],
+                // Set patternsLength
+                "pl": hpbMetaData[3],
+                // Set hpbPatternsOffset
+                "po": wordOffset + 512 + hpbMetaData[2],
+                // Set patternTrieOffset
+                "pt": patternTrieOffset,
+                // Set rightmin
+                "rm": hpbMetaData[5],
+                // Set translateOffset
+                "to": wordOffset + 512 + hpbMetaData[1],
+                // Set translatedWordOffset
+                "tw": wordOffset + 128,
+                // Set valueStoreOffset
+                "vs": valueStoreOffset,
+                // Set wordOffset
+                "wo": wordOffset
+            };
+        }
+
+        /**
+         * Setup env for hyphenateFunction
+         * @param {Object} baseData baseData
+         * @param {function} hyphenateFunc hyphenateFunction
+         * @returns {function} hyphenateFunction with closured environment
+         */
+        function encloseHyphenateFunction(baseData, hyphenateFunc) {
+            /* eslint-disable no-bitwise */
+            const heapBuffer = H.cf.wasm
+                ? baseData.wasmMemory.buffer
+                : baseData.heapBuffer;
+            const wordStore = (new Uint16Array(heapBuffer)).subarray(
+                baseData.wo >> 1,
+                (baseData.wo >> 1) + 64
+            );
+            const hydWrdStore = (new Uint16Array(heapBuffer)).subarray(
+                baseData.hw >> 1,
+                (baseData.hw >> 1) + 128
+            );
+            /* eslint-enable no-bitwise */
+            wordStore[0] = 95;
+            return function enclHyphenate(word, hyphencc, leftmin, rightmin) {
+                let i = 0;
+                let cc = 0;
+                do {
+                    cc = word.charCodeAt(i);
+                    i += 1;
+                    // eslint-disable-next-line security/detect-object-injection
+                    wordStore[i] = cc;
+                } while (cc);
+                /* eslint-disable security/detect-object-injection */
+                wordStore[i] = 95;
+                wordStore[i + 1] = 0;
+                /* eslint-enable security/detect-object-injection */
+                if (hyphenateFunc(leftmin, rightmin, hyphencc) === 1) {
+                    word = decode(hydWrdStore.subarray(1, hydWrdStore[0] + 1));
+                }
+                return word;
+            };
+        }
+
+        /**
+         * Instantiate Wasm Engine
+         * @param {string} lang The language
+         * @returns {undefined}
+         */
+        function instantiateWasmEngine(lang) {
+            Promise.all([H.bins.get(lang), H.bins.get("hyphenEngine")]).then(
+                function onAll(binaries) {
+                    const hpbBuf = binaries[0];
+                    const baseData = calculateBaseData(hpbBuf);
+                    const wasmModule = binaries[1];
+                    const specMem = H.specMems.get(lang);
+                    const wasmMemory = (
+                        specMem.buffer.byteLength >= baseData.hs
+                    )
+                        ? specMem
+                        : new WebAssembly.Memory({
+                            "initial": baseData.hs / 65536,
+                            "maximum": 256
+                        });
+                    const ui32wasmMemory = new Uint32Array(wasmMemory.buffer);
+                    ui32wasmMemory.set(
+                        new Uint32Array(hpbBuf),
+                        // eslint-disable-next-line no-bitwise
+                        baseData.ho >> 2
+                    );
+                    baseData.wasmMemory = wasmMemory;
+                    WebAssembly.instantiate(wasmModule, {
+                        "env": {
+                            "memory": baseData.wasmMemory,
+                            "memoryBase": 0
+                        },
+                        "x": baseData
+                    }).then(
+                        function runWasm(result) {
+                            const alphalen = result.exports.convert();
+                            prepareLanguagesObj(
+                                lang,
+                                encloseHyphenateFunction(
+                                    baseData,
+                                    result.exports.hyphenate
+                                ),
+                                decode(
+                                    (new Uint16Array(wasmMemory.buffer)).
+                                        subarray(385, 384 + alphalen)
+                                ),
+                                baseData.lm,
+                                baseData.rm
+                            );
+                        }
+                    );
+                }
+            );
+        }
+
+        /**
+         * Instantiate asm Engine
+         * @param {string} lang The language
+         * @returns {undefined}
+         */
+        function instantiateAsmEngine(lang) {
+            const hpbBuf = H.bins.get(lang);
+            const baseData = calculateBaseData(hpbBuf);
+            const specMem = H.specMems.get(lang);
+            const heapBuffer = (specMem.byteLength >= baseData.hs)
+                ? specMem
+                : new ArrayBuffer(baseData.hs);
+            const ui8Heap = new Uint8Array(heapBuffer);
+            const ui8Patterns = new Uint8Array(hpbBuf);
+            ui8Heap.set(ui8Patterns, baseData.ho);
+            baseData.heapBuffer = heapBuffer;
+            const theHyphenEngine = asmHyphenEngine(
+                {
+                    "Int32Array": w.Int32Array,
+                    "Math": Math,
+                    "Uint16Array": w.Uint16Array,
+                    "Uint8Array": w.Uint8Array
+                },
+                baseData,
+                baseData.heapBuffer
+            );
+            const alphalen = theHyphenEngine.convert();
+            prepareLanguagesObj(
+                lang,
+                encloseHyphenateFunction(baseData, theHyphenEngine.hyphenate),
+                decode(
+                    (new Uint16Array(heapBuffer)).
+                        subarray(385, 384 + alphalen)
+                ),
+                baseData.lm,
+                baseData.rm
+            );
+        }
+
+        let engineInstantiator = null;
+        const hpb = [];
+
+        /**
+         * Instantiate hyphenEngines for languages
+         * @param {string} lang The language
+         * @param {string} engineType The engineType: "wasm" or "asm"
+         * @returns {undefined}
+         */
+        function prepare(lang, engineType) {
+            if (lang === "*") {
+                if (engineType === "wasm") {
+                    engineInstantiator = instantiateWasmEngine;
+                } else if (engineType === "asm") {
+                    engineInstantiator = instantiateAsmEngine;
+                }
+                hpb.forEach(function eachHbp(hpbLang) {
+                    engineInstantiator(hpbLang);
+                });
+            } else if (engineInstantiator) {
+                engineInstantiator(lang);
+            } else {
+                hpb.push(lang);
+            }
+        }
+
+        H.events.define(
+            "contentLoaded",
+            function onContentLoaded() {
+                autoSetMainLanguage();
+                collectElements();
+                H.events.dispatch("elementsReady");
+            },
+            false
+        );
+
+        H.events.define(
+            "elementsReady",
+            function onElementsReady() {
+                elements.each(function eachElem(lang, values) {
+                    if (H.languages &&
+                        H.languages.has(lang) &&
+                        H.languages.get(lang).engineReady
+                    ) {
+                        hyphenateLangElements(lang, values);
+                    }
+                });
+            },
+            false
+        );
+
+        H.events.define(
+            "engineLoaded",
+            function onEngineLoaded(e) {
+                prepare("*", e.msg);
+            },
+            false
+        );
+
+        H.events.define(
+            "hpbLoaded",
+            function onHpbLoaded(e) {
+                prepare(e.msg, "*");
+            },
+            false
+        );
+
+        H.events.addListener(
+            "loadError",
+            function onLoadError(e) {
+                if (e.msg !== "wasm") {
+                    elements.rem(e.name);
+                }
+            },
+            false
+        );
+
+        H.events.define(
+            "engineReady",
+            function onEngineReady(e) {
+                if (H.elementsReady) {
+                    hyphenateLangElements(e.msg, elements.list.get(e.msg));
+                }
+            },
+            false
+        );
+
+        H.events.define(
+            "hyphenopolyStart",
+            null,
+            true
+        );
+
+        H.events.define(
+            "hyphenopolyEnd",
+            function def() {
+                w.clearTimeout(C.timeOutHandler);
+                if (C.hide !== "none") {
+                    H.toggle("on");
+                }
+                if (!C.keepAlive) {
+                    window.Hyphenopoly = null;
+                }
+            },
+            false
+        );
+
+        H.events.define(
+            "beforeElementHyphenation",
+            null,
+            true
+        );
+
+        H.events.define(
+            "afterElementHyphenation",
+            null,
+            true
+        );
+
+        H.events.tempRegister.forEach(function eachEo(eo) {
+            H.events.addListener(eo.name, eo.handler, false);
+        });
+        delete H.events.tempRegister;
+
+        H.events.dispatch("hyphenopolyStart", {"msg": "Hyphenopoly started"});
+
+        w.clearTimeout(H.c.timeOutHandler);
+
+        Object.defineProperty(C, "timeOutHandler", setProp(
+            w.setTimeout(function ontimeout() {
+                H.events.dispatch("timeout", {"delay": C.timeout});
+            }, C.timeout),
+            2
+        ));
+
+        H.events.deferred.forEach(function eachDeferred(deferredeo) {
+            H.events.dispatch(deferredeo.name, deferredeo.data);
+        });
+        delete H.events.deferred;
+    }(Hyphenopoly));
+}(window));

static/lib/Hyphenopoly-master/Hyphenopoly_Loader.js

@@ -0,0 +1,785 @@
+/**
+ * @license Hyphenopoly_Loader 3.4.0 - client side hyphenation
+ * ©2019  Mathias Nater, Zürich (mathiasnater at gmail dot com)
+ * https://github.com/mnater/Hyphenopoly
+ *
+ * Released under the MIT license
+ * http://mnater.github.io/Hyphenopoly/LICENSE
+ */
+
+/* globals Hyphenopoly:readonly */
+
+/**
+ * Wrap all code in an iife to keep a scope. Important objects are parameters
+ * of this iife to keep codesize low.
+ * @param {Object} w shorthand for window
+ * @param {Object} d shorthand for document
+ * @param {Object} H shorthand for Hyphenopoly
+ * @param {Object} o shorthand for object
+ */
+(function H9YL(w, d, H, o) {
+    "use strict";
+
+    const store = sessionStorage;
+    const wa = w.WebAssembly;
+    const lcFallbacks = new Map();
+    const lcRequire = new Map();
+
+    /**
+     * Create Object without standard Object-prototype
+     * @returns {Object} empty object
+     */
+    function empty() {
+        return o.create(null);
+    }
+
+
+    /**
+     * Shorthand for Object.keys(obj).forEach(function () {})
+     * @param {Object} obj the object to iterate
+     * @param {function} fn the function to execute
+     * @returns {undefined}
+     */
+    function eachKey(obj, fn) {
+        o.keys(obj).forEach(fn);
+    }
+
+    /**
+     * Set H.cf (Hyphenopoly.clientFeatures) either by reading out previously
+     * computed settings from sessionStorage or creating an template object.
+     * This is in an iife to keep complexity low.
+     */
+    (function configFeat() {
+        if (H.cacheFeatureTests && store.getItem("Hyphenopoly_Loader")) {
+            H.cf = JSON.parse(store.getItem("Hyphenopoly_Loader"));
+        } else {
+            H.cf = {
+                "langs": empty(),
+                "polyfill": false,
+                "wasm": null
+            };
+        }
+    }());
+
+    /**
+     * Set H.paths defaults or overwrite with user settings.
+     * This is in an iife to keep complexity low.
+     */
+    (function configPaths() {
+        const maindir = (d.currentScript)
+            ? d.currentScript.src.replace(/Hyphenopoly_Loader.js/i, "")
+            : "../";
+        const patterndir = maindir + "patterns/";
+        if (H.paths) {
+            H.paths.maindir = H.paths.maindir || maindir;
+            H.paths.patterndir = H.paths.patterndir || patterndir;
+        } else {
+            H.paths = o.create({
+                "maindir": maindir,
+                "patterndir": patterndir
+            });
+        }
+    }());
+
+    /**
+     * Set some H.setup fields to defaults or overwrite with user settings.
+     * This is in an iife to keep complexity low.
+     */
+    (function configSetup() {
+        if (H.setup) {
+            H.setup.selectors = H.setup.selectors || {".hyphenate": {}};
+            H.setup.timeout = H.setup.timeout || 1000;
+            H.setup.hide = H.setup.hide || "all";
+        } else {
+            H.setup = {
+                "hide": "all",
+                "selectors": {".hyphenate": {}},
+                "timeout": 1000
+            };
+        }
+    }());
+
+    /**
+     * Copy required languages to local lcRequire and
+     * eventually fallbacks to local lcFallbacks.
+     * This is in an iife to keep complexity low.
+     */
+    (function configRequire() {
+        eachKey(H.require, function copyRequire(k) {
+            // eslint-disable-next-line security/detect-object-injection
+            lcRequire.set(k.toLowerCase(), H.require[k]);
+        });
+        if (H.fallbacks) {
+            eachKey(H.fallbacks, function copyFallbacks(k) {
+                lcFallbacks.set(
+                    k.toLowerCase(),
+                    // eslint-disable-next-line security/detect-object-injection
+                    H.fallbacks[k].toLowerCase()
+                );
+            });
+        }
+    }());
+
+    /**
+     * Define function H.toggle.
+     * This function hides or unhides (depending of the parameter state)
+     * the whole document (H.setup.hide == "all") or
+     * each selected element (H.setup.hide == "element") or
+     * text of each selected element (H.setup.hide == "text")
+     * @param {string} state State: either on (visible) or off (hidden)
+     */
+    H.toggle = function toggle(state) {
+        if (state === "on") {
+            const stylesNode = d.getElementById("H9Y_Styles");
+            if (stylesNode) {
+                stylesNode.parentNode.removeChild(stylesNode);
+            }
+        } else {
+            const vis = " {visibility: hidden !important}\n";
+            const sc = d.createElement("style");
+            let myStyle = "";
+            sc.id = "H9Y_Styles";
+            switch (H.setup.hide) {
+            case "all":
+                myStyle = "html" + vis;
+                break;
+            case "element":
+                eachKey(H.setup.selectors, function eachSelector(sel) {
+                    myStyle += sel + vis;
+                });
+                break;
+            case "text":
+                eachKey(H.setup.selectors, function eachSelector(sel) {
+                    myStyle += sel + " {color: transparent !important}\n";
+                });
+                break;
+            // No Default
+            }
+            sc.appendChild(d.createTextNode(myStyle));
+            d.head.appendChild(sc);
+        }
+    };
+
+    /**
+     * Setup basic event system. Some events are defined but the definition of
+     * what happens when they are triggered is deferred to Hyphenopoly.js
+     * This is in an iife to keep complexity low.
+     */
+    (function setupEvents() {
+        // Events known to the system
+        const definedEvents = new Map();
+        // Default events, execution deferred to Hyphenopoly.js
+        const deferred = [];
+
+        /*
+         * Register for custom event handlers, where event is not yet defined
+         * these events will be correctly registered in Hyphenopoly.js
+         */
+        const tempRegister = [];
+
+        /**
+         * Create Event Object
+         * @param {string} name The Name of the event
+         * @param {function} defFunc The default method of the event
+         * @param {boolean} cancellable Is the default cancellable
+         * @returns {undefined}
+         */
+        function define(name, defFunc, cancellable) {
+            definedEvents.set(name, {
+                "cancellable": cancellable,
+                "default": defFunc,
+                "register": []
+            });
+        }
+
+        define(
+            "timeout",
+            function def(e) {
+                H.toggle("on");
+                w.console.info(
+                    "Hyphenopolys 'FOUHC'-prevention timed out after %dms",
+                    e.delay
+                );
+            },
+            false
+        );
+
+        define(
+            "error",
+            function def(e) {
+                switch (e.lvl) {
+                case "info":
+                    w.console.info(e.msg);
+                    break;
+                case "warn":
+                    w.console.warn(e.msg);
+                    break;
+                default:
+                    w.console.error(e.msg);
+                }
+            },
+            true
+        );
+
+        define(
+            "contentLoaded",
+            function def(e) {
+                deferred.push({
+                    "data": e,
+                    "name": "contentLoaded"
+                });
+            },
+            false
+        );
+
+        define(
+            "engineLoaded",
+            function def(e) {
+                deferred.push({
+                    "data": e,
+                    "name": "engineLoaded"
+                });
+            },
+            false
+        );
+
+        define(
+            "hpbLoaded",
+            function def(e) {
+                deferred.push({
+                    "data": e,
+                    "name": "hpbLoaded"
+                });
+            },
+            false
+        );
+
+        define(
+            "loadError",
+            function def(e) {
+                deferred.push({
+                    "data": e,
+                    "name": "loadError"
+                });
+            },
+            false
+        );
+
+        define(
+            "tearDown",
+            null,
+            true
+        );
+
+        /**
+         * Dispatch event <name> with arguments <data>
+         * @param {string} name The name of the event
+         * @param {Object|undefined} data Data of the event
+         * @returns {undefined}
+         */
+        function dispatch(name, data) {
+            data = data || empty();
+            let defaultPrevented = false;
+            definedEvents.get(name).register.forEach(
+                function call(currentHandler) {
+                    data.preventDefault = function preventDefault() {
+                        if (definedEvents.get(name).cancellable) {
+                            defaultPrevented = true;
+                        }
+                    };
+                    currentHandler(data);
+                }
+            );
+            if (
+                !defaultPrevented &&
+                definedEvents.get(name).default
+            ) {
+                definedEvents.get(name).default(data);
+            }
+        }
+
+        /**
+         * Add EventListender <handler> to event <name>
+         * @param {string} name The name of the event
+         * @param {function} handler Function to register
+         * @param {boolean} defer If the registration is deferred
+         * @returns {undefined}
+         */
+        function addListener(name, handler, defer) {
+            if (definedEvents.has(name)) {
+                definedEvents.get(name).register.push(handler);
+            } else if (defer) {
+                tempRegister.push({
+                    "handler": handler,
+                    "name": name
+                });
+            } else {
+                H.events.dispatch(
+                    "error",
+                    {
+                        "lvl": "warn",
+                        "msg": "unknown Event \"" + name + "\" discarded"
+                    }
+                );
+            }
+        }
+
+        if (H.handleEvent) {
+            eachKey(H.handleEvent, function add(name) {
+                /* eslint-disable security/detect-object-injection */
+                addListener(name, H.handleEvent[name], true);
+                /* eslint-enable security/detect-object-injection */
+            });
+        }
+
+        H.events = empty();
+        H.events.deferred = deferred;
+        H.events.tempRegister = tempRegister;
+        H.events.dispatch = dispatch;
+        H.events.define = define;
+        H.events.addListener = addListener;
+    }());
+
+    /**
+     * Feature test for wasm.
+     * @returns {boolean} support
+     */
+    function runWasmTest() {
+        /*
+         * Wasm feature test with iOS bug detection
+         * (https://bugs.webkit.org/show_bug.cgi?id=181781)
+         */
+        if (
+            typeof wa === "object" &&
+            typeof wa.Instance === "function"
+        ) {
+            /* eslint-disable array-element-newline */
+            const module = new wa.Module(Uint8Array.from([
+                0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 127,
+                3, 2, 1, 0, 5, 3, 1, 0, 1, 7, 5, 1, 1, 116, 0, 0,
+                10, 16, 1, 14, 0, 32, 0, 65, 1, 54, 2, 0, 32, 0, 40, 2,
+                0, 11
+            ]));
+            /* eslint-enable array-element-newline */
+            return (new wa.Instance(module).exports.t(4) !== 0);
+        }
+        return false;
+    }
+
+    /**
+     * Load script by adding <script>-tag
+     * @param {string} path Where the script is stored
+     * @param {string} filename Filename of the script
+     * @returns {undefined}
+     */
+    function loadScript(path, filename) {
+        const script = d.createElement("script");
+        script.src = path + filename;
+        if (filename === "hyphenEngine.asm.js") {
+            script.addEventListener("load", function listener() {
+                H.events.dispatch("engineLoaded", {"msg": "asm"});
+            });
+        }
+        d.head.appendChild(script);
+    }
+
+    const loadedBins = new Map();
+
+    /**
+     * Load binary files either with fetch (on new browsers that support wasm)
+     * or with xmlHttpRequest
+     * @param {string} path Where the script is stored
+     * @param {string} fne Filename of the script with extension
+     * @param {string} name Name of the ressource
+     * @param {Object} msg Message
+     * @returns {undefined}
+     */
+    function loadBinary(path, fne, name, msg) {
+        /**
+         * Get bin file using fetch
+         * @param {string} p Where the script is stored
+         * @param {string} f Filename of the script with extension
+         * @param {string} n Name of the ressource
+         * @param {Object} m Message
+         * @returns {undefined}
+         */
+        function fetchBinary(p, f, n, m) {
+            w.fetch(p + f, {"credentials": "include"}).then(
+                function resolve(response) {
+                    if (response.ok) {
+                        if (n === "hyphenEngine") {
+                            H.bins.set(n, response.arrayBuffer().then(
+                                function getModule(buf) {
+                                    return new wa.Module(buf);
+                                }
+                            ));
+                            H.events.dispatch("engineLoaded", {"msg": m});
+                        } else {
+                            const files = loadedBins.get(f);
+                            files.forEach(function eachHpb(rn) {
+                                H.bins.set(
+                                    rn,
+                                    (files.length > 1)
+                                        ? response.clone().arrayBuffer()
+                                        : response.arrayBuffer()
+                                );
+                                H.events.dispatch(
+                                    "hpbLoaded",
+                                    {"msg": rn}
+                                );
+                            });
+                        }
+                    } else {
+                        H.events.dispatch("loadError", {
+                            "file": f,
+                            "msg": m,
+                            "name": n,
+                            "path": p
+                        });
+                    }
+                }
+            );
+        }
+
+        /**
+         * Get bin file using XHR
+         * @param {string} p Where the script is stored
+         * @param {string} f Filename of the script with extension
+         * @param {string} n Name of the ressource
+         * @param {Object} m Message
+         * @returns {undefined}
+         */
+        function requestBinary(p, f, n, m) {
+            const xhr = new XMLHttpRequest();
+            xhr.onload = function onload() {
+                if (xhr.status === 200) {
+                    loadedBins.get(f).
+                        forEach(function eachHpb(rn) {
+                            H.bins.set(
+                                rn,
+                                xhr.response
+                            );
+                            H.events.dispatch(
+                                "hpbLoaded",
+                                {"msg": rn}
+                            );
+                        });
+                } else {
+                    H.events.dispatch("loadError", {
+                        "file": f,
+                        "msg": m,
+                        "name": n,
+                        "path": p
+                    });
+                }
+            };
+            xhr.open("GET", p + f);
+            xhr.responseType = "arraybuffer";
+            xhr.send();
+        }
+        if (!loadedBins.has(fne)) {
+            loadedBins.set(fne, [msg]);
+            if (H.cf.wasm) {
+                fetchBinary(path, fne, name, msg);
+            } else {
+                requestBinary(path, fne, name, msg);
+            }
+        } else if (name !== "hyphenEngine") {
+            loadedBins.get(fne).push(msg);
+        }
+    }
+
+    /**
+     * Pre-Allocate memory for (w)asm
+     * Default is 32 wasm Pages (). For languages with larger .hpb
+     * files a higher value is needed.
+     * Get the value from baseData.heapSize in Hyphenopoly.js
+     * @param {string} lang Language
+     * @returns {undefined}
+     */
+    function allocateMemory(lang) {
+        const specVal = new Map(
+            [["de", 54], ["hu", 205], ["nb-no", 91], ["nl", 41]]
+        );
+        const wasmPages = specVal.get(lang) || 32;
+        H.specMems = H.specMems || new Map();
+        if (H.cf.wasm) {
+            H.specMems.set(lang, new wa.Memory({
+                "initial": wasmPages,
+                "maximum": 256
+            }));
+        } else {
+            /* eslint-disable no-bitwise */
+            const asmPages = (2 << Math.floor(
+                Math.log(wasmPages) * Math.LOG2E
+            )) << 16;
+            /* eslint-enable no-bitwise */
+            H.specMems.set(lang, new ArrayBuffer(asmPages));
+        }
+    }
+
+    (function testClientFeatures() {
+        const tester = (function tester() {
+            let fakeBody = null;
+            /* eslint-disable array-element-newline */
+            const css = [
+                "visibility:hidden",
+                "-moz-hyphens:auto",
+                "-webkit-hyphens:auto",
+                "-ms-hyphens:auto",
+                "hyphens:auto",
+                "width:48px",
+                "font-size:12px",
+                "line-height:12px",
+                "border:none",
+                "padding:0",
+                "word-wrap:normal"
+            ].join(";");
+            /* eslint-enable array-element-newline */
+
+            /**
+             * Create and append div with CSS-hyphenated word
+             * @param {string} lang Language
+             * @returns {undefined}
+             */
+            function create(lang) {
+                /* eslint-disable security/detect-object-injection */
+                if (H.cf.langs[lang]) {
+                    return;
+                }
+                /* eslint-enable security/detect-object-injection */
+                fakeBody = fakeBody || d.createElement("body");
+                const testDiv = d.createElement("div");
+                testDiv.lang = lang;
+                testDiv.style.cssText = css;
+                testDiv.appendChild(
+                    d.createTextNode(lcRequire.get(lang).toLowerCase())
+                );
+                fakeBody.appendChild(testDiv);
+            }
+
+            /**
+             * Append fakeBody with tests to target (document)
+             * @param {Object} target Where to append fakeBody
+             * @returns {Object|null} The body element or null, if no tests
+             */
+            function append(target) {
+                if (fakeBody) {
+                    target.appendChild(fakeBody);
+                    return fakeBody;
+                }
+                return null;
+            }
+
+            /**
+             * Remove fakeBody
+             * @returns {undefined}
+             */
+            function clear() {
+                if (fakeBody) {
+                    fakeBody.parentNode.removeChild(fakeBody);
+                }
+            }
+            return {
+                "append": append,
+                "clear": clear,
+                "create": create
+            };
+        }());
+
+        /**
+         * Checks if hyphens (ev.prefixed) is set to auto for the element.
+         * @param {Object} elm - the element
+         * @returns {Boolean} result of the check
+         */
+        function checkCSSHyphensSupport(elm) {
+            return (
+                elm.style.hyphens === "auto" ||
+                elm.style.webkitHyphens === "auto" ||
+                elm.style.msHyphens === "auto" ||
+                elm.style["-moz-hyphens"] === "auto"
+            );
+        }
+
+        /**
+         * Expose the hyphenate-function of a specific language to
+         * Hyphenopoly.hyphenators.<language>
+         *
+         * Hyphenopoly.hyphenators.<language> is a Promise that fullfills
+         * to hyphenate(entity, sel) as soon as the ressources are loaded
+         * and the engine is ready.
+         * If Promises aren't supported (e.g. IE11) a error message is produced.
+         *
+         * @param {string} lang - the language
+         * @returns {undefined}
+         */
+        function exposeHyphenateFunction(lang) {
+            /* eslint-disable security/detect-object-injection */
+            H.hyphenators = H.hyphenators || empty();
+            if (!H.hyphenators[lang]) {
+                if (w.Promise) {
+                    H.hyphenators[lang] = new Promise(function pro(rs, rj) {
+                        H.events.addListener(
+                            "engineReady",
+                            function handler(e) {
+                                if (e.msg === lang) {
+                                    rs(H.createHyphenator(e.msg));
+                                }
+                            },
+                            true
+                        );
+                        H.events.addListener(
+                            "loadError",
+                            function handler(e) {
+                                if (e.name === lang || e.name === "hyphenEngine") {
+                                    rj(new Error("File " + e.file + " can't be loaded from " + e.path));
+                                }
+                            },
+                            false
+                        );
+                    });
+                    H.hyphenators[lang].catch(function catchPromiseError(e) {
+                        H.events.dispatch(
+                            "error",
+                            {
+                                "lvl": "error",
+                                "msg": e.message
+                            }
+                        );
+                    });
+                } else {
+                    H.hyphenators[lang] = {
+
+                        /**
+                         * Fires an error message, if then is called
+                         * @returns {undefined}
+                         */
+                        "then": function () {
+                            H.events.dispatch(
+                                "error",
+                                {"msg": "Promises not supported in this engine. Use a polyfill."}
+                            );
+                        }
+                    };
+                }
+            }
+            /* eslint-enable security/detect-object-injection */
+        }
+
+        /**
+         * Load .hpb files
+         * @param {string} lang The language
+         * @returns {undefined}
+         */
+        function loadPattern(lang) {
+            let filename = lang + ".hpb";
+            let langFallback = lang;
+            H.cf.polyfill = true;
+            // eslint-disable-next-line security/detect-object-injection
+            H.cf.langs[lang] = "H9Y";
+            if (lcFallbacks && lcFallbacks.has(lang)) {
+                langFallback = lcFallbacks.get(lang);
+                filename = langFallback + ".hpb";
+            }
+            H.bins = H.bins || new Map();
+            loadBinary(H.paths.patterndir, filename, langFallback, lang);
+        }
+
+        if (H.cf.wasm === null) {
+            H.cf.wasm = runWasmTest();
+        }
+        lcRequire.forEach(function eachReq(value, lang) {
+            if (value === "FORCEHYPHENOPOLY" ||
+                // eslint-disable-next-line security/detect-object-injection
+                (H.cf.langs[lang] && H.cf.langs[lang] === "H9Y")
+            ) {
+                loadPattern(lang);
+            } else {
+                tester.create(lang);
+            }
+        });
+
+        const testContainer = tester.append(d.documentElement);
+        if (testContainer !== null) {
+            const nl = testContainer.querySelectorAll("div");
+            Array.prototype.forEach.call(nl, function eachNode(n) {
+                if (checkCSSHyphensSupport(n) && n.offsetHeight > 12) {
+                    H.cf.langs[n.lang] = "CSS";
+                } else {
+                    loadPattern(n.lang);
+                }
+            });
+            tester.clear();
+        }
+        if (H.cf.polyfill) {
+            loadScript(H.paths.maindir, "Hyphenopoly.js");
+            if (H.cf.wasm) {
+                loadBinary(
+                    H.paths.maindir,
+                    "hyphenEngine.wasm",
+                    "hyphenEngine",
+                    "wasm"
+                );
+            } else {
+                loadScript(H.paths.maindir, "hyphenEngine.asm.js");
+            }
+            eachKey(H.cf.langs, function prepareEach(lang) {
+                /* eslint-disable security/detect-object-injection */
+                if (H.cf.langs[lang] === "H9Y") {
+                    allocateMemory(lang);
+                    exposeHyphenateFunction(lang);
+                }
+                /* eslint-enable security/detect-object-injection */
+            });
+        }
+    }());
+
+    /**
+     * Hides the specified elements and starts the process by
+     * dispatching a "contentLoaded"-event in Hyphenopoly
+     * @returns {undefined}
+     */
+    function handleDCL() {
+        if (H.setup.hide.match(/^(?:element|text)$/)) {
+            H.toggle("off");
+        }
+        H.events.dispatch(
+            "contentLoaded",
+            {"msg": ["contentLoaded"]}
+        );
+    }
+
+    if (H.cf.polyfill) {
+        if (H.setup.hide === "all") {
+            H.toggle("off");
+        }
+        if (H.setup.hide !== "none") {
+            H.setup.timeOutHandler = w.setTimeout(function timedOut() {
+                H.toggle("on");
+                H.events.dispatch("timeout", {"delay": H.setup.timeout});
+            }, H.setup.timeout);
+        }
+        if (d.readyState === "loading") {
+            d.addEventListener(
+                "DOMContentLoaded",
+                handleDCL,
+                {
+                    "once": true,
+                    "passive": true
+                }
+            );
+        } else {
+            handleDCL();
+        }
+    } else {
+        H.events.dispatch("tearDown", {});
+        w.Hyphenopoly = null;
+    }
+
+    if (H.cacheFeatureTests) {
+        store.setItem(
+            "Hyphenopoly_Loader",
+            JSON.stringify(H.cf)
+        );
+    }
+}(window, document, Hyphenopoly, Object));

static/lib/Hyphenopoly-master/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Mathias Nater
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

static/lib/Hyphenopoly-master/docs/Branching-Model.md

@@ -0,0 +1,34 @@
+# Branching Model
+
+Since Version 3.0.0 a branching model based on [https://nvie.com/posts/a-successful-git-branching-model/](https://nvie.com/posts/a-successful-git-branching-model/) is used.
+
+## Overview
+````text
+       tag                              tag                  tag
+        v                                v                    v
+master    #--------------------------------#--------------------#---  stable
+           \                              /                    /
+(release)   \                      #--#--#                 #--#       locally prepare merge to master
+             \                    /                       /
+develop   ----#--#------#--#--#--#----#-------#--#-------#----------  public dev branch
+                  \    /
+(feature)          #--#                                               local dev branches                                     
+````
+
+## Branches
+
+### master
+The public `master` branch always reflects the currently released actual version, i.e. a production-ready state.
+Merges to `master` must always cause a new release.
+
+### develop
+The public `develop` branch reflects the state of the latest stable development state. The code here is tested but waiting for more changes to accumulate, before a new release is triggered.
+
+### release
+The `release` branch is a temporary preparation branch. It is always branched from the `develop` branch, when enough changes piled up. This is the last stage where version numbers are updated, final tests are made and changelog is finalised before it is merged to master.
+
+`release`branches are named `release-x.y.z`. In most cases they are not pushed to GitHub.
+
+### feature
+`feature` branches are temporary branches for creating features, that can not be implemented directly in the `develop` branch. `feature` branches are branched/merged from/to `develop`.
+In most cases they are not pushed to GitHub and are named depending on the feature they implement.

static/lib/Hyphenopoly-master/docs/Coping-with-hyphenation-errors.md

@@ -0,0 +1,94 @@
+# Hyphenation errors
+Automatic hyphenation can not be error free! Because ...
+* ... [homographs](https://en.wikipedia.org/wiki/Homograph) may be hyphenated differently.
+    ````
+    desert (arid land) -> des‧ert
+    desert (to leave) -> de‧sert
+    ````
+    In some patterns this is solved by not hyphenating ambiguous words at all.
+* ... [neologisms](https://en.wikipedia.org/wiki/Neologism) that are not in the list of words used for pattern creation may be hyphenated incorrectly.
+    ````
+    blogosphere -> blog·o·sphere (Merriam webster)
+        // bl‧o‧gos‧phere (en-us patterns)
+        // blo‧go‧sphere (en-gb patterns)
+    ````
+* ... the rules for hyphenation may have changed or are not specified unambiguously.
+    ````
+    dictionary -> dic‧tion‧ary (Wiktionary)
+        // dic·tio·nary (Merriam-Webster)
+    ````
+* ... the patterns differ in quality. Some are very new and reflect the current state of the language others are older. Some are based on a very large list of words others are crafted by hand (which is not necessarily bad).
+
+In any case automatic hyphenation needs proofreading and may need some intervention.
+
+## Proofread
+Use a visible hyphen character to display all hyphen opportunities:
+````javascript
+<script>
+var Hyphenopoly = {
+    require: [...],
+    setup: {
+        selectors: {
+            ".hyphenate": {
+                hyphen: "•"
+            }
+        }
+    }
+};
+</script>
+````
+See also [Setup#hyphen](./Setup.md#hyphen)
+
+## Fix hyphenation
+There are three levels of fixing possibilities:
+1. [Directly in the text](#fix-hyphenation-in-the-text)
+2. [Defining hyphenation exceptions for Hyphenopoly](#define-hyphenation-exceptions)
+3. [Improve patterns](#help-to-improve-the-patterns)
+
+### Fix hyphenation in the text
+Words containing a soft hyphen (\&shy;) will not be hyphenated by Hyphenopoly.js. Therefor you can simply add soft hyphens manually to 'overwrite' automatic hyphenation.
+
+__pro:__
+- easy to do
+
+__contra:__
+- needs to be repeated for every occurence of the word
+- has no effect in the long term (others will not benefit)
+
+### Define hyphenation exceptions.
+Hyphenopoly.js has an API for hyphenation exceptions: https://github.com/mnater/Hyphenopoly/wiki/Setup#exceptions
+````javascript
+<script>
+var Hyphenopoly = {
+    require: {...},
+    setup: {
+        exceptions: {
+            "en-us": "desert, dic-tion-ary, dic-tion-aries, blog-o-sphere" //language-specific exceptions
+        },
+        selectors: {...}
+    }
+};
+</script>
+````
+In the example above Hyphenopoly.js will never hyphenate the word "desert" (exceptions are not case sensitive) and hyphenate the words "dictionary", "dictionaries" and "blogosphere" at the positions marked with a hyphen-minus.
+
+__pro:__
+- one place for all exceptions
+- exceptions apply to all occurences of the words
+
+__contra:__
+- needs carefulness
+- has no effect in the long term (others will not benefit)
+
+### Help to improve the patterns
+Go to [http://www.hyphenation.org/](http://www.hyphenation.org/) and help to improve the patterns.
+
+__pro:__
+- others will benefit (Mozilla, Apple, the whole TeX-community and many others rely on these patterns)
+- the error will be fixed in long term (sometimes, maybe)
+
+__contra:__
+- fixing patterns often takes a long time (not all patterns are actively maintained)
+- fixing the patterns often requires extended knowledge
+
+As an intermediate step to improved patterns, patterns also have the ability to include exceptions. Follow this guide ([todo](todo)) to improve the patterns Hyphenopoly.js uses.

static/lib/Hyphenopoly-master/docs/Download,-install-and-setup-for-deployment.md

@@ -0,0 +1,38 @@
+# Download for deployment
+
+## General Notes
+
+### Minifying
+While the .wasm and .hpb files are already compact by design, the .js files are not minified. I highly recommend to use one of the es6-savy JavaScript minifier tools.
+
+If you [installed Hyphenopoly with npm](#using-npmjs) run `npm run minify` to create a directory called `min` that contains a full set of minified files (and the test suite) minified with `terser`.
+
+### Compression
+All files have good compression rates when using gzip, deflate and the like. You may need to configure your server to be able to compress `.hpb`-files though!
+
+### es6
+Hyphenopoly_Loader.js and Hyphenopoly.js use some basic es6-syntax (`let`, `const`, etc. not the fancy stuff). If for some reason you need es5-syntax use [babel](http://babeljs.io) to transpile the scripts.
+
+### node
+Hyphenopoly_Loader.js and Hyphenopoly.js is designed for use in browsers. For usage in node.js see: [node module](./Node-Module.md)
+
+Let me now, if you have a use case for hyphenation in node.js
+
+## Download
+
+### Using GitHub
+1. Go to [https://github.com/mnater/Hyphenopoly/releases/latest](https://github.com/mnater/Hyphenopoly/releases/latest) and download the latest stable version (don't be afraid of the name `Source code`).
+2. Unpack the package and copy the following files and folders to your server:
+    * `Hyphenopoly_Loader.js`
+    * `Hyphenopoly.js`
+    * `hyphenEngine.asm.js`
+    * `hyphenEnginge.wasm`
+    * `patterns/`
+
+    (Of course you can delete the patterns for the language you won't need.)
+3. Then follow the instructions on [https://github.com/mnater/Hyphenopoly#usage-browser](https://github.com/mnater/Hyphenopoly#usage-browser)
+ 
+### Using npm.js
+1. Run `npm i hyphenopoly` in your project folder
+2. Tell Hyphenopoly where to find the files: [paths](./Global-Hyphenopoly-Object.md#paths)
+3. Follow the instructions on [https://github.com/mnater/Hyphenopoly#usage-browser](https://github.com/mnater/Hyphenopoly#usage-browser) (don't forget to adapt the paths)

static/lib/Hyphenopoly-master/docs/Events.md

@@ -0,0 +1,140 @@
+# Events
+Hyphenopoly fires a bunch of events while executing. As a user you can extend or overwrite the actions performed by these events.
+Some events have a default action that may be prevented (if event is cancellable).
+
+## timeout-Event
+Fired when the Flash Of Unhyphenated Content-prevention timed out.
+
+````
+Default-action: unhides content
+cancellable: false
+Fields: `delay` (timeout in ms)
+````
+
+## error-Event
+Fired when an error occurs.
+
+````
+Default-action: `window.console.error(e.msg);`
+cancellable: true
+Fields: `msg` (error message)
+````
+
+To silent errors prevent default of this event:
+
+````javascript
+const Hyphenopoly = {
+    require: {
+        //[...]
+    },
+    handleEvent: {
+        error: function (e) {
+            e.preventDefault(); //don't show error messages in console
+        }
+    }
+}
+````
+
+## contentLoaded-Event
+Handles the DOMContentLoaded internally.
+Can be manually fired if contentChanges to rehyphenate the document.
+
+````
+Default-action: runs Hyphenopoly (together with `engineLoaded` and `hpbLoaded`)
+cancellable: false
+Fields: `msg` (list of what has been loaded)
+````
+
+_note: use [Hyphenators](./Hyphenators.md) to prevent a costly rehyphenation of the whole document_
+
+## engineLoaded-Event
+Fired when the (w)asm-engine is instantiated.
+
+````
+Default-action: starts Hyphenopoly (together with `DOMContentLoaded ` and `hpbLoaded`)
+cancellable: false
+Fields: `msg` (list of what has been loaded)
+````
+
+## hpbLoaded-Event
+Fired on each load of a patternfile.
+
+````
+Default-action: starts Hyphenopoly (together with `DOMContentLoaded ` and `engineLoaded `)
+cancellable: false
+Fields: `msg` (list of what has been loaded)
+````
+
+## loadError-Event
+(new in v3.0.0)
+Fired just before Hyphenopoly is deleted if the browser supports native CSS.
+
+````
+Default-action: Remove elements from the internal list of elements to be hyphenated.
+cancellable: false
+Fields: `msg` (list of what has not been loaded)
+````
+
+## elementsReady-Event
+Fired when elements are collected and ready for hyphenation.
+
+````
+Default-action: Starts hyphenation if pattern file and engine are ready.
+cancellable: false
+Fields: null
+````
+
+## engineReady-Event
+Fired when engine and pattern files are ready.
+
+````
+Default-action: Starts hyphenation if elements are ready.
+cancellable: false
+Fields: msg (language code)
+````
+
+## hyphenopolyStart-Event
+Fired when Hyphenopoly starts.
+
+````
+Default-action: null
+cancellable: true
+Fields: msg
+````
+
+## hyphenopolyEnd-Event
+Fired when all collected elements are hyphenated.
+
+````
+Default-action: clears FOUHC-timeout and unhides elements
+cancellable: false
+Fields: null
+````
+
+## beforeElementHyphenation-Event
+Fired before an element gets hyphenated.
+
+````
+Default-action: null
+cancellable: true
+Fields: `el` (element), `lang` (language-code)
+````
+
+## afterElementHyphenation-Event
+Fired after an element has been hyphenated.
+
+````
+Default-action: null
+cancellable: true
+Fields: `el` (element), `lang` (language-code)
+````
+
+## tearDown-Event
+(new in v3.0.0)
+Fired just before Hyphenopoly is deleted if the browser supports native CSS.
+
+````
+Default-action: null
+cancellable: true
+Fields: null
+````

static/lib/Hyphenopoly-master/docs/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+gem 'github-pages', group: :jekyll_plugins

static/lib/Hyphenopoly-master/docs/Gemfile.lock

@@ -0,0 +1,248 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.11.1)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    addressable (2.6.0)
+      public_suffix (>= 2.0.2, < 4.0)
+    coffee-script (2.4.1)
+      coffee-script-source
+      execjs
+    coffee-script-source (1.11.1)
+    colorator (1.1.0)
+    commonmarker (0.17.13)
+      ruby-enum (~> 0.5)
+    concurrent-ruby (1.1.5)
+    dnsruby (1.61.3)
+      addressable (~> 2.5)
+    em-websocket (0.5.1)
+      eventmachine (>= 0.12.9)
+      http_parser.rb (~> 0.6.0)
+    ethon (0.12.0)
+      ffi (>= 1.3.0)
+    eventmachine (1.2.7)
+    execjs (2.7.0)
+    faraday (0.15.4)
+      multipart-post (>= 1.2, < 3)
+    ffi (1.11.1)
+    forwardable-extended (2.6.0)
+    gemoji (3.0.1)
+    github-pages (198)
+      activesupport (= 4.2.11.1)
+      github-pages-health-check (= 1.16.1)
+      jekyll (= 3.8.5)
+      jekyll-avatar (= 0.6.0)
+      jekyll-coffeescript (= 1.1.1)
+      jekyll-commonmark-ghpages (= 0.1.5)
+      jekyll-default-layout (= 0.1.4)
+      jekyll-feed (= 0.11.0)
+      jekyll-gist (= 1.5.0)
+      jekyll-github-metadata (= 2.12.1)
+      jekyll-mentions (= 1.4.1)
+      jekyll-optional-front-matter (= 0.3.0)
+      jekyll-paginate (= 1.1.0)
+      jekyll-readme-index (= 0.2.0)
+      jekyll-redirect-from (= 0.14.0)
+      jekyll-relative-links (= 0.6.0)
+      jekyll-remote-theme (= 0.3.1)
+      jekyll-sass-converter (= 1.5.2)
+      jekyll-seo-tag (= 2.5.0)
+      jekyll-sitemap (= 1.2.0)
+      jekyll-swiss (= 0.4.0)
+      jekyll-theme-architect (= 0.1.1)
+      jekyll-theme-cayman (= 0.1.1)
+      jekyll-theme-dinky (= 0.1.1)
+      jekyll-theme-hacker (= 0.1.1)
+      jekyll-theme-leap-day (= 0.1.1)
+      jekyll-theme-merlot (= 0.1.1)
+      jekyll-theme-midnight (= 0.1.1)
+      jekyll-theme-minimal (= 0.1.1)
+      jekyll-theme-modernist (= 0.1.1)
+      jekyll-theme-primer (= 0.5.3)
+      jekyll-theme-slate (= 0.1.1)
+      jekyll-theme-tactile (= 0.1.1)
+      jekyll-theme-time-machine (= 0.1.1)
+      jekyll-titles-from-headings (= 0.5.1)
+      jemoji (= 0.10.2)
+      kramdown (= 1.17.0)
+      liquid (= 4.0.0)
+      listen (= 3.1.5)
+      mercenary (~> 0.3)
+      minima (= 2.5.0)
+      nokogiri (>= 1.8.5, < 2.0)
+      rouge (= 2.2.1)
+      terminal-table (~> 1.4)
+    github-pages-health-check (1.16.1)
+      addressable (~> 2.3)
+      dnsruby (~> 1.60)
+      octokit (~> 4.0)
+      public_suffix (~> 3.0)
+      typhoeus (~> 1.3)
+    html-pipeline (2.12.0)
+      activesupport (>= 2)
+      nokogiri (>= 1.4)
+    http_parser.rb (0.6.0)
+    i18n (0.9.5)
+      concurrent-ruby (~> 1.0)
+    jekyll (3.8.5)
+      addressable (~> 2.4)
+      colorator (~> 1.0)
+      em-websocket (~> 0.5)
+      i18n (~> 0.7)
+      jekyll-sass-converter (~> 1.0)
+      jekyll-watch (~> 2.0)
+      kramdown (~> 1.14)
+      liquid (~> 4.0)
+      mercenary (~> 0.3.3)
+      pathutil (~> 0.9)
+      rouge (>= 1.7, < 4)
+      safe_yaml (~> 1.0)
+    jekyll-avatar (0.6.0)
+      jekyll (~> 3.0)
+    jekyll-coffeescript (1.1.1)
+      coffee-script (~> 2.2)
+      coffee-script-source (~> 1.11.1)
+    jekyll-commonmark (1.3.1)
+      commonmarker (~> 0.14)
+      jekyll (>= 3.7, < 5.0)
+    jekyll-commonmark-ghpages (0.1.5)
+      commonmarker (~> 0.17.6)
+      jekyll-commonmark (~> 1)
+      rouge (~> 2)
+    jekyll-default-layout (0.1.4)
+      jekyll (~> 3.0)
+    jekyll-feed (0.11.0)
+      jekyll (~> 3.3)
+    jekyll-gist (1.5.0)
+      octokit (~> 4.2)
+    jekyll-github-metadata (2.12.1)
+      jekyll (~> 3.4)
+      octokit (~> 4.0, != 4.4.0)
+    jekyll-mentions (1.4.1)
+      html-pipeline (~> 2.3)
+      jekyll (~> 3.0)
+    jekyll-optional-front-matter (0.3.0)
+      jekyll (~> 3.0)
+    jekyll-paginate (1.1.0)
+    jekyll-readme-index (0.2.0)
+      jekyll (~> 3.0)
+    jekyll-redirect-from (0.14.0)
+      jekyll (~> 3.3)
+    jekyll-relative-links (0.6.0)
+      jekyll (~> 3.3)
+    jekyll-remote-theme (0.3.1)
+      jekyll (~> 3.5)
+      rubyzip (>= 1.2.1, < 3.0)
+    jekyll-sass-converter (1.5.2)
+      sass (~> 3.4)
+    jekyll-seo-tag (2.5.0)
+      jekyll (~> 3.3)
+    jekyll-sitemap (1.2.0)
+      jekyll (~> 3.3)
+    jekyll-swiss (0.4.0)
+    jekyll-theme-architect (0.1.1)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-cayman (0.1.1)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-dinky (0.1.1)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-hacker (0.1.1)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-leap-day (0.1.1)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-merlot (0.1.1)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-midnight (0.1.1)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-minimal (0.1.1)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-modernist (0.1.1)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-primer (0.5.3)
+      jekyll (~> 3.5)
+      jekyll-github-metadata (~> 2.9)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-slate (0.1.1)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-tactile (0.1.1)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-time-machine (0.1.1)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-titles-from-headings (0.5.1)
+      jekyll (~> 3.3)
+    jekyll-watch (2.2.1)
+      listen (~> 3.0)
+    jemoji (0.10.2)
+      gemoji (~> 3.0)
+      html-pipeline (~> 2.2)
+      jekyll (~> 3.0)
+    kramdown (1.17.0)
+    liquid (4.0.0)
+    listen (3.1.5)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+      ruby_dep (~> 1.2)
+    mercenary (0.3.6)
+    mini_portile2 (2.4.0)
+    minima (2.5.0)
+      jekyll (~> 3.5)
+      jekyll-feed (~> 0.9)
+      jekyll-seo-tag (~> 2.1)
+    minitest (5.11.3)
+    multipart-post (2.1.1)
+    nokogiri (1.10.4)
+      mini_portile2 (~> 2.4.0)
+    octokit (4.14.0)
+      sawyer (~> 0.8.0, >= 0.5.3)
+    pathutil (0.16.2)
+      forwardable-extended (~> 2.6)
+    public_suffix (3.1.1)
+    rb-fsevent (0.10.3)
+    rb-inotify (0.10.0)
+      ffi (~> 1.0)
+    rouge (2.2.1)
+    ruby-enum (0.7.2)
+      i18n
+    ruby_dep (1.5.0)
+    rubyzip (2.0.0)
+    safe_yaml (1.0.5)
+    sass (3.7.4)
+      sass-listen (~> 4.0.0)
+    sass-listen (4.0.0)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+    sawyer (0.8.2)
+      addressable (>= 2.3.5)
+      faraday (> 0.8, < 2.0)
+    terminal-table (1.8.0)
+      unicode-display_width (~> 1.1, >= 1.1.1)
+    thread_safe (0.3.6)
+    typhoeus (1.3.1)
+      ethon (>= 0.9.0)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  github-pages
+
+BUNDLED WITH
+   2.0.2

static/lib/Hyphenopoly-master/docs/Global-Hyphenopoly-Object.md

@@ -0,0 +1,148 @@
+# The global Hyphenopoly object
+
+Before loading Hyphenopoly_Loader.js initial settings must be provided in a global `Hyphenopoly`-object. This is the only place in global space where Hyphenopoly.js puts data.
+
+## Mandatory Fields
+These fields in the `Hyphenopoly`-object must be defined.
+
+### require
+The `require` field must be an object of key-value-pairs, where the keys are language codes and the values are a long word (>=12 characters) in the required language.
+````javascript
+require: {
+    "en-us": "supercalifragilisticexpialidocious",
+    "de": "Silbentrennungsalgorithmus"
+}
+````
+Hyphenopoly_Loader.js feature tests the browser for CSS-hyphenation support of the required languages using the long word.
+If the feature test indicates that the browser doesn't support CSS-hyphenation for at least one language, all necessary ressources will be loaded and Hyphenopoly.js gets executed.
+
+Use this to test support for every language used on the current page. If e.g. the language of the page is `lang="de-DE"` you must require `de-de` (case doesn't matter). For languages that aren't in the patterns directory a fallback must be defined (see below).
+
+To force the usage of Hyphenopoly.js (e.g. for testing or if you prefer to use your own patterns) the special keyword `"FORCEHYPHENOPOLY"` can be used as value. Note: Disable CSS-hyphenation while using `"FORCEHYPHENOPOLY"`.
+
+## Optional Fields
+### paths
+By default Hyphenopoly looks in `../Hyphenopoly/patterns/` for .hpb-files and in `../Hyphenopoly/` for other resources.
+
+These paths can be reconfigured:
+The `paths` field must be an object with two key-value-pairs:
+````javascript
+paths: {
+    "patterndir": "../patterns/", //path to the directory of pattern files
+    "maindir": "../" //path to the directory where the other ressources are stored
+}
+````
+
+### fallbacks
+
+In some cases a fallback-language need to be defined:
+  * patterns for a given language are not (yet) available but patterns of an other language can be used.
+  * the language on the webpage has a region tag.
+
+E.g. you'd like to use `en-gb` patterns for `en-au` and `de` for `de-DE`:
+
+````javascript
+const Hyphenopoly = {
+    require: {
+        "en-au": "FORCEHYPHENOPOLY", //or a long string
+        "de-DE": "FORCEHYPHENOPOLY"  //or a long string
+    },
+    fallbacks: {
+        "en-au": "en-gb",            //use en-gb for en-au
+        "de-DE": "de".               //use de for de-DE
+    },
+    setup: { ... }
+}
+````
+
+### cacheFeatureTests
+On the first run Hyphenopoly_Loader.js does the following feature tests:
+
+* Test if the client supports **WASM**
+* Test for each language in `Hyphenopoly.require` if the client supports **CSS-hyphenation**
+
+The result of these tests is stored in `Hyphenopoly.testResults`. Because these tests take 
+some time and may cause a reflow of the document, Hyphenopoly_Loader.js can store their
+result and retrieve these stored results for other pages in the same browsing session.
+
+The test results are stored in sessionStorage to assure that the tests are rerun when
+the browser occasionally gets updated.
+
+Because the law in some contries require a user opt-in or opt-out or whatever if you store
+data on the client, `cacheFeatureTests` is deactivated by default and has to be activated
+explicitely by hand in the [Hyphenopoly global object](./Global-Hyphenopoly-Object.md):
+````javascript
+const Hyphenopoly = {
+    "require": {...},
+    "cacheFeatureTests": true
+}
+````
+It's up to you to comply to the cookie-regulations of your country.
+
+### setup
+By default Hyphenopoly.js hyphenates elements with the classname `.hyphenate` and sets a FOUHC-timeout of 1000ms.
+
+#### selectors
+
+With selectors elements can be selected very precicely without the need of adding classes to the HTML. The selectors-object is a list of key-value-pairs where the key is a selector and the value is an object of settings specific to the selected elements.
+
+````javascript
+setup: {
+    selectors: {
+        "p": {}, // This selects all <p> elements for hyphenation with default settings
+        ".content, .title": { // This selects all elements with class .content and .title and sets minWordLength to 4 for these elements
+            minWordLength: 4
+        }
+    }
+}
+````
+See [CSS-Selectors on MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors) for a complete reference on CSS-Selectors.
+
+Note: There was a field called `classnames` in older versions of Hyphenopoly. `classnames` had been deprecated since v2.6.0 and are completly removed in v3.0.0 in favor of `selectors`.
+
+#### Optional fields in setup
+See [Setup](./Setup.md)
+
+### Events
+See [Events](./Events.md)
+
+### Hyphenate manually
+See [Hyphenators](./Hyphenators.md)
+
+### Unhyphenate
+To remove all hyphenation previously applied by Hyphenopoly call `Hyphenopoly.unhyphenate();`.
+
+## Putting it all together
+A typical init could look like this:
+````javascript
+const Hyphenopoly = {
+    require: {
+        "en-us": "supercalifragilisticexpialidocious"
+    },
+    setup: {
+        selectors: {
+            ".text": {}
+        }
+    },
+    handleEvent: {
+        error: function (e) {
+            e.preventDefault(); //don't show error messages in console
+        }
+    }
+}
+````
+
+## Internal Fields
+If you `console.dir(Hyphenopoly)` you'll see lots of other data that is internally used by Hyphenopoly_Loader.js and Hyphenopoly.js but isn't meant to be changed by the user.
+
+## Reclaim memory
+Hyphenopoly is quite hungry regarding to memory usage: for each language 2MB of wasm/asm memory are allocated. If you're done with Hyphenopoly you can set `window.Hyphenopoly = null` and leave it to the garbage collector to free the memory:
+
+````javascript
+handleEvent: {
+    hyphenopolyEnd: function (e) {
+        window.Hyphenopoly = null;
+    }
+}
+````
+See [Events](./Events.md) for more details about the `hyphenopolyEnd`-event.

static/lib/Hyphenopoly-master/docs/Hyphenators.md

@@ -0,0 +1,227 @@
+# Hyphenators
+While the main functionality of Hyphenopoly is to just hyphenate your HTML with no further ado, it is sometimes usefull to have a function at hand that hyphenates text.
+
+Possible usecases are:
+* dynamically loaded text
+* hyphenating text provided by the user (e.g. in a preview window of a blogging software)
+* …
+
+Up to version 2.4.0 the only way to hyphenate text after the page has loaded was to [dispatch a `contentLoaded`-Event](./Events.md#contentloaded-event) in order to restart the hyphenation process. This works but is a bit like using a sledgehammer to crack a nut, since the whole page is reprocessed.
+
+_Since Version 2.5.0 Hyphenopoly.js exposes `hyphenators` – language specific functions that hyphenates a string or a DOM-Object._
+
+## Create and access `Hyphenopoly.hyphenators`
+`hyphenators` are language specific functions that hyphenate their input.
+
+Hyphenopoly_Loader.js creates a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Using_promises) for a `hyphenator` for each language it loads (i.e. languages the UA doesn't support or languages you "FORCEHYPHENOPOLY"-ied).
+
+````html
+<script>
+    var Hyphenopoly = {
+        require: {
+            "en-us": "FORCEHYPHENOPOLY",
+            "de": "Silbentrennungsalgorithmus"
+        }
+    };
+</script>
+<script src="./Hyphenopoly_Loader.js"></script>
+<script>
+    console.log(Hyphenopoly.hyphenators); //{en-us: Promise}
+</script>
+````
+
+In the example above we enforced Hyphenopoly_Loader.js to use Hyphenopoly.js for `en-us`. Since the UA seems to support CSS3-hyphens for German, `Hyphenopoly.hyphenators` only contain a Promise for a `en-us`-hyphenator.
+
+## Use `Hyphenopoly.hyphenators` for Strings
+`hyphenators` are Promises. They are resolved as soon as everything necessary is loaded and ready (or rejected when something goes wrong). `hyphenators` resolve to a language specific function (a `hyphenator`) that hyphenates its input according to the settings for selectors (default: `.hyphenate`):
+
+`function hyphenator({string|DOM-Element}, [Optional: selector=".hyphenate"]) => {string|undefined}`
+
+````html
+<script>
+    var Hyphenopoly = {
+        require: {
+            "en-us": "FORCEHYPHENOPOLY",
+            "de": "Silbentrennungsalgorithmus"
+        },
+        paths: {
+            maindir: "../",
+            patterndir: "../patterns/"
+        },
+        setup: {
+            selectors: {
+                ".hyphenate": {
+                    hyphen: "•"
+                },
+                ".hyphenatePipe": {
+                    hyphen: "|"
+                }
+            }
+        }
+    };
+</script>
+<script src="./Hyphenopoly_Loader.js"></script>
+<script>
+    Hyphenopoly.hyphenators["en-us"].then((hyphenator_en) => {
+        console.log(hyphenator_en("Hyphenation")); //Hy•phen•ation
+        console.log(hyphenator_en("Hyphenation", ".hyphenatePipe")); //Hy|phen|ation
+    })
+</script>
+````
+
+In the example a `string` is handed over to the `hyphenator` which returns a hyphenated string according to the settings for the `selector`. If no `selector` is defined it defaults to `".hyphenate"`.
+
+## Use `Hyphenopoly.hyphenators` for DOM-Elements
+When handing over a HTMLELEMENT instead of a string `hyphenators` directly hyphenate the contents of a HTMLElement and return nothing (`undefined`).
+
+````html
+<html>
+<head>
+<script>
+    var Hyphenopoly = {
+        require: {
+            "en-us": "FORCEHYPHENOPOLY",
+            "de": "Silbentrennungsalgorithmus"
+        },
+        setup: {
+            selectors: {
+                ".hyphenate": {
+                    hyphen: "•"
+                }
+            }
+        }
+    };
+</script>
+<script src="./Hyphenopoly_Loader.js"></script>
+<script>
+    Hyphenopoly.hyphenators["en-us"].then((hyphenator_en) => {
+        hyphenator_en(document.getElementById("hyphenateme"));
+    });
+</script>
+</head>
+<body>
+    <div id="hyphenateme">Supercalifragilisticexpialidocious</div>
+<!--becomes -->
+<!--<div id="hyphenateme">Su•per•cal•ifrag•ilis•tic•ex•pi•ali•do•cious</div>-->
+</body>
+</html>
+````
+
+## Further notes and compatibility
+Instead of using `.then` on the Promises we could also use `async/await`:
+
+````javascript
+async function runHyphenator(id) {
+    (await Hyphenopoly.hyphenators["en-us"])(document.getElementById(id));
+}
+runHyphenator("hyphenateme");
+````
+
+If Promises are not supported by the browser an error is dispatched.
+
+All modern Browsers [support Promises](https://caniuse.com/#feat=promises) and the [`async/await`-syntax](https://caniuse.com/#feat=async-functions). If you need to support IE11 use a polyfill for promises (e.g. [taylorhakes/promise-polyfill](https://github.com/taylorhakes/promise-polyfill)) and stick to the `.then`-syntax.
+
+# Use case: Hyphenopoly in react
+`hyphenators` are very important in dynamically generated web-content (web-apps). The following describes some first steps in how to use Hyphenopoly in react-apps. Please note that I'm not an expert in react.js If you find a better way I'd highly appreciate your ideas.
+
+1. [download](https://github.com/mnater/Hyphenopoly/releases/latest) and copy the latest version of Hyphenopoly to your react's `public` folder.
+
+2. Configure `window.Hyphenopoly` and load `Hyphenopoly_Loader.js` in your react's index.html:
+
+````html
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8" />
+    <script>
+    //attach the global 'Hyphenopoly' object to window
+        window.Hyphenopoly = {
+            require: {
+                "en-us": "FORCEHYPHENOPOLY"
+            },
+            paths: {
+                maindir: "./hyphenopoly/",
+                patterndir: "./hyphenopoly/patterns/"
+            },
+            setup: {
+              selectors: {
+                ".hyphenate": {
+                  hyphen: "•"
+                }
+              }
+            },
+        }
+    </script>
+    <script src="./hyphenopoly/min/Hyphenopoly_Loader.js"></script>
+    <title>Use Hyphenopoly in React</title>
+  </head>
+  <body>
+    <!-- We will put our React component inside this div. -->
+    <div id="container"></div>
+
+    <!-- Load React. -->
+    <!-- Note: when deploying, replace "development.js" with "production.min.js". -->
+    <script src="https://unpkg.com/react@16/umd/react.production.min.js" crossorigin></script>
+    <script src="https://unpkg.com/react-dom@16/umd/react-dom.production.min.js" crossorigin></script>
+
+    <!-- Load our React component. -->
+    <script src="hyphenateText.js"></script>
+
+  </body>
+</html>
+````
+
+
+3. Define a `React.Component` that triggers Hyphenopoly (if necessary) on `componentDidUpdate`.
+
+`hyphenateText.js`:
+````javascript
+'use strict';
+
+const e = React.createElement;
+
+
+class Toggle extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = {isToggleOn: true};
+
+    // This binding is necessary to make `this` work in the callback
+    this.handleClick = this.handleClick.bind(this);
+  }
+
+  handleClick() {
+    this.setState(prevState => ({
+      isToggleOn: !prevState.isToggleOn
+    }));
+  }
+
+  componentDidUpdate(prevProps, prevState, snapshot) {
+    const el = this.el;
+    //if hyphenation is handled by CSS, Hyphenopoly is undefined
+    if (window.Hyphenopoly) {
+      window.Hyphenopoly.hyphenators["en-us"].then(
+        function (enHyphenator) {
+          enHyphenator(el);
+        }
+      );
+    }
+  }
+
+  render() {
+    return e(
+      "p",
+      {
+        class: "hyphenate",
+        onClick: () => this.handleClick(),
+        ref: el => this.el = el
+      },
+      this.state.isToggleOn ? "hyphenation" : "algorithm"
+    );
+  }
+}
+
+const domContainer = document.querySelector('#container');
+ReactDOM.render(e(Toggle), domContainer);
+````
+

static/lib/Hyphenopoly-master/docs/Node-Module.md

@@ -0,0 +1,155 @@
+# node.js module
+
+The Hyphenopoly-package contains a file called `hyphenopoly.module.js`.
+This module provides hyphenation for node.js applications.
+
+## Install
+
+````
+npm install hyphenopoly
+````
+
+## Usage
+
+One language:
+
+````javascript
+const Hyphenopoly = require("hyphenopoly");
+
+const textHyphenators = Hyphenopoly.config({
+    "require": ["en-us"],
+    "hyphen": "•"
+});
+
+textHyphenators.then(
+    function ff(hyphenateText) {
+        console.log(hyphenateText("Hyphenation enhances justification."));
+    }
+).catch(
+    function err(e) {
+        console.log(e);
+    }
+);
+````
+
+More then one language:
+
+````javascript
+const Hyphenopoly = require("hyphenopoly");
+
+const textHyphenators = Hyphenopoly.config({
+    "require": ["de", "en-us"],
+    "hyphen": "•"
+});
+
+textHyphenators.get("de").then(
+    function ff(hyphenateText) {
+        console.log(hyphenateText("Silbentrennung verbessert den Blocksatz."));
+    }
+);
+
+textHyphenators.get("en-us").then(
+    function ff(hyphenateText) {
+        console.log(hyphenateText("Hyphenation enhances justification."));
+    }
+);
+````
+
+## Synchronous mode
+
+By default, `Hyphenopoly.config` returns a promise (or a `Map` of promises). Some code bases are not yet capable of handling async code.
+By setting `"sync" : true` the hyphenopoly module switches to a sync mode.
+
+````javascript
+const hyphenopoly = require("hyphenopoly");
+
+const hyphenator = hyphenopoly.config({
+    "sync": true,
+    "require": ["de", "en-us"],
+    "hyphen": "•",
+    "exceptions": {
+        "en-us": "en-han-ces"
+    }
+});
+
+const hy1 = hyphenator.get("en-us")("hyphenation enhances justification.");
+const hy2 = hyphenator.get("de")("Silbentrennung verbessert den Blocksatz.");
+
+
+console.log(hy1);
+console.log(hy2);
+````
+
+## Configuration
+
+The `.config`-method takes an object as argument:
+
+Defaults:
+````javascript
+{
+    "compound": "hyphen",
+    "exceptions": {},
+    "hyphen": String.fromCharCode(173),
+    "leftmin": 0,
+    "loader": "fs",
+    "minWordLength": 6,
+    "mixedCase": true,
+    "normalize": false,
+    "orphanControl": 1,
+    "paths": {
+        "maindir": `${__dirname}/`,
+        "patterndir": `${__dirname}/patterns/
+    },
+    "require": [],
+    "rightmin": 0,
+    "sync": false
+}
+````
+
+The only option that Must be set is `require` which takes an array of language-tags.
+
+### loader
+By default hyphenopoly.module.js loads pattern files and hyphenEnginge by using nodes "fs"-module.
+This can be changed to the "http"-module by setting the `loader` to "http":
+````javascript
+const hyphenator = hyphenopoly.config({
+    "require": […],
+    "loader": "http"
+});
+
+````
+This is useful if the module is transformed to a script used in a webbrowser (e.g. by using [browserify](http://browserify.org)).
+
+### other options
+For documentation about the other options see the `Hyphenopoly.js`-documentation:
+
+- [compound](./Setup.md#compound)
+- [exceptions](./Setup.md#exceptions)
+- [hyphen](./Setup.md#hyphen)
+- [leftmin](./Setup.md#leftmin-and-rightmin)
+- [minWordLength](./Setup.md#minwordlength)
+- [mixedCase](./Setup.md#mixedcase)
+- [normalize](./Setup.md#normalize)
+- [orphanControl](./Setup.md#orphancontrol)
+- [paths](./Global-Hyphenopoly-Object.md#paths)
+- [rightmin](./Setup.md#leftmin-and-rightmin)
+
+## Supported languages (since Version 2.8.0)
+A list of supported languages can be programmatically obtained by looking at `Hyphenopoly.supportedLanguages`:
+````javascript
+const Hyphenopoly = require("hyphenopoly");
+Hyphenopoly.supportedLanguages.includes("en-us"); //true
+Hyphenopoly.supportedLanguages.includes("en"); //false
+````
+
+## Performance
+
+On my machine with node.js 10.0.1:
+
+| module        | setup         | hyphenate 100 de words |
+| ------------- | -------------:| ----------------------:|
+| _hyphenopoly_ | _12ms_        | _2ms_                  |
+| [hyphen](https://www.npmjs.com/package/hyphen)        | 40ms          | 370ms                  |
+| [hypher](https://www.npmjs.com/package/hypher)        | 70ms          | 3ms                    |
+
+

static/lib/Hyphenopoly-master/docs/Setup.md

@@ -0,0 +1,454 @@
+# optional fields in `setup`
+These page documents the optional fields in `setup`:
+* [Global Settings](#global-settings)
+  * [defaultLanguage](#defaultlanguage)
+  * [dontHyphenate](#donthyphenate)
+  * [dontHyphenateClass](#donthyphenateclass)
+  * [exceptions](#exceptions)
+  * [hide](#hide)
+  * [keepAlive](#keepalive)
+  * [normalize](#normalize)
+  * [safeCopy](#safecopy)
+  * [timeout](#timeout)
+* [Selector Based Settings](#selector-based-settings)
+  * [compound](#compound)
+  * [hyphen](#hyphen)
+  * [leftmin and rightmin](#leftmin-and-rightmin)
+  * [leftminPerLang and rightminPerLang](#leftminperlang-and-rightminperlang)
+  * [minWordLength](#minwordlength)
+  * [mixedCase](#mixedcase)
+  * [orphanControl](#orphancontrol)
+
+## Global Settings
+These settings apply to Hyphenopoly in general.
+
+### defaultLanguage
+````
+type: String
+default: "en-us"
+````
+Sets a fallback language in case no language is set in HTML.
+````html
+<script>
+var Hyphenopoly = {
+    require: {...},
+    paths: {...},
+    setup: {
+        defaultLanguage: "en-us",
+        selectors: {...}
+    }
+};
+</script>
+````
+To hyphenate a text its language needs to be known to the system (be it native CSS hyphenation or Hyphenopoly.js). Thus the language needs to be set in HTML either for the whole document (`<html lang="...">`) or on the elements.
+Hyphenopoly.js does a good job here: it searches for a `lang`-tag going up all the parentNodes of the DOM-tree and passes the language down to childNodes. But if no such tag can be found it needs `defaultLanguage`-fall back.
+
+_It's strongly recommended to set the language in HTML and use `defaultLanguage` only in cases where this wouldn't be possible!_
+
+### dontHyphenate
+````
+type: Object
+default: {
+    video: true,
+    audio: true,
+    script: true,
+    code: true,
+    pre: true,
+    img: true,
+    br: true,
+    samp: true,
+    kbd: true,
+    var: true,
+    abbr: true,
+    acronym: true,
+    sub: true,
+    sup: true,
+    button: true,
+    option: true,
+    label: true,
+    textarea: true,
+    input: true,
+    math: true,
+    svg: true,
+    style: true
+}
+````
+Elements in this list with a `true`-value and their contents are not hyphenated. Change the value to `false` or delete the line to change this.
+````html
+<script>
+var Hyphenopoly = {
+    require: [...],
+    paths: [...],
+    setup: {
+        dontHyphenate: {
+            video: true,
+            audio: true,
+            script: true,
+            code: true,
+            pre: true,
+            img: true,
+            br: true,
+            samp: true,
+            kbd: true,
+            var: true,
+            abbr: true,
+            acronym: true,
+            sub: true,
+            sup: true,
+            button: false, //<--
+            option: true,
+            label: true,
+            textarea: true,
+            input: true,
+            math: true,
+            svg: true,
+            style: true
+        },
+        selectors: {...}
+    }
+};
+</script>
+````
+
+### dontHyphenateClass
+````
+type: String
+default: "donthyphenate"
+````
+Elements with this class will not be hyphenated by Hyphenopoly.js
+````html
+<script>
+var Hyphenopoly = {
+    require: [...],
+    paths: [...],
+    setup: {
+        dontHyphenateClass: "donthyphenate",
+        selectors: {...}
+    }
+};
+</script>
+````
+Hyphenopoly.js hyphenates all elements that match the selectors defined in `selectors` – and it hyphenates their childElements unless they have the `dontHyphenateClass` set.
+````html
+<div class="hyphenate">
+    <p>This text will be hyphenated by default.</p>
+    <p>This will. <span class="donthyphenate">This will not</span> And this will…</p>
+</div>
+````
+
+### exceptions
+````
+type: Object
+default: undefined
+````
+Provide exceptions for hyphenation.
+````html
+<script>
+var Hyphenopoly = {
+    require: {...},
+    paths: {...},
+    setup: {
+        exceptions: {
+            "global": "FORTRAN", //excpetions for all languages
+            "en-us": "Web-Assembly, Java-Script" //language-specific exceptions
+        },
+        selectors: {...}
+    }
+};
+</script>
+````
+The exceptions object must contain language-codes as keys (or "global" for all languages). The values must be words separated by `,⎵` (comma, space), where a hyphen-minus marks the hyphenation points.
+If the word does not contain a hyphen, it will not be hyphenated by Hyphenopoly.js
+
+### hide
+````
+type: string ("all" | "element" | "text")
+default: "all"
+````
+Define if and how elements are made unvisible while being hyphenated.
+````html
+<script>
+var Hyphenopoly = {
+    require: {...},
+    paths: {...},
+    setup: {
+        hide: "element"
+    }
+};
+</script>
+````
+To prevent a flash of unhyphenated content (FOUHC) Hyphenopoly hides the elements being hyphenated. Depending on the structure of your page this can lead to visual flicker. You can change the way Hyphenopoly hides the content:
+
+- `all` hides the whole page by inserting the following CSS-rule `html {visibility: hidden !important}`
+- `element` hides the selected elements by inserting the following CSS-rule for each selector: `<selector> {visibility: hidden !important}`
+- `text` hides only the text of the selected elements by inserting the following CSS-rule for each selector: `<selector> {color: transparent !important}`
+- any other keyword prevents hiding.
+
+These CSS-rules are removed, when Hyphenopoly has finished its job or when the [timeout](#timeout) gets fired.
+
+### keepAlive
+````
+type: boolean
+default: true
+````
+Keeps object `window.Hyphenopoly` in memory to be accessible for further use (e.g. hyphenators). If Hyphenopoly is not used after initial run, it should be cleared to save memory.
+````html
+<script>
+var Hyphenopoly = {
+    require: {...},
+    paths: {...},
+    setup: {
+        keepAlive: false,
+        selectors: {...}
+    }
+};
+</script>
+````
+
+### normalize
+````
+type: boolean
+default: false
+````
+Normalize words before hyphenation.
+````html
+<script>
+var Hyphenopoly = {
+    require: {...},
+    paths: {...},
+    setup: {
+        normalize: true,
+        selectors: {...}
+    }
+};
+</script>
+````
+The pattern files work with _precomposed_ characters. So an `Å` (LATIN CAPITAL LETTER A WITH RING ABOVE) must not be composed of `A` (LATIN CAPITAL LETTER A) and ` ̊` (COMBINING RING ABOVE) to be recognizable by hyphenation-engine.
+If the text contains _composed_ characters they must be normalised to _precomposed_ characters. If `normalize` is activated and the user agent supports `String.prototype.normalize()` this can happen automatically.
+Since this comes with a performance penalty it is deactivated by default and it's recommended to use _precomposed_ characters in HTML.
+
+### safeCopy
+````
+type: boolean
+default: true
+````
+Removes soft hyphens from the clipboard.
+````html
+<script>
+var Hyphenopoly = {
+    require: {...},
+    paths: {...},
+    setup: {
+        safeCopy: true,
+        selectors: {...}
+    }
+};
+</script>
+````
+To prevent soft hyphens from beeing copied to the clipboard, Hyphenopoly.js registers a `onCopy`-Event on hyphenated elements. When text is copied to the clipboard, this event fires and soft hyphens are removed.
+_It does NOT remove other `hyphen`-characters!_
+This feature is on by default, but it's a hack – disable it if you don't like it.
+
+### timeout
+````
+type: number
+default: 1000
+````
+
+Sets a timeout in ms after which in case of a failure Hyphenopoly stops executing and unhides the text.
+````html
+<script>
+var Hyphenopoly = {
+    require: {...},
+    paths: {...},
+    setup: {
+        timeout: 1000,
+        selectors: {...}
+    }
+};
+</script>
+````
+To prevent a _Flash Of Unhyphenated Content (FOUHC)_ Hyphenopoly_Loader.js hides text to be hyphenated until hyphenation is done. If something goes wrong (e.g. a ressource didn't load correctly) this timeout saves us from an empty page. The timeout is cleared when hyphenation succeeds.
+If the timeout kicks in, the `onTimeOut`event is fired.
+
+See [hide](#hide) about different ways of hiding.
+
+## Selector Based Settings
+These settings can be set for each set of elements that are matched by the given selector.
+
+### compound
+````
+type: string ("auto" | "all" | "hyphen")
+default: "hyphen"
+````
+Define how compound words (words containing a hyphen) will be treated.
+````html
+<script>
+var Hyphenopoly = {
+    require: {...},
+    paths: {...},
+    setup: {
+        selectors: {
+            ".hyphenate": {
+                compound: "hyphen"
+            }
+        }
+    }
+};
+</script>
+````
+Not all browsers recognize the hyphen as a possible line-breaking spot. Thus we have to handle this.
+There are three possible values:
+
+**"auto":** leave the hyphen as it is and hyphenate the parts: `com|pu|ter-aid|ed`
+
+**"all":** hyphenate the parts and insert a zero-width space after the hyphen: `com|pu|ter-|aid|ed`
+
+**"hyphen":** don't hyphenate the parts but insert a zero-width space after the hyphen: `computer-|aided`
+
+### hyphen
+````
+type: String (a single character!)
+default: "\u00AD" (&shy; | &#173;)
+````
+The hyphen character.
+````html
+<script>
+var Hyphenopoly = {
+    require: {...},
+    paths: {...},
+    setup: {
+        selectors: {
+            ".hyphenate": {
+                hyphen: "\u00AD"
+            }
+        }
+    }
+};
+</script>
+````
+Can be set to something visible for testing and documentation.
+
+### leftmin and rightmin
+````
+type: number
+default: 0
+````
+Minimal number of characters before the first hyphenation point (leftmin). And minimal number of characters after the last hyphenation point (rightmin).
+````html
+<script>
+var Hyphenopoly = {
+    require: {...},
+    paths: {...},
+    setup: {
+        selectors: {
+            ".hyphenate": {
+                leftmin: 0,
+                rightmin: 0
+            }
+        }
+    }
+};
+</script>
+````
+Leftmin and rightmin are provided by the pattern-file but can be overwritten with larger values.
+If the value is smaller than the value from the pattern-file, it has no effect. `leftmin` and `rightmin` have an effect for the whole set of elements, disregarding the language of the subelements.
+
+### leftminPerLang and rightminPerLang:
+````
+type: object | 0
+default: 0
+````
+While `leftmin` and `rightmin` have an effect on all elements that are matched by the selector, `leftminPerLang` and `rightminPerLang` are language specific.
+````html
+<script>
+var Hyphenopoly = {
+    require: {...},
+    paths: {...},
+    setup: {
+        selectors: {
+            ".hyphenate": {
+                leftminPerLang: {
+                    "en-us": 3,
+                    "de": 4
+                }
+            }
+        }
+    }
+};
+</script>
+````
+If both (left-/rightmin and left-/rightminPerLanguage) are given, the highest value is respectively taken in account.
+
+### minWordLength
+````
+type: number
+default: 6
+````
+Minimal length of words to be hyphenated.
+````html
+<script>
+var Hyphenopoly = {
+    require: {...},
+    paths: {...},
+    setup: {
+        selectors: {
+            ".hyphenate": {
+                minWordLength: 6
+            }
+        }
+    }
+};
+</script>
+````
+
+### mixedCase
+````
+type: boolean
+default: true
+````
+If set to false, prevents hyphenation of mixed case words.
+````html
+<script>
+var Hyphenopoly = {
+    require: {...},
+    paths: {...},
+    setup: {
+        selectors: {
+            ".hyphenate": {
+                mixedCase: false
+            }
+        }
+    }
+};
+</script>
+````
+According to a [note in the css-text draft](https://drafts.csswg.org/css-text-3/#valdef-hyphens-auto)
+mixed case words may not be hyphenated. This setting defaults to true, because this simple heuristic
+excludes words at the beginning of a sentence from being hyphenated.
+
+### orphanControl
+````
+type: number (1 | 2 | 3)
+default: 1
+````
+Prevent [orphans](https://en.wikipedia.org/wiki/Widows_and_orphans)
+````html
+<script>
+var Hyphenopoly = {
+    require: {...},
+    paths: {...},
+    setup: {
+        selectors: {
+            ".hyphenate": {
+                orphanControl: 1
+            }
+        }
+    }
+};
+</script>
+````
+There are three stages:
+1. allow orphans
+2. don't hyphenate the last word of an element
+3. don't hyphenate the last word of an element and replace the space before with a no-breaking space

static/lib/Hyphenopoly-master/docs/Special-use-cases.md

@@ -0,0 +1,190 @@
+# Special use cases and how-to's
+
+1. [Browserify hyphenopoly.module.js](#browserify-hyphenopolymodulejs)
+2. [Webpack](#webpack)
+3. [Hyphenate depending on media queries](#hyphenate-depending-on-media-queries)
+4. [Set .focus() while Hyphenopoly is running](#set-focus-while-hyphenopoly-is-running)
+
+__Note: It's not recommended to use `hyphenopoly.module.js` in a browser environment. See e.g. [this guide](./Hyphenators.md#use-case-hyphenopoly-in-react) on how to use Hyphenopoly in react.__
+
+## Browserify hyphenopoly.module.js
+__Note: A browserifyed hyphenopoly.module.js is by far larger then the Hyphenopoly_Loader.js and Hyphenopoly.js scripts which are optimized for usage in browsers.__
+
+### Basic setup
+Create a npm project:
+````Shell
+npm init
+````
+
+Install browserify as devDependency
+````Shell
+npm install --save-dev browserify
+````
+
+Install hyphenopoly
+````Shell
+npm install hyphenopoly
+````
+
+Setup hyphenopoly in main.js. Make sure to set the loader to "http" since browserify will not shim the "fs" module:
+````javascript
+"use strict";
+
+const hyphenopoly = require("hyphenopoly");
+
+const hyphenator = hyphenopoly.config({
+    "require": ["de", "en-us"],
+    "paths": {
+        "maindir": "./node_modules/hyphenopoly/",
+        "patterndir": "./node_modules/hyphenopoly/patterns/"
+    },
+    "hyphen": "•",
+    "loader": "http"
+});
+
+async function hyphenate_en(text) {
+    const hyphenateText = await hyphenator.get("en-us");
+    console.log(hyphenateText(text));
+}
+
+async function hyphenate_de(text) {
+    const hyphenateText = await hyphenator.get("de");
+    console.log(hyphenateText(text));
+}
+
+hyphenate_en("hyphenation enhances justification.");
+hyphenate_de("Silbentrennung verbessert den Blocksatz.");
+````
+
+Transform the module
+````Shell
+browserify main.js -o bundle.js
+````
+This will generate the script-file `bundle.js`. Usage of a minifying tool (e.g. [tinyify](https://github.com/browserify/tinyify)) is recommended.
+
+_Note:_ Make sure the directories referenced in `paths` are available.
+
+## Webpack
+__Note: A webpacked hyphenopoly.module.js is by far larger then the Hyphenopoly_Loader.js and Hyphenopoly.js scripts which are optimized for usage in browsers.__
+
+Like `browserify` `webpack` will not shim "fs". Thus we have to tell `webpack` to shim the "fs" module with an empty object and configure `hyphenopoly` to use the "http"-loader.
+
+webpack.config.js
+````javascript
+module.exports = {
+  node: {
+    fs: "empty" //<- prevent "fs not found"
+  }
+};
+````
+
+index.js
+````javascript
+const hyphenopoly = require("hyphenopoly");
+
+const hyphenator = hyphenopoly.config({
+    "require": ["de", "en-us"],
+    "paths": {
+        "maindir": "../node_modules/hyphenopoly/",
+        "patterndir": "../node_modules/hyphenopoly/patterns/"
+    },
+    "hyphen": "•",
+    "loader": "http"
+});
+````
+
+## Hyphenate depending on media queries
+In CSS hyphenation can be restricted to special media-queries. If hyphenation on a website must be dependent of e.g. the width of the window and only active on small screens, you'd do somethink like this:
+````css
+@media (max-width: 600px) {
+    .hyphenate {
+        hyphens: auto;
+        -ms-hyphens: auto;
+        -moz-hyphens: auto;
+        -webkit-hyphens: auto;
+       }
+}
+@media (min-width: 601px) {
+    .hyphenate {
+        hyphens: none;
+        -ms-hyphens: none;
+        -moz-hyphens: none;
+        -webkit-hyphens: none;
+       }
+}
+````
+To polyfill hyphenation for browsers that don't support hyphenation (or don't support the required language) we'll have to tell Hyphenopoly to behave the same.
+
+The standard way to enable Hyphenopoly would just hyphenate, regardless of the screen-width. Well have to tell the browser to run Hyphenopoly_Loader.js only for small screens and react to changes of the screen width (e.g. when rotating a mobile device). Therefor, instead of including Hyphenopoly the standard way
+````html
+<script>
+var startTime;
+var Hyphenopoly = {
+    require: {
+        "en-us": "FORCEHYPHENOPOLY"
+    },
+    paths: {
+        maindir: "../",
+        patterndir: "../patterns/"
+    }
+};
+</script>
+<script src="../Hyphenopoly_Loader.js"></script>
+````
+
+ we'll define a `selectiveLoad` IIFE:
+
+````html
+<script>
+(function selectiveLoad() {
+    let H9YLisLoaded = false;
+    function handleSize(mql) {
+        if (mql.matches) { //i.e. if width <= 600px
+            if (H9YLisLoaded) {
+               window.Hyphenopoly.events.dispatch(
+                    "contentLoaded",
+                    {"msg": ["contentLoaded"]}
+                );
+            } else {
+                // Hyphenopoly isn't loaded yet, so load the Loader
+                // with the following settings:
+                window.Hyphenopoly = {
+                    require: {
+                        "en-us": "supercalifragilisticexpialidocious"
+                    },
+                    paths: {
+                        maindir: "../",
+                        patterndir: "../patterns/"
+                    },
+                    setup: {
+                        selectors: {
+                            ".hyphenate": {}
+                        }
+                    }
+                };
+                const loaderScript = document.createElement("script");
+                loaderScript.src = "../Hyphenopoly_Loader.js";
+                document.head.appendChild(loaderScript);
+                H9YLisLoaded = true;
+            }
+        } else { //i.e. if width > 600px
+            if (H9YLisLoaded) {
+                //remove hyphenation previously applied by Hyphenopoly
+                window.Hyphenopoly.unhyphenate();
+            }
+        }
+    }
+    // Create a Media-Query-List
+    const mql = window.matchMedia("(max-width: 600px)");
+    // Listen to changes
+    mql.addListener(handleSize);
+    // call handleSize on init
+    handleSize(mql);
+}());
+</script>
+````
+
+## Set .focus() while Hyphenopoly is running
+By default `Hyphenopoly_Loader.js` hides the whole document to prevent a "Flash of unhyphenated content" (FOUHC) until hyphenation has finished. If `focus()` is called while the document is hidden the focus will not change.
+
+To prevent this behavior experiment with [different settings for hiding](./Setup.md#hide). Using "element" or "text" should work in most cases.

static/lib/Hyphenopoly-master/docs/Usage-of-devDependencies.md

@@ -0,0 +1,56 @@
+# Usage of devDependencies
+Hyphenopoly has no dependencies for deployment but relies on other packages for development (devDependencies).
+
+## Clone and install devDependencies
+
+You need [git](https://git-scm.com/downloads) and [node.js with npm.js](https://nodejs.org/) installed on your system.
+
+### Clone repository from GitHub
+Use
+
+`git clone https://github.com/mnater/Hyphenopoly.git`
+
+to [clone](https://git-scm.com/docs/git-clone) the current development status (HEAD) of Hyphenopoly.js (this has the newest features, but is not fully tested).
+
+This will create a directory called `Hyphenopoly` in your current working directory containing all the files on the Hyphenopoly-GitHub-Repository. Those files are 'connected' to the repository: `git pull` will `fetch` and `merge` changes from the repository to the files in your directory.
+
+Use this to create pull-requests or to fork the repository.
+
+### Donwload tagged release
+
+While cloning gives you the most recent status, downloading a tagged release gives you a more thoughtfully tested (but never error free) version of Hyphenopoly.
+
+1. Go to [https://github.com/mnater/Hyphenopoly/releases/latest](https://github.com/mnater/Hyphenopoly/releases/latest) and download the package.
+2. Unpack the package.
+
+This will create a directory called `Hyphenopoly` in your current working directory containing all the files on the Hyphenopoly-GitHub-Repository. Those files are __NOT__ 'connected' to the repository (you can't do `git pull` and a like).
+
+Use this if you don't plan to make changes to Hyphenopoly that need to go upstream.
+
+### Install devDependencies
+In your `Hyphenopoly`-directory run `npm install`. This will install the devDependencies listed in the `package.json`-file to a directory called `node_modules`.
+
+This will install:
+* [eslint](https://eslint.org)
+* [eslint-plugin-security](https://github.com/nodesecurity/eslint-plugin-security)
+* [remark-cli](https://www.npmjs.com/package/remark-cli)
+* [remark-preset-lint-recommended](https://github.com/remarkjs/remark-lint/tree/master/packages/remark-preset-lint-recommended)
+* [tap](https://www.npmjs.com/package/tap)
+* [terser](https://github.com/fabiosantoscode/terser)
+
+and their dependencies.
+
+### Install 3rd-party software
+Some dependencies are not available on npm. Run `npm run-script install3rdparty`. This will install more tools in a directory called `third-party`.
+
+This will install and compile [binaryen](https://github.com/WebAssembly/binaryen).
+
+## Use the tools
+With the tools mentioned above installed you can run the following scripts:
+
+* `npm prepare` – recreates a minified subset of the files in the `min`-directory.
+* `npm test` – runs the tap tests for Hyphenopoly.module.js
+* `npm run testsuite` – opens a browser and runs the test suite
+* `npm run lint` – runs the linter on all .js files
+* `npm run compilewasm` - compiles `hyphenEngine.asm.js` to `hyphenEngine.wasm`
+* `npm run doc` – build and open documentation page locally

static/lib/Hyphenopoly-master/docs/_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-minimal

static/lib/Hyphenopoly-master/docs/index.md

@@ -0,0 +1,32 @@
+## In the browser – Hyphenopoly_Loader.js & Hyphenopoly.js
+* [Download for deployment](./Download,-install-and-setup-for-deployment.md)
+  * [Notes](./Download,-install-and-setup-for-deployment.md#general-notes)
+  * [GitHub](./Download,-install-and-setup-for-deployment.md#using-github)
+  * [npm](./Download,-install-and-setup-for-deployment.md#using-npmjs)
+* [Global Hyphenopoly Object](./Global-Hyphenopoly-Object.md)
+  * [Mandatory fields](./Global-Hyphenopoly-Object.md#mandatory-fields)
+    * [require](./Global-Hyphenopoly-Object.md#require)
+  * [Optional fields](./Global-Hyphenopoly-Object.md#optional-fields)
+    * [paths](./Global-Hyphenopoly-Object.md#paths)
+    * [setup](./Global-Hyphenopoly-Object.md#setup)
+    * [events](./Events.md)
+    * [cacheFeatureTests](./cacheFeatureTests.md)
+* [Optional fields in setup](./Setup.md)
+  * [Global Settings](./Setup.md#global-settings)
+  * [Selector Based Settings](./Setup.md#selector-based-settings)
+* [Events](./Events.md)
+* [Hyphenators](./Hyphenators.md)
+* [Hyphenation Errors](./Coping-with-hyphenation-errors.md)
+
+## In node.js – hyphenopoly.module.js
+* [hyphenopoly.module](./Node-Module.md)
+
+## Special use cases
+* [Browserify hyphenopoly.module.js](./Special-use-cases.md#browserify-hyphenopolymodulejs)
+* [Webpack](./Special-use-cases.md#webpack)
+* [Hyphenate depending on media queries](./Special-use-cases.md#hyphenate-depending-on-media-queries)
+* [Set .focus() while Hyphenopoly is running](./Special-use-cases.md#set-focus-while-hyphenopoly-is-running)
+
+## Develop
+* [Dev Tools (devDeps)](./Usage-of-devDependencies.md)
+* [Branching Model](./Branching-Model.md)

static/lib/Hyphenopoly-master/example.js

@@ -0,0 +1,27 @@
+// For RunKit:
+const hyphenopoly = require("hyphenopoly");
+
+
+// For local node:
+// const hyphenopoly = require("./hyphenopoly.module.js");
+
+const hyphenator = hyphenopoly.config({
+    "exceptions": {
+        "en-us": "en-han-ces"
+    },
+    "hyphen": "•",
+    "require": ["de", "en-us"]
+});
+
+async function hyphenateEn(text) {
+    const hyphenateText = await hyphenator.get("en-us");
+    console.log(hyphenateText(text));
+}
+
+async function hyphenateDe(text) {
+    const hyphenateText = await hyphenator.get("de");
+    console.log(hyphenateText(text));
+}
+
+hyphenateEn("hyphenation enhances justification.");
+hyphenateDe("Silbentrennung verbessert den Blocksatz.");

static/lib/Hyphenopoly-master/example1.html

@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta http-equiv="content-type" content="text/html; charset=UTF-8">
+        <title>Example 1</title>
+        <script>
+        var Hyphenopoly = {
+            require: {
+                "la": "honorificabilitudinitas",
+                "de": "Silbentrennungsalgorithmus",
+                "en-us": "Supercalifragilisticexpialidocious"
+            },
+            paths: {
+                patterndir: "./patterns/",
+                maindir: "./"
+            },
+            setup: {
+                selectors: {
+                    ".container": {}
+                }
+            }
+        };
+        </script>
+        <script src="./Hyphenopoly_Loader.js"></script>
+        <style type="text/css">
+            body {
+                width:60%;
+                margin-left:20%;
+            }
+            p {
+                text-align: justify;
+                margin: 0 2em 0 0;
+            }
+            .container {
+                display: flex;
+                hyphens: auto;
+                -ms-hyphens: auto;
+                -moz-hyphens: auto;
+                -webkit-hyphens: auto;
+            }
+        </style>
+    </head>
+    <body>
+        <h1>Example 1</h1>
+        <div class="container">
+            <p lang="la">Qua de causa Helvetii quoque reliquos Gallos virtute praecedunt, quod fere cotidianis proeliis cum Germanis contendunt, cum aut suis finibus eos prohibent aut ipsi in eorum finibus bellum gerunt.</p>
+            <p lang="en-us">For which reason the Helvetii also surpass the rest of the Gauls in valor, as they contend with the Germans in almost daily battles, when they either repel them from their own territories, or themselves wage war on their frontiers.</p>
+            <p lang="de">Aus diesem Grund übertreffen auch die Helvetier die übrigen Gallier an Tapferkeit, weil sie sich in fast täglichen Gefechten mit den Germanen messen, wobei sie diese entweder von ihrem Gebiet fernhalten oder selbst in deren Gebiet kämpfen.</p>
+        </div>
+    </body>
+</html>

static/lib/Hyphenopoly-master/exampleSync.js

@@ -0,0 +1,26 @@
+/* eslint-env node */
+/* eslint no-console: 0 */
+"use strict";
+// For RunKit:
+const hyphenopoly = require("hyphenopoly");
+
+/*
+ * For local node:
+ * const hyphenopoly = require("./hyphenopoly.module.js");
+ */
+
+const hyphenator = hyphenopoly.config({
+    "exceptions": {
+        "en-us": "en-han-ces"
+    },
+    "hyphen": "•",
+    "require": ["de", "en-us"],
+    "sync": true
+});
+
+const hy1 = hyphenator.get("en-us")("hyphenation enhances justification.");
+const hy2 = hyphenator.get("de")("Silbentrennung verbessert den Blocksatz.");
+
+
+console.log(hy1);
+console.log(hy2);

static/lib/Hyphenopoly-master/hyphenEngine.asm.js

@@ -0,0 +1,261 @@
+/**
+ * @license hyphenEngine.asm.js 3.4.0 - client side hyphenation for webbrowsers
+ * ©2019  Mathias Nater, Zürich (mathiasnater at gmail dot com)
+ * https://github.com/mnater/Hyphenopoly
+ *
+ * Released under the MIT license
+ * http://mnater.github.io/Hyphenopoly/LICENSE
+ */
+/* eslint-disable */
+function asmHyphenEngine(std, x, heap) {
+    "use asm";
+    var ui8 = new std.Uint8Array(heap);
+    var ui16 = new std.Uint16Array(heap);
+    var i32 = new std.Int32Array(heap);
+    var imul = std.Math.imul;
+
+    var to = x.to | 0;
+    var po = x.po | 0;
+    var pl = x.pl | 0;
+    var vs = x.vs | 0;
+    var pt = x.pt | 0;
+    var wo = x.wo | 0;
+    var tw = x.tw | 0;
+    var hp = x.hp | 0;
+    var hw = x.hw | 0;
+
+    function hashCharCode(cc) {
+        //maps BMP-charCode (16bit) to 8bit adresses
+        //{0, 1, 2, ..., 2^16 - 1} -> {0, 1, 2, ..., 2^8 - 1}
+        //collisions will occur!
+        cc = cc | 0;
+        var h = 0;
+        h = imul(cc, 40503); // 2^16 (-1 + sqrt(5)) / 2 = 40’503.475...
+        h = h & 255; //mask 8bits
+        return h << 1;
+    }
+
+    function pushToTranslateMap(cc, id) {
+        cc = cc | 0;
+        id = id | 0;
+        var addr = 0;
+        addr = hashCharCode(cc | 0) | 0;
+        while ((ui16[addr >> 1] | 0) != 0) {
+            addr = (addr + 2) | 0;
+        }
+        ui16[addr >> 1] = cc;
+        ui8[((addr >> 1) + 512) | 0] = id;
+    }
+
+    function pullFromTranslateMap(cc) {
+        cc = cc | 0;
+        var addr = 0;
+        addr = hashCharCode(cc) | 0;
+        while ((ui16[addr >> 1] | 0) != (cc | 0)) {
+            addr = (addr + 2) | 0;
+            if ((addr | 0) >= 512) {
+                return 255;
+            }
+        }
+        return ui8[((addr >> 1) + 512) | 0] | 0;
+    }
+
+
+    function createTranslateMap() {
+        var i = 0;
+        var k = 0;
+        var first = 0;
+        var second = 0;
+        var secondInt = 0;
+        var alphabetCount = 0;
+        i = (to + 2) | 0;
+        while ((i | 0) < (po | 0)) {
+            first = ui16[i >> 1] | 0;
+            second = ui16[(i + 2) >> 1] | 0;
+            if ((second | 0) == 0) {
+                secondInt = 255;
+            } else {
+                secondInt = pullFromTranslateMap(second) | 0;
+            }
+            if ((secondInt | 0) == 255) {
+                //there's no such char yet in the TranslateMap
+                pushToTranslateMap(first, k);
+                if ((second | 0) != 0) {
+                    //set upperCase representation
+                    pushToTranslateMap(second, k);
+                }
+                k = (k + 1) | 0;
+            } else {
+                //char is already in TranslateMap -> SUBSTITUTION
+                pushToTranslateMap(first, secondInt);
+            }
+            //add to alphabet
+            ui16[(768 + (alphabetCount << 1)) >> 1] = first;
+            alphabetCount = (alphabetCount + 1) | 0;
+            i = (i + 4) | 0;
+        }
+        return alphabetCount | 0;
+    }
+
+    function convert() {
+        var i = 0;
+        var charAti = 0;
+        var plen = 0;
+        var count = 0;
+        var nextRowStart = 0;
+        var trieNextEmptyRow = 0;
+        var rowStart = 0;
+        var rowOffset = 0;
+        var valueStoreStartIndex = 0;
+        var valueStoreCurrentIdx = 0;
+        var valueStorePrevIdx = 0;
+        var alphabetlength = 0;
+        var first = 0;
+        var second = 0;
+        var trieRowLength = 0;
+        trieRowLength = ((ui16[to >> 1] << 1) + 1) << 2;
+        nextRowStart = pt;
+        trieNextEmptyRow = pt;
+        rowStart = pt;
+        valueStoreStartIndex = vs;
+        valueStoreCurrentIdx = vs;
+        valueStorePrevIdx = vs;
+
+        alphabetlength = createTranslateMap() | 0;
+        i = po | 0;
+        while ((i | 0) < (po + pl | 0)) {
+            if ((ui8[i | 0] | 0) == 0) {
+                plen = ui8[(i + 1) | 0] | 0;
+                i = (i + 2) | 0;
+            } else {
+                if ((ui8[i | 0] | 0) == 255) {
+                    first = ui8[(i + 1) | 0] | 0;
+                    second = ui8[(i + 2) | 0] | 0;
+                    i = (i + 3) | 0;
+                }
+                while ((count | 0) < (plen | 0)) {
+                    if ((count | 0) == 0) {
+                        charAti = first;
+                    } else if ((count | 0) == 1) {
+                        charAti = second;
+                    } else {
+                        charAti = ui8[i | 0] | 0;
+                        i = (i + 1) | 0;
+                    }
+                    if ((charAti | 0) > 11) {
+                        valueStoreCurrentIdx = (valueStoreCurrentIdx + 1) | 0;
+                        if ((nextRowStart | 0) == 0) {
+                            //start a new row
+                            trieNextEmptyRow = trieNextEmptyRow + trieRowLength | 0;
+                            nextRowStart = trieNextEmptyRow;
+                            i32[(rowStart + rowOffset) >> 2] = nextRowStart;
+                        }
+                        rowOffset = ((charAti - 12) | 0) << 3;
+                        rowStart = nextRowStart;
+                        nextRowStart = i32[(rowStart + rowOffset) >> 2] | 0;
+                    } else {
+                        ui8[valueStoreCurrentIdx | 0] = charAti | 0;
+                        valueStorePrevIdx = valueStoreCurrentIdx;
+                    }
+                    count = (count + 1) | 0;
+                }
+//terminate valueStore and save link to valueStoreStartIndex
+                ui8[(valueStorePrevIdx + 1) | 0] = 255; //mark end of pattern
+                i32[(rowStart + rowOffset + 4) >> 2] = valueStoreStartIndex | 0;
+//reset indizes
+                valueStoreStartIndex = (valueStorePrevIdx + 2) | 0;
+                valueStoreCurrentIdx = valueStoreStartIndex;
+                count = 0;
+                rowStart = pt;
+                nextRowStart = pt;
+            }
+        }
+        return alphabetlength | 0;
+    }
+
+    function hyphenate(lm, rm, hc) {
+        lm = lm | 0;
+        rm = rm | 0;
+        hc = hc | 0;
+        var patternStartPos = 0;
+        var wordLength = 0;
+        var charOffset = 0;
+        var cc = 0;
+        var row = 0;
+        var rowOffset2 = 0;
+        var link = 0;
+        var value = 0;
+        var hyphenPointsCount = 0;
+        var hyphenPoint = 0;
+        var hpPos = 0;
+        var translatedChar = 0;
+
+        //translate UTF16 word to internal ints and clear hpPos-Array
+        cc = ui16[wo >> 1] | 0;
+        while ((cc | 0) != 0) {
+            translatedChar = pullFromTranslateMap(cc | 0) | 0;
+            if ((translatedChar | 0) == 255) {
+                return 0;
+            }
+            ui8[(tw + charOffset) | 0] = translatedChar | 0;
+            charOffset = (charOffset + 1) | 0;
+            ui8[(hp + charOffset) | 0] = 0;
+            cc = ui16[(wo + (charOffset << 1)) >> 1] | 0;
+        }
+        //find patterns and collect hyphenPoints
+        wordLength = charOffset;
+        while ((patternStartPos | 0) < (wordLength | 0)) {
+            row = pt;
+            charOffset = patternStartPos | 0;
+            while ((charOffset | 0) < (wordLength | 0)) {
+                rowOffset2 = ui8[(tw + charOffset) | 0] << 3;
+                link = i32[(row + rowOffset2) >> 2] | 0;
+                value = i32[(row + rowOffset2 + 4) >> 2] | 0;
+                if ((value | 0) > 0) {
+                    hyphenPointsCount = 0;
+                    hyphenPoint = ui8[value | 0] | 0;
+                    while ((hyphenPoint | 0) != 255) {
+                        hpPos = (hp + patternStartPos + hyphenPointsCount) | 0;
+                        if ((hyphenPoint | 0) > (ui8[hpPos | 0] | 0)) {
+                            ui8[hpPos | 0] = hyphenPoint | 0;
+                        }
+                        hyphenPointsCount = (hyphenPointsCount + 1) | 0;
+                        hyphenPoint = ui8[(value + hyphenPointsCount) | 0] | 0;
+                    }
+                }
+                if ((link | 0) > 0) {
+                    row = link | 0;
+                } else {
+                    break;
+                }
+                charOffset = (charOffset + 1) | 0;
+            }
+            patternStartPos = (patternStartPos + 1) | 0;
+        }
+
+        //get chars of original word and insert hyphenPoints
+        charOffset = 1;
+        hyphenPointsCount = 0;
+        wordLength = (wordLength - 2) | 0;
+        while ((charOffset | 0) <= (wordLength | 0)) {
+            ui16[(hw + (charOffset << 1) + hyphenPointsCount) >> 1] = ui16[(wo + (charOffset << 1)) >> 1] | 0;
+            if (
+                (((charOffset | 0) >= (lm | 0)) | 0) &
+                (((charOffset | 0) <= ((wordLength - rm) | 0)) | 0)
+            ) {
+                if (ui8[(hp + charOffset + 1) | 0] & 1) {
+                    hyphenPointsCount = (hyphenPointsCount + 2) | 0;
+                    ui16[(hw + (charOffset << 1) + hyphenPointsCount) >> 1] = hc;
+                }
+            }
+            charOffset = (charOffset + 1) | 0;
+        }
+        ui16[hw >> 1] = (wordLength + (hyphenPointsCount >> 1)) | 0;
+        return 1;
+    }
+
+    return {
+        convert: convert,
+        hyphenate: hyphenate
+    };
+}

static/lib/Hyphenopoly-master/hyphenopoly.module.js

@@ -0,0 +1,888 @@
+/**
+ * @license Hyphenopoly.module.js 3.4.0 - hyphenation for node
+ * ©2018  Mathias Nater, Zürich (mathiasnater at gmail dot com)
+ * https://github.com/mnater/Hyphenopoly
+ *
+ * Released under the MIT license
+ * http://mnater.github.io/Hyphenopoly/LICENSE
+ */
+
+/* eslint-env node */
+"use strict";
+
+/*
+ * Use 'fs' in node environment and fallback to http if the module gets executed
+ * in a browser environment (e.g. browserified)
+ */
+let loader = require("fs");
+
+const {StringDecoder} = require("string_decoder");
+
+const decode = (function makeDecoder() {
+    const utf16ledecoder = new StringDecoder("utf-16le");
+    return function dec(ui16) {
+        return utf16ledecoder.write(Buffer.from(ui16));
+    };
+}());
+
+/**
+ * Create Object without standard Object-prototype
+ * @returns {Object} empty object
+ */
+function empty() {
+    return Object.create(null);
+}
+
+/**
+ * Set value and properties of object member
+ * Argument <props> is a bit pattern:
+ * 1. bit: configurable
+ * 2. bit: enumerable
+ * 3. bit writable
+ * e.g. 011(2) = 3(10) => configurable: f, enumerable: t, writable: t
+ * or   010(2) = 2(10) => configurable: f, enumerable: t, writable: f
+ * @param {any} val The value
+ * @param {number} props bitfield
+ * @returns {Object} Property object
+ */
+function setProp(val, props) {
+    /* eslint-disable no-bitwise, sort-keys */
+    return {
+        "configurable": (props & 4) > 0,
+        "enumerable": (props & 2) > 0,
+        "writable": (props & 1) > 0,
+        "value": val
+    };
+    /* eslint-enable no-bitwise, sort-keys */
+}
+
+const H = empty();
+H.binaries = new Map();
+
+H.supportedLanguages = [
+    "af",
+    "as",
+    "be",
+    "bg",
+    "bn",
+    "ca",
+    "cs",
+    "cy",
+    "da",
+    "de",
+    "el-monoton",
+    "el-polyton",
+    "en-gb",
+    "en-us",
+    "eo",
+    "es",
+    "et",
+    "eu",
+    "fi",
+    "fr",
+    "fur",
+    "ga",
+    "gl",
+    "grc",
+    "gu",
+    "hi",
+    "hr",
+    "hsb",
+    "hu",
+    "hy",
+    "ia",
+    "id",
+    "is",
+    "it",
+    "ka",
+    "kmr",
+    "kn",
+    "la-x-liturgic",
+    "la",
+    "lt",
+    "lv",
+    "ml",
+    "mn-cyrl",
+    "mr",
+    "mul-ethi",
+    "nb-no",
+    "nl",
+    "nn",
+    "oc",
+    "or",
+    "pa",
+    "pl",
+    "pms",
+    "pt",
+    "rm",
+    "ro",
+    "ru",
+    "sh-cyrl",
+    "sh-latn",
+    "sk",
+    "sl",
+    "sr-cyrl",
+    "sv",
+    "ta",
+    "te",
+    "th",
+    "tk",
+    "tr",
+    "uk",
+    "zh-latn-pinyin"
+];
+
+/**
+ * Read a file and call callback
+ * Use "fs" (node) or "http" (browser)
+ * @param {string} file - the filename
+ * @param {function} cb - callback function with args (error, data)
+ * @returns {undefined}
+ */
+function readFile(file, cb, sync) {
+    if (H.c.loader === "fs") {
+        /* eslint-disable security/detect-non-literal-fs-filename */
+        if (sync) {
+            // eslint-disable-next-line no-sync
+            return loader.readFileSync(file);
+        }
+        loader.readFile(file, cb);
+        /* eslint-enable security/detect-non-literal-fs-filename */
+    } else {
+        loader.get(file, function onData(res) {
+            const rawData = [];
+            res.on("data", function onChunk(chunk) {
+                rawData.push(chunk);
+            });
+            res.on("end", function onEnd() {
+                cb(null, Buffer.concat(rawData));
+            });
+        });
+    }
+    return null;
+}
+
+/**
+ * Read a wasm file, dispatch "engineLoaded" on success
+ * @returns {undefined}
+ */
+function loadWasm() {
+    if (H.c.sync) {
+        const data = readFile(`${H.c.paths.maindir}hyphenEngine.wasm`, null, true);
+        H.binaries.set("hyphenEngine", new Uint8Array(data).buffer);
+        H.events.dispatch("engineLoaded");
+    } else {
+        readFile(
+            `${H.c.paths.maindir}hyphenEngine.wasm`,
+            function cb(err, data) {
+                if (err) {
+                    H.events.dispatch("error", {
+                        "key": "hyphenEngine",
+                        "msg": `${H.c.paths.maindir}hyphenEngine.wasm not found.`
+                    });
+                } else {
+                    H.binaries.set("hyphenEngine", new Uint8Array(data).buffer);
+                    H.events.dispatch("engineLoaded");
+                }
+            },
+            false
+        );
+    }
+}
+
+/**
+ * Read a hpb file, dispatch "hpbLoaded" on success
+ * @param {string} lang - The language
+ * @returns {undefined}
+ */
+function loadHpb(lang) {
+    if (H.c.sync) {
+        const data = readFile(`${H.c.paths.patterndir}${lang}.hpb`, null, true);
+        H.binaries.set(lang, new Uint8Array(data).buffer);
+        H.events.dispatch("hpbLoaded", {"msg": lang});
+    } else {
+        readFile(
+            `${H.c.paths.patterndir}${lang}.hpb`,
+            function cb(err, data) {
+                if (err) {
+                    H.events.dispatch("error", {
+                        "key": lang,
+                        "msg": `${H.c.paths.patterndir}${lang}.hpb not found.`
+                    });
+                } else {
+                    H.binaries.set(lang, new Uint8Array(data).buffer);
+                    H.events.dispatch("hpbLoaded", {"msg": lang});
+                }
+            },
+            false
+        );
+    }
+}
+
+/**
+ * Calculate heap size for wasm
+ * wasm page size: 65536 = 64 Ki
+ * @param {number} targetSize The targetet Size
+ * @returns {number} The necessary heap size
+ */
+function calculateHeapSize(targetSize) {
+    return Math.ceil(targetSize / 65536) * 65536;
+}
+
+/**
+ * Calculate Base Data
+ *
+ * Build Heap (the heap object's byteLength must be
+ * either 2^n for n in [12, 24)
+ * or 2^24 · n for n ≥ 1;)
+ *
+ * MEMORY LAYOUT:
+ *
+ * -------------------- <- Offset 0
+ * |   translateMap   |
+ * |        keys:     |
+ * |256 chars * 2Bytes|
+ * |         +        |
+ * |      values:     |
+ * |256 chars * 1Byte |
+ * -------------------- <- 768 Bytes
+ * |     alphabet     |
+ * |256 chars * 2Bytes|
+ * -------------------- <- valueStoreOffset (vs) = 1280
+ * |    valueStore    |
+ * |      1 Byte      |
+ * |* valueStoreLength|
+ * --------------------
+ * | align to 4Bytes  |
+ * -------------------- <- patternTrieOffset (pt)
+ * |    patternTrie   |
+ * |     4 Bytes      |
+ * |*patternTrieLength|
+ * -------------------- <- wordOffset (wo)
+ * |    wordStore     |
+ * |    Uint16[64]    | 128 bytes
+ * -------------------- <- translatedWordOffset (tw)
+ * | transl.WordStore |
+ * |    Uint8[64]     | 64 bytes
+ * -------------------- <- hyphenPointsOffset (hp)
+ * |   hyphenPoints   |
+ * |    Uint8[64]     | 64 bytes
+ * -------------------- <- hyphenatedWordOffset (hw)
+ * |  hyphenatedWord  |
+ * |   Uint16[128]    | 256 Bytes
+ * -------------------- <- hpbOffset (ho)      -
+ * |     HEADER       |                        |
+ * |    6*4 Bytes     |                        |
+ * |    24 Bytes      |                        |
+ * --------------------                        |
+ * |    PATTERN LIC   |                        |
+ * |  variable Length |                        |
+ * --------------------                        |
+ * | align to 4Bytes  |                        } this is the .hpb-file
+ * -------------------- <- hpbTranslateOffset  |
+ * |    TRANSLATE     |                        |
+ * | 2 + [0] * 2Bytes |                        |
+ * -------------------- <-hpbPatternsOffset(po)|
+ * |     PATTERNS     |                        |
+ * |  patternsLength  |                        |
+ * -------------------- <- heapEnd             -
+ * | align to 4Bytes  |
+ * -------------------- <- heapSize (hs)
+ * @param {Object} hpbBuf FileBuffer from .hpb-file
+ * @returns {Object} baseData-object
+ */
+function calculateBaseData(hpbBuf) {
+    const hpbMetaData = new Uint32Array(hpbBuf).subarray(0, 8);
+    const valueStoreLength = hpbMetaData[7];
+    const valueStoreOffset = 1280;
+    const patternTrieOffset = valueStoreOffset + valueStoreLength +
+        (4 - ((valueStoreOffset + valueStoreLength) % 4));
+    const wordOffset = patternTrieOffset + (hpbMetaData[6] * 4);
+    return {
+        // Set hpbOffset
+        "ho": wordOffset + 512,
+        // Set hyphenPointsOffset
+        "hp": wordOffset + 192,
+        // Set heapSize
+        "hs": Math.max(calculateHeapSize(wordOffset + 512 + hpbMetaData[2] + hpbMetaData[3]), 32 * 1024 * 64),
+        // Set hyphenatedWordOffset
+        "hw": wordOffset + 256,
+        // Set leftmin
+        "lm": hpbMetaData[4],
+        // Set patternsLength
+        "pl": hpbMetaData[3],
+        // Set hpbPatternsOffset
+        "po": wordOffset + 512 + hpbMetaData[2],
+        // Set patternTrieOffset
+        "pt": patternTrieOffset,
+        // Set rightmin
+        "rm": hpbMetaData[5],
+        // Set translateOffset
+        "to": wordOffset + 512 + hpbMetaData[1],
+        // Set translatedWordOffset
+        "tw": wordOffset + 128,
+        // Set valueStoreOffset
+        "vs": valueStoreOffset,
+        // Set wordOffset
+        "wo": wordOffset
+    };
+}
+
+/**
+ * Convert exceptions to Map
+ * @param {string} exc comma separated list of exceptions
+ * @returns {Object} Map of exceptions
+ */
+function convertExceptions(exc) {
+    const r = new Map();
+    exc.split(", ").forEach(function eachExc(e) {
+        const key = e.replace(/-/g, "");
+        r.set(key, e);
+    });
+    return r;
+}
+
+/**
+ * Create lang Object
+ * @param {string} lang The language
+ * @returns {Object} The newly created lang object
+ */
+function createLangObj(lang) {
+    if (!H.languages) {
+        H.languages = new Map();
+    }
+    if (!H.languages.has(lang)) {
+        H.languages.set(lang, empty());
+    }
+    return H.languages.get(lang);
+}
+
+/**
+ * Setup a language object (lo) and dispatch "engineReady"
+ * @param {string} lang The language
+ * @param {function} hyphenateFunction The hyphenateFunction
+ * @param {string} alphabet List of used characters
+ * @param {number} leftmin leftmin
+ * @param {number} rightmin rightmin
+ * @returns {undefined}
+ */
+function prepareLanguagesObj(
+    lang,
+    hyphenateFunction,
+    alphabet,
+    leftmin,
+    rightmin
+) {
+    alphabet = alphabet.replace(/-/g, "");
+    const lo = createLangObj(lang);
+    if (!lo.engineReady) {
+        lo.cache = new Map();
+        /* eslint-disable security/detect-object-injection */
+        if (H.c.exceptions.global) {
+            if (H.c.exceptions[lang]) {
+                H.c.exceptions[lang] += `, ${H.c.exceptions.global}`;
+            } else {
+                H.c.exceptions[lang] = H.c.exceptions.global;
+            }
+        }
+        if (H.c.exceptions[lang]) {
+            lo.exceptions = convertExceptions(H.c.exceptions[lang]);
+            delete H.c.exceptions[lang];
+        } else {
+            lo.exceptions = new Map();
+        }
+        /* eslint-enable security/detect-object-injection */
+        /* eslint-disable security/detect-non-literal-regexp */
+        lo.genRegExp = new RegExp(`[\\w${alphabet}${String.fromCharCode(8204)}-]{${H.c.minWordLength},}`, "gi");
+        /* eslint-enable security/detect-non-literal-regexp */
+        lo.leftmin = leftmin;
+        lo.rightmin = rightmin;
+        lo.hyphenateFunction = hyphenateFunction;
+        lo.engineReady = true;
+    }
+    H.events.dispatch("engineReady", {"msg": lang});
+}
+
+/**
+ * Setup env for hyphenateFunction
+ * @param {Object} baseData baseData
+ * @param {function} hyphenateFunc hyphenateFunction
+ * @returns {function} hyphenateFunction with closured environment
+ */
+function encloseHyphenateFunction(baseData, hyphenateFunc) {
+    /* eslint-disable no-bitwise */
+    const heapBuffer = baseData.wasmMemory.buffer;
+    const wordStore = (new Uint16Array(heapBuffer)).subarray(
+        baseData.wo >> 1,
+        (baseData.wo >> 1) + 64
+    );
+    const hyphenatedWordStore = (new Uint16Array(heapBuffer)).subarray(
+        baseData.hw >> 1,
+        (baseData.hw >> 1) + 128
+    );
+    /* eslint-enable no-bitwise */
+    const defLeftmin = baseData.lm;
+    const defRightmin = baseData.rm;
+
+    /**
+     * The hyphenateFunction that encloses the env above
+     * Copies the word to wasm-Memory, calls wasm.hyphenateFunc and reads
+     * the hyphenated word from wasm-Memory (eventually replacing hyphenchar)
+     * @param {String} word - the word that has to be hyphenated
+     * @param {String} hyphenchar – the hyphenate character
+     * @param {Number} leftmin – min number of chars to remain on line
+     * @param {Number} rightmin – min number of chars to go to new line
+     * @returns {String} the hyphenated word
+     */
+    wordStore[0] = 95;
+    return function enclHyphenate(word, hyphencc, leftmin, rightmin) {
+        leftmin = leftmin || defLeftmin;
+        rightmin = rightmin || defRightmin;
+        let i = 0;
+        let cc = 0;
+        do {
+            cc = word.charCodeAt(i);
+            i += 1;
+            // eslint-disable-next-line security/detect-object-injection
+            wordStore[i] = cc;
+        } while (cc);
+        /* eslint-disable security/detect-object-injection */
+        wordStore[i] = 95;
+        wordStore[i + 1] = 0;
+        if (hyphenateFunc(leftmin, rightmin, hyphencc) === 1) {
+            word = String.fromCharCode.apply(
+                null,
+                hyphenatedWordStore.subarray(
+                    1,
+                    hyphenatedWordStore[0] + 1
+                )
+            );
+        }
+        return word;
+    };
+}
+
+/**
+ * Instantiate Wasm Engine, then compute the pattern trie and
+ * call prepareLanguagesObj.
+ * @param {string} lang The language
+ * @returns {undefined}
+ */
+function instantiateWasmEngine(lang) {
+    const baseData = calculateBaseData(H.binaries.get(lang));
+    const wasmMemory = new WebAssembly.Memory({
+        "initial": baseData.hs / 65536,
+        "maximum": 256
+    });
+    const ui32wasmMemory = new Uint32Array(wasmMemory.buffer);
+    ui32wasmMemory.set(
+        new Uint32Array(H.binaries.get(lang)),
+        // eslint-disable-next-line no-bitwise
+        baseData.ho >> 2
+    );
+    baseData.wasmMemory = wasmMemory;
+    const importObj = {
+        "env": {
+            "memory": baseData.wasmMemory,
+            "memoryBase": 0
+        },
+        "x": baseData
+    };
+    if (H.c.sync) {
+        const heInstance = new WebAssembly.Instance(
+            new WebAssembly.Module(H.binaries.get("hyphenEngine")),
+            importObj
+        );
+        heInstance.exports.convert();
+        prepareLanguagesObj(
+            lang,
+            encloseHyphenateFunction(
+                baseData,
+                heInstance.exports.hyphenate
+            ),
+            decode(
+                (new Uint8Array(wasmMemory.buffer)).
+                    subarray(768, 1280)
+            ),
+            baseData.lm,
+            baseData.rm
+        );
+    } else {
+        WebAssembly.instantiate(H.binaries.get("hyphenEngine"), importObj).then(
+            function runWasm(result) {
+                result.instance.exports.convert();
+                prepareLanguagesObj(
+                    lang,
+                    encloseHyphenateFunction(
+                        baseData,
+                        result.instance.exports.hyphenate
+                    ),
+                    decode(
+                        (new Uint8Array(wasmMemory.buffer)).
+                            subarray(768, 1280)
+                    ),
+                    baseData.lm,
+                    baseData.rm
+                );
+            }
+        );
+    }
+}
+
+
+let engineInstantiator = null;
+const hpb = [];
+
+/**
+ * Instantiate hyphenEngines for languages
+ * @param {string} lang The language
+ * @returns {undefined}
+ */
+function prepare(lang) {
+    if (lang === "*") {
+        engineInstantiator = instantiateWasmEngine;
+        hpb.forEach(function eachHbp(hpbLang) {
+            engineInstantiator(hpbLang);
+        });
+    } else if (engineInstantiator) {
+        engineInstantiator(lang);
+    } else {
+        hpb.push(lang);
+    }
+}
+
+const wordHyphenatorPool = new Map();
+
+/**
+ * Factory for hyphenatorFunctions for a specific language and class
+ * @param {Object} lo Language-Object
+ * @param {string} lang The language
+ * @returns {function} The hyphenate function
+ */
+function createWordHyphenator(lo, lang) {
+    /**
+     * HyphenateFunction for compound words
+     * @param {string} word The word
+     * @returns {string} The hyphenated compound word
+     */
+    function hyphenateCompound(word) {
+        const zeroWidthSpace = String.fromCharCode(8203);
+        let parts = null;
+        let wordHyphenator = null;
+        if (H.c.compound === "auto" ||
+            H.c.compound === "all") {
+            wordHyphenator = createWordHyphenator(lo, lang);
+            parts = word.split("-").map(function h7eParts(p) {
+                if (p.length >= H.c.minWordLength) {
+                    return wordHyphenator(p);
+                }
+                return p;
+            });
+            if (H.c.compound === "auto") {
+                word = parts.join("-");
+            } else {
+                word = parts.join("-" + zeroWidthSpace);
+            }
+        } else {
+            word = word.replace("-", "-" + zeroWidthSpace);
+        }
+        return word;
+    }
+
+    /**
+     * Checks if a string is mixed case
+     * @param {string} s The string
+     * @returns {boolean} true if s is mixed case
+     */
+    function isMixedCase(s) {
+        return Array.prototype.map.call(s, function mapper(c) {
+            return (c === c.toLowerCase());
+        }).some(function checker(v, i, a) {
+            return (v !== a[0]);
+        });
+    }
+
+    /* eslint-disable complexity */
+    /**
+     * HyphenateFunction for words (compound or not)
+     * @param {string} word The word
+     * @returns {string} The hyphenated word
+     */
+    function hyphenator(word) {
+        let hw = lo.cache.get(word);
+        if (!H.c.mixedCase && isMixedCase(word)) {
+            hw = word;
+        }
+        if (!hw) {
+            if (lo.exceptions.has(word)) {
+                hw = lo.exceptions.get(word).replace(
+                    /-/g,
+                    H.c.hyphen
+                );
+            } else if (word.indexOf("-") === -1) {
+                if (word.length > 61) {
+                    H.events.dispatch("error", {"msg": "found word longer than 61 characters"});
+                    hw = word;
+                } else {
+                    hw = lo.hyphenateFunction(
+                        word,
+                        H.c.hyphen.charCodeAt(0),
+                        H.c.leftmin,
+                        H.c.rightmin
+                    );
+                }
+            } else {
+                hw = hyphenateCompound(word);
+            }
+            lo.cache.set(word, hw);
+        }
+        return hw;
+    }
+    /* eslint-enable complexity */
+    wordHyphenatorPool.set(lang, hyphenator);
+    return hyphenator;
+}
+
+const orphanController = (function createOrphanController() {
+    /**
+     * Function template
+     * @param {string} ignore unused result of replace
+     * @param {string} leadingWhiteSpace The leading whiteSpace
+     * @param {string} lastWord The last word
+     * @param {string} trailingWhiteSpace The trailing whiteSpace
+     * @returns {string} Treated end of text
+     */
+    function controlOrphans(
+        ignore,
+        leadingWhiteSpace,
+        lastWord,
+        trailingWhiteSpace
+    ) {
+        let h = H.c.hyphen;
+        if (".\\+*?[^]$(){}=!<>|:-".indexOf(H.c.hyphen) !== -1) {
+            h = `\\${H.c.hyphen}`;
+        }
+        if (H.c.orphanControl === 3 && leadingWhiteSpace === " ") {
+            leadingWhiteSpace = String.fromCharCode(160);
+        }
+        /* eslint-disable security/detect-non-literal-regexp */
+        return leadingWhiteSpace + lastWord.replace(new RegExp(h, "g"), "") + trailingWhiteSpace;
+        /* eslint-enable security/detect-non-literal-regexp */
+    }
+    return controlOrphans;
+}());
+
+/**
+ * Encloses hyphenateTextFunction
+ * @param {string} lang - The language
+ * @return {function} The hyphenateText-function
+ */
+function createTextHyphenator(lang) {
+    const lo = H.languages.get(lang);
+    const wordHyphenator = (wordHyphenatorPool.has(lang))
+        ? wordHyphenatorPool.get(lang)
+        : createWordHyphenator(lo, lang);
+
+    /**
+     * Hyphenate text
+     * @param {string} text The text
+     * @param {string} lang The language of the text
+     * @returns {string} Hyphenated text
+     */
+    return function hyphenateText(text) {
+        if (H.c.normalize) {
+            text = text.normalize("NFC");
+        }
+        let tn = text.replace(lo.genRegExp, wordHyphenator);
+        if (H.c.orphanControl !== 1) {
+            tn = tn.replace(
+                // eslint-disable-next-line prefer-named-capture-group
+                /(\u0020*)(\S+)(\s*)$/,
+                orphanController
+            );
+        }
+        return tn;
+    };
+}
+
+(function setupEvents() {
+    // Events known to the system
+    const definedEvents = new Map();
+
+    /**
+     * Create Event Object
+     * @param {string} name The Name of the event
+     * @param {function|null} defFunc The default method of the event
+     * @param {boolean} cancellable Is the default cancellable
+     * @returns {undefined}
+     */
+    function define(name, defFunc, cancellable) {
+        definedEvents.set(name, {
+            "cancellable": cancellable,
+            "default": defFunc,
+            "register": []
+        });
+    }
+
+    define(
+        "error",
+        function def(e) {
+            // eslint-disable-next-line no-console
+            console.error(e.msg);
+        },
+        true
+    );
+
+    define(
+        "engineLoaded",
+        function def() {
+            prepare("*");
+        },
+        false
+    );
+
+    define(
+        "hpbLoaded",
+        function def(e) {
+            prepare(e.msg);
+        },
+        false
+    );
+
+    define(
+        "engineReady",
+        null,
+        false
+    );
+
+    /**
+     * Dispatch error <name> with arguments <data>
+     * @param {string} name The name of the event
+     * @param {Object|undefined} data Data of the event
+     * @returns {undefined}
+     */
+    function dispatch(name, data) {
+        if (!data) {
+            data = empty();
+        }
+        data.defaultPrevented = false;
+        data.preventDefault = function preventDefault() {
+            if (definedEvents.get(name).cancellable) {
+                data.defaultPrevented = true;
+            }
+        };
+        definedEvents.get(name).register.forEach(function call(currentHandler) {
+            currentHandler(data);
+        });
+        if (!data.defaultPrevented && definedEvents.get(name).default) {
+            definedEvents.get(name).default(data);
+        }
+    }
+
+    /**
+     * Add EventListender <handler> to event <name>
+     * @param {string} name The name of the event
+     * @param {function} handler Function to register
+     * @returns {undefined}
+     */
+    function addListener(name, handler) {
+        if (definedEvents.has(name)) {
+            definedEvents.get(name).register.push(handler);
+        } else {
+            H.events.dispatch(
+                "error",
+                {"msg": `unknown Event "${name}" discarded`}
+            );
+        }
+    }
+
+    H.events = empty();
+    H.events.dispatch = dispatch;
+    H.events.define = define;
+    H.events.addListener = addListener;
+}());
+
+H.config = function config(userConfig) {
+    const defaults = Object.create(null, {
+        "compound": setProp("hyphen", 2),
+        "exceptions": setProp(empty(), 2),
+        "hyphen": setProp(String.fromCharCode(173), 2),
+        "leftmin": setProp(0, 2),
+        "loader": setProp("fs", 2),
+        "minWordLength": setProp(6, 2),
+        "mixedCase": setProp(true, 2),
+        "normalize": setProp(false, 2),
+        "orphanControl": setProp(1, 2),
+        "paths": setProp(Object.create(null, {
+            "maindir": setProp(`${__dirname}/`, 2),
+            "patterndir": setProp(`${__dirname}/patterns/`, 2)
+        }), 2),
+        "require": setProp([], 2),
+        "rightmin": setProp(0, 2),
+        "sync": setProp(false, 2)
+    });
+    const settings = Object.create(defaults);
+    Object.keys(userConfig).forEach(function each(key) {
+        Object.defineProperty(
+            settings,
+            key,
+            /* eslint-disable security/detect-object-injection */
+            setProp(userConfig[key], 3)
+            /* eslint-enable security/detect-object-injection */
+        );
+    });
+    H.c = settings;
+    if (H.c.loader === "https") {
+        // eslint-disable-next-line global-require
+        loader = require("https");
+    }
+    if (H.c.loader === "http") {
+        // eslint-disable-next-line global-require
+        loader = require("http");
+    }
+    if (H.c.handleEvent) {
+        Object.keys(H.c.handleEvent).forEach(function add(name) {
+            /* eslint-disable security/detect-object-injection */
+            H.events.addListener(name, H.c.handleEvent[name]);
+            /* eslint-enable security/detect-object-injection */
+        });
+    }
+    const result = new Map();
+    if (H.c.require.length === 0) {
+        H.events.dispatch(
+            "error",
+            {"msg": "No language has been required. Setup config according to documenation."}
+        );
+    }
+    H.c.require.forEach(function each(lang) {
+        loadHpb(lang);
+        if (H.c.sync) {
+            H.events.addListener("engineReady", function handler(e) {
+                if (e.msg === lang) {
+                    result.set(lang, createTextHyphenator(lang));
+                }
+            });
+        } else {
+            const prom = new Promise(function pro(resolve, reject) {
+                H.events.addListener("engineReady", function handler(e) {
+                    if (e.msg === lang) {
+                        resolve(createTextHyphenator(lang));
+                    }
+                });
+                H.events.addListener("error", function handler(e) {
+                    e.preventDefault();
+                    if (e.key === lang || e.key === "hyphenEngine") {
+                        reject(e.msg);
+                    }
+                });
+            });
+            result.set(lang, prom);
+        }
+    });
+    loadWasm();
+    return (result.size === 1)
+        ? result.get(H.c.require[0])
+        : result;
+};
+
+module.exports = H;

static/lib/Hyphenopoly-master/package-lock.json

@@ -0,0 +1,5043 @@
+{
+  "name": "hyphenopoly",
+  "version": "3.3.0",
+  "lockfileVersion": 1,
+  "requires": true,
+  "dependencies": {
+    "@babel/code-frame": {
+      "version": "7.5.5",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.5.5.tgz",
+      "integrity": "sha512-27d4lZoomVyo51VegxI20xZPuSHusqbQag/ztrBC7wegWoQ1nLREPVSKSW8byhTlzTKyNE4ifaTA6lCp7JjpFw==",
+      "dev": true,
+      "requires": {
+        "@babel/highlight": "^7.0.0"
+      }
+    },
+    "@babel/generator": {
+      "version": "7.7.7",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.7.7.tgz",
+      "integrity": "sha512-/AOIBpHh/JU1l0ZFS4kiRCBnLi6OTHzh0RPk3h9isBxkkqELtQNFi1Vr/tiG9p1yfoUdKVwISuXWQR+hwwM4VQ==",
+      "dev": true,
+      "requires": {
+        "@babel/types": "^7.7.4",
+        "jsesc": "^2.5.1",
+        "lodash": "^4.17.13",
+        "source-map": "^0.5.0"
+      },
+      "dependencies": {
+        "source-map": {
+          "version": "0.5.7",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz",
+          "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=",
+          "dev": true
+        }
+      }
+    },
+    "@babel/helper-function-name": {
+      "version": "7.7.4",
+      "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.7.4.tgz",
+      "integrity": "sha512-AnkGIdiBhEuiwdoMnKm7jfPfqItZhgRaZfMg1XX3bS25INOnLPjPG1Ppnajh8eqgt5kPJnfqrRHqFqmjKDZLzQ==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-get-function-arity": "^7.7.4",
+        "@babel/template": "^7.7.4",
+        "@babel/types": "^7.7.4"
+      }
+    },
+    "@babel/helper-get-function-arity": {
+      "version": "7.7.4",
+      "resolved": "https://registry.npmjs.org/@babel/helper-get-function-arity/-/helper-get-function-arity-7.7.4.tgz",
+      "integrity": "sha512-QTGKEdCkjgzgfJ3bAyRwF4yyT3pg+vDgan8DSivq1eS0gwi+KGKE5x8kRcbeFTb/673mkO5SN1IZfmCfA5o+EA==",
+      "dev": true,
+      "requires": {
+        "@babel/types": "^7.7.4"
+      }
+    },
+    "@babel/helper-split-export-declaration": {
+      "version": "7.7.4",
+      "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.7.4.tgz",
+      "integrity": "sha512-guAg1SXFcVr04Guk9eq0S4/rWS++sbmyqosJzVs8+1fH5NI+ZcmkaSkc7dmtAFbHFva6yRJnjW3yAcGxjueDug==",
+      "dev": true,
+      "requires": {
+        "@babel/types": "^7.7.4"
+      }
+    },
+    "@babel/highlight": {
+      "version": "7.5.0",
+      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.5.0.tgz",
+      "integrity": "sha512-7dV4eu9gBxoM0dAnj/BCFDW9LFU0zvTrkq0ugM7pnHEgguOEeOz1so2ZghEdzviYzQEED0r4EAgpsBChKy1TRQ==",
+      "dev": true,
+      "requires": {
+        "chalk": "^2.0.0",
+        "esutils": "^2.0.2",
+        "js-tokens": "^4.0.0"
+      }
+    },
+    "@babel/parser": {
+      "version": "7.7.7",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.7.7.tgz",
+      "integrity": "sha512-WtTZMZAZLbeymhkd/sEaPD8IQyGAhmuTuvTzLiCFM7iXiVdY0gc0IaI+cW0fh1BnSMbJSzXX6/fHllgHKwHhXw==",
+      "dev": true
+    },
+    "@babel/runtime": {
+      "version": "7.7.7",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.7.7.tgz",
+      "integrity": "sha512-uCnC2JEVAu8AKB5do1WRIsvrdJ0flYx/A/9f/6chdacnEZ7LmavjdsDXr5ksYBegxtuTPR5Va9/+13QF/kFkCA==",
+      "dev": true,
+      "requires": {
+        "regenerator-runtime": "^0.13.2"
+      }
+    },
+    "@babel/template": {
+      "version": "7.7.4",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.7.4.tgz",
+      "integrity": "sha512-qUzihgVPguAzXCK7WXw8pqs6cEwi54s3E+HrejlkuWO6ivMKx9hZl3Y2fSXp9i5HgyWmj7RKP+ulaYnKM4yYxw==",
+      "dev": true,
+      "requires": {
+        "@babel/code-frame": "^7.0.0",
+        "@babel/parser": "^7.7.4",
+        "@babel/types": "^7.7.4"
+      }
+    },
+    "@babel/traverse": {
+      "version": "7.7.4",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.7.4.tgz",
+      "integrity": "sha512-P1L58hQyupn8+ezVA2z5KBm4/Zr4lCC8dwKCMYzsa5jFMDMQAzaBNy9W5VjB+KAmBjb40U7a/H6ao+Xo+9saIw==",
+      "dev": true,
+      "requires": {
+        "@babel/code-frame": "^7.5.5",
+        "@babel/generator": "^7.7.4",
+        "@babel/helper-function-name": "^7.7.4",
+        "@babel/helper-split-export-declaration": "^7.7.4",
+        "@babel/parser": "^7.7.4",
+        "@babel/types": "^7.7.4",
+        "debug": "^4.1.0",
+        "globals": "^11.1.0",
+        "lodash": "^4.17.13"
+      },
+      "dependencies": {
+        "globals": {
+          "version": "11.12.0",
+          "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz",
+          "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==",
+          "dev": true
+        }
+      }
+    },
+    "@babel/types": {
+      "version": "7.7.4",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.7.4.tgz",
+      "integrity": "sha512-cz5Ji23KCi4T+YIE/BolWosrJuSmoZeN1EFnRtBwF+KKLi8GG/Z2c2hOJJeCXPk4mwk4QFvTmwIodJowXgttRA==",
+      "dev": true,
+      "requires": {
+        "esutils": "^2.0.2",
+        "lodash": "^4.17.13",
+        "to-fast-properties": "^2.0.0"
+      }
+    },
+    "@types/unist": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.3.tgz",
+      "integrity": "sha512-FvUupuM3rlRsRtCN+fDudtmytGO6iHJuuRKS1Ss0pG5z8oX0diNEw94UEL7hgDbpN94rgaK5R7sWm6RrSkZuAQ==",
+      "dev": true
+    },
+    "acorn": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.1.0.tgz",
+      "integrity": "sha512-kL5CuoXA/dgxlBbVrflsflzQ3PAas7RYZB52NOm/6839iVYJgKMJ3cQJD+t2i5+qFa8h3MDpEOJiS64E8JLnSQ==",
+      "dev": true
+    },
+    "acorn-jsx": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.1.0.tgz",
+      "integrity": "sha512-tMUqwBWfLFbJbizRmEcWSLw6HnFzfdJs2sOJEOwwtVPMoH/0Ay+E703oZz78VSXZiiDcZrQ5XKjPIUQixhmgVw==",
+      "dev": true
+    },
+    "ajv": {
+      "version": "6.10.2",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.10.2.tgz",
+      "integrity": "sha512-TXtUUEYHuaTEbLZWIKUr5pmBuhDLy+8KYtPYdcV8qC+pOZL+NKqYwvWSRrVXHn+ZmRRAu8vJTAznH7Oag6RVRw==",
+      "dev": true,
+      "requires": {
+        "fast-deep-equal": "^2.0.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      }
+    },
+    "ansi-escapes": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.0.tgz",
+      "integrity": "sha512-EiYhwo0v255HUL6eDyuLrXEkTi7WwVCLAw+SeOQ7M7qdun1z1pum4DEm/nuqIVbPvi9RPPc9k9LbyBv6H0DwVg==",
+      "dev": true,
+      "requires": {
+        "type-fest": "^0.8.1"
+      }
+    },
+    "ansi-regex": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz",
+      "integrity": "sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==",
+      "dev": true
+    },
+    "ansi-styles": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
+      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+      "dev": true,
+      "requires": {
+        "color-convert": "^1.9.0"
+      }
+    },
+    "anymatch": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.1.tgz",
+      "integrity": "sha512-mM8522psRCqzV+6LhomX5wgp25YVibjh8Wj23I5RPkPppSVSjyKD2A2mBJmWGa+KN7f2D6LNh9jkBCeyLktzjg==",
+      "dev": true,
+      "requires": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      }
+    },
+    "append-transform": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/append-transform/-/append-transform-1.0.0.tgz",
+      "integrity": "sha512-P009oYkeHyU742iSZJzZZywj4QRJdnTWffaKuJQLablCZ1uz6/cW4yaRgcDaoQ+uwOxxnt0gRUcwfsNP2ri0gw==",
+      "dev": true,
+      "requires": {
+        "default-require-extensions": "^2.0.0"
+      }
+    },
+    "archy": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/archy/-/archy-1.0.0.tgz",
+      "integrity": "sha1-+cjBN1fMHde8N5rHeyxipcKGjEA=",
+      "dev": true
+    },
+    "arg": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.2.tgz",
+      "integrity": "sha512-+ytCkGcBtHZ3V2r2Z06AncYO8jz46UEamcspGoU8lHcEbpn6J77QK0vdWvChsclg/tM5XIJC5tnjmPp7Eq6Obg==",
+      "dev": true
+    },
+    "argparse": {
+      "version": "1.0.10",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
+      "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
+      "dev": true,
+      "requires": {
+        "sprintf-js": "~1.0.2"
+      }
+    },
+    "asn1": {
+      "version": "0.2.4",
+      "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.4.tgz",
+      "integrity": "sha512-jxwzQpLQjSmWXgwaCZE9Nz+glAG01yF1QnWgbhGwHI5A6FRIEY6IVqtHhIepHqI7/kyEyQEagBC5mBEFlIYvdg==",
+      "dev": true,
+      "requires": {
+        "safer-buffer": "~2.1.0"
+      }
+    },
+    "assert-plus": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz",
+      "integrity": "sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=",
+      "dev": true
+    },
+    "astral-regex": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-1.0.0.tgz",
+      "integrity": "sha512-+Ryf6g3BKoRc7jfp7ad8tM4TtMiaWvbF/1/sQcZPkkS7ag3D5nMBCe2UfOTONtAkaG0tO0ij3C5Lwmf1EiyjHg==",
+      "dev": true
+    },
+    "async-hook-domain": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/async-hook-domain/-/async-hook-domain-1.1.3.tgz",
+      "integrity": "sha512-ZovMxSbADV3+biB7oR1GL5lGyptI24alp0LWHlmz1OFc5oL47pz3EiIF6nXOkDW7yLqih4NtsiYduzdDW0i+Wg==",
+      "dev": true,
+      "requires": {
+        "source-map-support": "^0.5.11"
+      }
+    },
+    "asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k=",
+      "dev": true
+    },
+    "aws-sign2": {
+      "version": "0.7.0",
+      "resolved": "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz",
+      "integrity": "sha1-tG6JCTSpWR8tL2+G1+ap8bP+dqg=",
+      "dev": true
+    },
+    "aws4": {
+      "version": "1.9.0",
+      "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.9.0.tgz",
+      "integrity": "sha512-Uvq6hVe90D0B2WEnUqtdgY1bATGz3mw33nH9Y+dmA+w5DHvUmBgkr5rM/KCHpCsiFNRUfokW/szpPPgMK2hm4A==",
+      "dev": true
+    },
+    "bail": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/bail/-/bail-1.0.4.tgz",
+      "integrity": "sha512-S8vuDB4w6YpRhICUDET3guPlQpaJl7od94tpZ0Fvnyp+MKW/HyDTcRDck+29C9g+d/qQHnddRH3+94kZdrW0Ww==",
+      "dev": true
+    },
+    "balanced-match": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz",
+      "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=",
+      "dev": true
+    },
+    "bcrypt-pbkdf": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz",
+      "integrity": "sha1-pDAdOJtqQ/m2f/PKEaP2Y342Dp4=",
+      "dev": true,
+      "requires": {
+        "tweetnacl": "^0.14.3"
+      }
+    },
+    "binary-extensions": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.0.0.tgz",
+      "integrity": "sha512-Phlt0plgpIIBOGTT/ehfFnbNlfsDEiqmzE2KRXoX1bLIlir4X/MR+zSyBEkL05ffWgnRSf/DXv+WrUAVr93/ow==",
+      "dev": true
+    },
+    "bind-obj-methods": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/bind-obj-methods/-/bind-obj-methods-2.0.0.tgz",
+      "integrity": "sha512-3/qRXczDi2Cdbz6jE+W3IflJOutRVica8frpBn14de1mBOkzDo+6tY33kNhvkw54Kn3PzRRD2VnGbGPcTAk4sw==",
+      "dev": true
+    },
+    "brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "dev": true,
+      "requires": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "braces": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
+      "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+      "dev": true,
+      "requires": {
+        "fill-range": "^7.0.1"
+      }
+    },
+    "browser-process-hrtime": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/browser-process-hrtime/-/browser-process-hrtime-1.0.0.tgz",
+      "integrity": "sha512-9o5UecI3GhkpM6DrXr69PblIuWxPKk9Y0jHBRhdocZ2y7YECBFCsHm79Pr3OyR2AvjhDkabFJaDJMYRazHgsow==",
+      "dev": true
+    },
+    "buffer-from": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz",
+      "integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==",
+      "dev": true
+    },
+    "caching-transform": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/caching-transform/-/caching-transform-3.0.2.tgz",
+      "integrity": "sha512-Mtgcv3lh3U0zRii/6qVgQODdPA4G3zhG+jtbCWj39RXuUFTMzH0vcdMtaJS1jPowd+It2Pqr6y3NJMQqOqCE2w==",
+      "dev": true,
+      "requires": {
+        "hasha": "^3.0.0",
+        "make-dir": "^2.0.0",
+        "package-hash": "^3.0.0",
+        "write-file-atomic": "^2.4.2"
+      },
+      "dependencies": {
+        "write-file-atomic": {
+          "version": "2.4.3",
+          "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-2.4.3.tgz",
+          "integrity": "sha512-GaETH5wwsX+GcnzhPgKcKjJ6M2Cq3/iZp1WyY/X1CSqrW+jVNM9Y7D8EC2sM4ZG/V8wZlSniJnCKWPmBYAucRQ==",
+          "dev": true,
+          "requires": {
+            "graceful-fs": "^4.1.11",
+            "imurmurhash": "^0.1.4",
+            "signal-exit": "^3.0.2"
+          }
+        }
+      }
+    },
+    "callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+      "dev": true
+    },
+    "camelcase": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz",
+      "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
+      "dev": true
+    },
+    "caseless": {
+      "version": "0.12.0",
+      "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz",
+      "integrity": "sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=",
+      "dev": true
+    },
+    "ccount": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/ccount/-/ccount-1.0.4.tgz",
+      "integrity": "sha512-fpZ81yYfzentuieinmGnphk0pLkOTMm6MZdVqwd77ROvhko6iujLNGrHH5E7utq3ygWklwfmwuG+A7P+NpqT6w==",
+      "dev": true
+    },
+    "chalk": {
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+      "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
+      "dev": true,
+      "requires": {
+        "ansi-styles": "^3.2.1",
+        "escape-string-regexp": "^1.0.5",
+        "supports-color": "^5.3.0"
+      }
+    },
+    "character-entities": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/character-entities/-/character-entities-1.2.3.tgz",
+      "integrity": "sha512-yB4oYSAa9yLcGyTbB4ItFwHw43QHdH129IJ5R+WvxOkWlyFnR5FAaBNnUq4mcxsTVZGh28bHoeTHMKXH1wZf3w==",
+      "dev": true
+    },
+    "character-entities-html4": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-1.1.3.tgz",
+      "integrity": "sha512-SwnyZ7jQBCRHELk9zf2CN5AnGEc2nA+uKMZLHvcqhpPprjkYhiLn0DywMHgN5ttFZuITMATbh68M6VIVKwJbcg==",
+      "dev": true
+    },
+    "character-entities-legacy": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-1.1.3.tgz",
+      "integrity": "sha512-YAxUpPoPwxYFsslbdKkhrGnXAtXoHNgYjlBM3WMXkWGTl5RsY3QmOyhwAgL8Nxm9l5LBThXGawxKPn68y6/fww==",
+      "dev": true
+    },
+    "character-reference-invalid": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/character-reference-invalid/-/character-reference-invalid-1.1.3.tgz",
+      "integrity": "sha512-VOq6PRzQBam/8Jm6XBGk2fNEnHXAdGd6go0rtd4weAGECBamHDwwCQSOT12TACIYUZegUXnV6xBXqUssijtxIg==",
+      "dev": true
+    },
+    "chardet": {
+      "version": "0.7.0",
+      "resolved": "https://registry.npmjs.org/chardet/-/chardet-0.7.0.tgz",
+      "integrity": "sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==",
+      "dev": true
+    },
+    "chokidar": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.3.0.tgz",
+      "integrity": "sha512-dGmKLDdT3Gdl7fBUe8XK+gAtGmzy5Fn0XkkWQuYxGIgWVPPse2CxFA5mtrlD0TOHaHjEUqkWNyP1XdHoJES/4A==",
+      "dev": true,
+      "requires": {
+        "anymatch": "~3.1.1",
+        "braces": "~3.0.2",
+        "fsevents": "~2.1.1",
+        "glob-parent": "~5.1.0",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.2.0"
+      }
+    },
+    "cli-cursor": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-3.1.0.tgz",
+      "integrity": "sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==",
+      "dev": true,
+      "requires": {
+        "restore-cursor": "^3.1.0"
+      }
+    },
+    "cli-width": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-2.2.0.tgz",
+      "integrity": "sha1-/xnt6Kml5XkyQUewwR8PvLq+1jk=",
+      "dev": true
+    },
+    "cliui": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-4.1.0.tgz",
+      "integrity": "sha512-4FG+RSG9DL7uEwRUZXZn3SS34DiDPfzP0VOiEwtUWlE+AR2EIg+hSyvrIgUUfhdgR/UkAeW2QHgeP+hWrXs7jQ==",
+      "dev": true,
+      "requires": {
+        "string-width": "^2.1.1",
+        "strip-ansi": "^4.0.0",
+        "wrap-ansi": "^2.0.0"
+      },
+      "dependencies": {
+        "ansi-regex": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz",
+          "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=",
+          "dev": true
+        },
+        "is-fullwidth-code-point": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
+          "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
+          "dev": true
+        },
+        "string-width": {
+          "version": "2.1.1",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz",
+          "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==",
+          "dev": true,
+          "requires": {
+            "is-fullwidth-code-point": "^2.0.0",
+            "strip-ansi": "^4.0.0"
+          }
+        },
+        "strip-ansi": {
+          "version": "4.0.0",
+          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz",
+          "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=",
+          "dev": true,
+          "requires": {
+            "ansi-regex": "^3.0.0"
+          }
+        }
+      }
+    },
+    "co": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/co/-/co-3.1.0.tgz",
+      "integrity": "sha1-TqVOpaCJOBUxheFSEMaNkJK8G3g=",
+      "dev": true
+    },
+    "code-point-at": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz",
+      "integrity": "sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=",
+      "dev": true
+    },
+    "collapse-white-space": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/collapse-white-space/-/collapse-white-space-1.0.4.tgz",
+      "integrity": "sha512-YfQ1tAUZm561vpYD+5eyWN8+UsceQbSrqqlc/6zDY2gtAE+uZLSdkkovhnGpmCThsvKBFakq4EdY/FF93E8XIw==",
+      "dev": true
+    },
+    "color-convert": {
+      "version": "1.9.3",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
+      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+      "dev": true,
+      "requires": {
+        "color-name": "1.1.3"
+      }
+    },
+    "color-name": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+      "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=",
+      "dev": true
+    },
+    "color-support": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz",
+      "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==",
+      "dev": true
+    },
+    "combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "dev": true,
+      "requires": {
+        "delayed-stream": "~1.0.0"
+      }
+    },
+    "commander": {
+      "version": "2.20.3",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
+      "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",
+      "dev": true
+    },
+    "commondir": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz",
+      "integrity": "sha1-3dgA2gxmEnOTzKWVDqloo6rxJTs=",
+      "dev": true
+    },
+    "concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
+      "dev": true
+    },
+    "concat-stream": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-2.0.0.tgz",
+      "integrity": "sha512-MWufYdFw53ccGjCA+Ol7XJYpAlW6/prSMzuPOTRnJGcGzuhLn4Scrz7qf6o8bROZ514ltazcIFJZevcfbo0x7A==",
+      "dev": true,
+      "requires": {
+        "buffer-from": "^1.0.0",
+        "inherits": "^2.0.3",
+        "readable-stream": "^3.0.2",
+        "typedarray": "^0.0.6"
+      }
+    },
+    "convert-source-map": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.7.0.tgz",
+      "integrity": "sha512-4FJkXzKXEDB1snCFZlLP4gpC3JILicCpGbzG9f9G7tGqGCzETQ2hWPrcinA9oU4wtf2biUaEH5065UnMeR33oA==",
+      "dev": true,
+      "requires": {
+        "safe-buffer": "~5.1.1"
+      },
+      "dependencies": {
+        "safe-buffer": {
+          "version": "5.1.2",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+          "dev": true
+        }
+      }
+    },
+    "core-util-is": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz",
+      "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=",
+      "dev": true
+    },
+    "coveralls": {
+      "version": "3.0.9",
+      "resolved": "https://registry.npmjs.org/coveralls/-/coveralls-3.0.9.tgz",
+      "integrity": "sha512-nNBg3B1+4iDox5A5zqHKzUTiwl2ey4k2o0NEcVZYvl+GOSJdKBj4AJGKLv6h3SvWch7tABHePAQOSZWM9E2hMg==",
+      "dev": true,
+      "requires": {
+        "js-yaml": "^3.13.1",
+        "lcov-parse": "^1.0.0",
+        "log-driver": "^1.2.7",
+        "minimist": "^1.2.0",
+        "request": "^2.88.0"
+      },
+      "dependencies": {
+        "minimist": {
+          "version": "1.2.0",
+          "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
+          "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
+          "dev": true
+        }
+      }
+    },
+    "cp-file": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/cp-file/-/cp-file-6.2.0.tgz",
+      "integrity": "sha512-fmvV4caBnofhPe8kOcitBwSn2f39QLjnAnGq3gO9dfd75mUytzKNZB1hde6QHunW2Rt+OwuBOMc3i1tNElbszA==",
+      "dev": true,
+      "requires": {
+        "graceful-fs": "^4.1.2",
+        "make-dir": "^2.0.0",
+        "nested-error-stacks": "^2.0.0",
+        "pify": "^4.0.1",
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "cross-spawn": {
+      "version": "6.0.5",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.5.tgz",
+      "integrity": "sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==",
+      "dev": true,
+      "requires": {
+        "nice-try": "^1.0.4",
+        "path-key": "^2.0.1",
+        "semver": "^5.5.0",
+        "shebang-command": "^1.2.0",
+        "which": "^1.2.9"
+      },
+      "dependencies": {
+        "semver": {
+          "version": "5.7.1",
+          "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz",
+          "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==",
+          "dev": true
+        }
+      }
+    },
+    "dashdash": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz",
+      "integrity": "sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA=",
+      "dev": true,
+      "requires": {
+        "assert-plus": "^1.0.0"
+      }
+    },
+    "debug": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz",
+      "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==",
+      "dev": true,
+      "requires": {
+        "ms": "^2.1.1"
+      }
+    },
+    "decamelize": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz",
+      "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=",
+      "dev": true
+    },
+    "deep-extend": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz",
+      "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==",
+      "dev": true
+    },
+    "deep-is": {
+      "version": "0.1.3",
+      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz",
+      "integrity": "sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=",
+      "dev": true
+    },
+    "default-require-extensions": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/default-require-extensions/-/default-require-extensions-2.0.0.tgz",
+      "integrity": "sha1-9fj7sYp9bVCyH2QfZJ67Uiz+JPc=",
+      "dev": true,
+      "requires": {
+        "strip-bom": "^3.0.0"
+      }
+    },
+    "delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk=",
+      "dev": true
+    },
+    "diff": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.1.tgz",
+      "integrity": "sha512-s2+XdvhPCOF01LRQBC8hf4vhbVmI2CGS5aZnxLJlT5FtdhPCDFq80q++zK2KlrVorVDdL5BOGZ/VfLrVtYNF+Q==",
+      "dev": true
+    },
+    "diff-frag": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/diff-frag/-/diff-frag-1.0.1.tgz",
+      "integrity": "sha512-6/v2PC/6UTGcWPPetb9acL8foberUg/CtPdALeJUdD1B/weHNvzftoo00gYznqHGRhHEbykUGzqfG9RWOSr5yw==",
+      "dev": true
+    },
+    "doctrine": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz",
+      "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==",
+      "dev": true,
+      "requires": {
+        "esutils": "^2.0.2"
+      }
+    },
+    "ecc-jsbn": {
+      "version": "0.1.2",
+      "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz",
+      "integrity": "sha1-OoOpBOVDUyh4dMVkt1SThoSamMk=",
+      "dev": true,
+      "requires": {
+        "jsbn": "~0.1.0",
+        "safer-buffer": "^2.1.0"
+      }
+    },
+    "emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true
+    },
+    "error-ex": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz",
+      "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==",
+      "dev": true,
+      "requires": {
+        "is-arrayish": "^0.2.1"
+      }
+    },
+    "es6-error": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/es6-error/-/es6-error-4.1.1.tgz",
+      "integrity": "sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==",
+      "dev": true
+    },
+    "escape-string-regexp": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+      "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=",
+      "dev": true
+    },
+    "eslint": {
+      "version": "6.8.0",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-6.8.0.tgz",
+      "integrity": "sha512-K+Iayyo2LtyYhDSYwz5D5QdWw0hCacNzyq1Y821Xna2xSJj7cijoLLYmLxTQgcgZ9mC61nryMy9S7GRbYpI5Ig==",
+      "dev": true,
+      "requires": {
+        "@babel/code-frame": "^7.0.0",
+        "ajv": "^6.10.0",
+        "chalk": "^2.1.0",
+        "cross-spawn": "^6.0.5",
+        "debug": "^4.0.1",
+        "doctrine": "^3.0.0",
+        "eslint-scope": "^5.0.0",
+        "eslint-utils": "^1.4.3",
+        "eslint-visitor-keys": "^1.1.0",
+        "espree": "^6.1.2",
+        "esquery": "^1.0.1",
+        "esutils": "^2.0.2",
+        "file-entry-cache": "^5.0.1",
+        "functional-red-black-tree": "^1.0.1",
+        "glob-parent": "^5.0.0",
+        "globals": "^12.1.0",
+        "ignore": "^4.0.6",
+        "import-fresh": "^3.0.0",
+        "imurmurhash": "^0.1.4",
+        "inquirer": "^7.0.0",
+        "is-glob": "^4.0.0",
+        "js-yaml": "^3.13.1",
+        "json-stable-stringify-without-jsonify": "^1.0.1",
+        "levn": "^0.3.0",
+        "lodash": "^4.17.14",
+        "minimatch": "^3.0.4",
+        "mkdirp": "^0.5.1",
+        "natural-compare": "^1.4.0",
+        "optionator": "^0.8.3",
+        "progress": "^2.0.0",
+        "regexpp": "^2.0.1",
+        "semver": "^6.1.2",
+        "strip-ansi": "^5.2.0",
+        "strip-json-comments": "^3.0.1",
+        "table": "^5.2.3",
+        "text-table": "^0.2.0",
+        "v8-compile-cache": "^2.0.3"
+      }
+    },
+    "eslint-plugin-security": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-security/-/eslint-plugin-security-1.4.0.tgz",
+      "integrity": "sha512-xlS7P2PLMXeqfhyf3NpqbvbnW04kN8M9NtmhpR3XGyOvt/vNKS7XPXT5EDbwKW9vCjWH4PpfQvgD/+JgN0VJKA==",
+      "dev": true,
+      "requires": {
+        "safe-regex": "^1.1.0"
+      }
+    },
+    "eslint-scope": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.0.0.tgz",
+      "integrity": "sha512-oYrhJW7S0bxAFDvWqzvMPRm6pcgcnWc4QnofCAqRTRfQC0JcwenzGglTtsLyIuuWFfkqDG9vz67cnttSd53djw==",
+      "dev": true,
+      "requires": {
+        "esrecurse": "^4.1.0",
+        "estraverse": "^4.1.1"
+      }
+    },
+    "eslint-utils": {
+      "version": "1.4.3",
+      "resolved": "https://registry.npmjs.org/eslint-utils/-/eslint-utils-1.4.3.tgz",
+      "integrity": "sha512-fbBN5W2xdY45KulGXmLHZ3c3FHfVYmKg0IrAKGOkT/464PQsx2UeIzfz1RmEci+KLm1bBaAzZAh8+/E+XAeZ8Q==",
+      "dev": true,
+      "requires": {
+        "eslint-visitor-keys": "^1.1.0"
+      }
+    },
+    "eslint-visitor-keys": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.1.0.tgz",
+      "integrity": "sha512-8y9YjtM1JBJU/A9Kc+SbaOV4y29sSWckBwMHa+FGtVj5gN/sbnKDf6xJUl+8g7FAij9LVaP8C24DUiH/f/2Z9A==",
+      "dev": true
+    },
+    "esm": {
+      "version": "3.2.25",
+      "resolved": "https://registry.npmjs.org/esm/-/esm-3.2.25.tgz",
+      "integrity": "sha512-U1suiZ2oDVWv4zPO56S0NcR5QriEahGtdN2OR6FiOG4WJvcjBVFB0qI4+eKoWFH483PKGuLuu6V8Z4T5g63UVA==",
+      "dev": true
+    },
+    "espree": {
+      "version": "6.1.2",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-6.1.2.tgz",
+      "integrity": "sha512-2iUPuuPP+yW1PZaMSDM9eyVf8D5P0Hi8h83YtZ5bPc/zHYjII5khoixIUTMO794NOY8F/ThF1Bo8ncZILarUTA==",
+      "dev": true,
+      "requires": {
+        "acorn": "^7.1.0",
+        "acorn-jsx": "^5.1.0",
+        "eslint-visitor-keys": "^1.1.0"
+      }
+    },
+    "esprima": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+      "dev": true
+    },
+    "esquery": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.0.1.tgz",
+      "integrity": "sha512-SmiyZ5zIWH9VM+SRUReLS5Q8a7GxtRdxEBVZpm98rJM7Sb+A9DVCndXfkeFUd3byderg+EbDkfnevfCwynWaNA==",
+      "dev": true,
+      "requires": {
+        "estraverse": "^4.0.0"
+      }
+    },
+    "esrecurse": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.2.1.tgz",
+      "integrity": "sha512-64RBB++fIOAXPw3P9cy89qfMlvZEXZkqqJkjqqXIvzP5ezRZjW+lPWjw35UX/3EhUPFYbg5ER4JYgDw4007/DQ==",
+      "dev": true,
+      "requires": {
+        "estraverse": "^4.1.0"
+      }
+    },
+    "estraverse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz",
+      "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==",
+      "dev": true
+    },
+    "esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+      "dev": true
+    },
+    "events-to-array": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/events-to-array/-/events-to-array-1.1.2.tgz",
+      "integrity": "sha1-LUH1Y+H+QA7Uli/hpNXGp1Od9/Y=",
+      "dev": true
+    },
+    "extend": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
+      "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==",
+      "dev": true
+    },
+    "external-editor": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-3.1.0.tgz",
+      "integrity": "sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==",
+      "dev": true,
+      "requires": {
+        "chardet": "^0.7.0",
+        "iconv-lite": "^0.4.24",
+        "tmp": "^0.0.33"
+      }
+    },
+    "extsprintf": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz",
+      "integrity": "sha1-lpGEQOMEGnpBT4xS48V06zw+HgU=",
+      "dev": true
+    },
+    "fast-deep-equal": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz",
+      "integrity": "sha1-ewUhjd+WZ79/Nwv3/bLLFf3Qqkk=",
+      "dev": true
+    },
+    "fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+      "dev": true
+    },
+    "fast-levenshtein": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+      "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=",
+      "dev": true
+    },
+    "fault": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/fault/-/fault-1.0.3.tgz",
+      "integrity": "sha512-sfFuP4X0hzrbGKjAUNXYvNqsZ5F6ohx/dZ9I0KQud/aiZNwg263r5L9yGB0clvXHCkzXh5W3t7RSHchggYIFmA==",
+      "dev": true,
+      "requires": {
+        "format": "^0.2.2"
+      }
+    },
+    "figures": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/figures/-/figures-3.1.0.tgz",
+      "integrity": "sha512-ravh8VRXqHuMvZt/d8GblBeqDMkdJMBdv/2KntFH+ra5MXkO7nxNKpzQ3n6QD/2da1kH0aWmNISdvhM7gl2gVg==",
+      "dev": true,
+      "requires": {
+        "escape-string-regexp": "^1.0.5"
+      }
+    },
+    "file-entry-cache": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-5.0.1.tgz",
+      "integrity": "sha512-bCg29ictuBaKUwwArK4ouCaqDgLZcysCFLmM/Yn/FDoqndh/9vNuQfXRDvTuXKLxfD/JtZQGKFT8MGcJBK644g==",
+      "dev": true,
+      "requires": {
+        "flat-cache": "^2.0.1"
+      }
+    },
+    "fill-range": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
+      "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+      "dev": true,
+      "requires": {
+        "to-regex-range": "^5.0.1"
+      }
+    },
+    "find-cache-dir": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/find-cache-dir/-/find-cache-dir-2.1.0.tgz",
+      "integrity": "sha512-Tq6PixE0w/VMFfCgbONnkiQIVol/JJL7nRMi20fqzA4NRs9AfeqMGeRdPi3wIhYkxjeBaWh2rxwapn5Tu3IqOQ==",
+      "dev": true,
+      "requires": {
+        "commondir": "^1.0.1",
+        "make-dir": "^2.0.0",
+        "pkg-dir": "^3.0.0"
+      }
+    },
+    "find-up": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz",
+      "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==",
+      "dev": true,
+      "requires": {
+        "locate-path": "^3.0.0"
+      }
+    },
+    "findit": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/findit/-/findit-2.0.0.tgz",
+      "integrity": "sha1-ZQnwEmr0wXhVHPqZOU4DLhOk1W4=",
+      "dev": true
+    },
+    "flat-cache": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-2.0.1.tgz",
+      "integrity": "sha512-LoQe6yDuUMDzQAEH8sgmh4Md6oZnc/7PjtwjNFSzveXqSHt6ka9fPBuso7IGf9Rz4uqnSnWiFH2B/zj24a5ReA==",
+      "dev": true,
+      "requires": {
+        "flatted": "^2.0.0",
+        "rimraf": "2.6.3",
+        "write": "1.0.3"
+      }
+    },
+    "flatted": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-2.0.1.tgz",
+      "integrity": "sha512-a1hQMktqW9Nmqr5aktAux3JMNqaucxGcjtjWnZLHX7yyPCmlSV3M54nGYbqT8K+0GhF3NBgmJCc3ma+WOgX8Jg==",
+      "dev": true
+    },
+    "flow-parser": {
+      "version": "0.114.0",
+      "resolved": "https://registry.npmjs.org/flow-parser/-/flow-parser-0.114.0.tgz",
+      "integrity": "sha512-Qt9HT3v507bCerJfp4FX4N5E7ysinBzxjpK1rL7bJ/Bw12puF6lva2MAIXYS1d83bV7BT/F7EDk+faJQY5MpRA==",
+      "dev": true
+    },
+    "flow-remove-types": {
+      "version": "2.114.0",
+      "resolved": "https://registry.npmjs.org/flow-remove-types/-/flow-remove-types-2.114.0.tgz",
+      "integrity": "sha512-ckon8RO7tFcVGW3Ll0jAWgULVrNa/cEN0JXp2I7XmzWT/GCQghSb+0312NjtAb+y3W9iXpPxkVMI86+SDU0E0Q==",
+      "dev": true,
+      "requires": {
+        "flow-parser": "^0.114.0",
+        "pirates": "^3.0.2",
+        "vlq": "^0.2.1"
+      }
+    },
+    "fn-name": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/fn-name/-/fn-name-2.0.1.tgz",
+      "integrity": "sha1-UhTXU3pNBqSjAcDMJi/rhBiAAuc=",
+      "dev": true
+    },
+    "foreground-child": {
+      "version": "1.5.6",
+      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-1.5.6.tgz",
+      "integrity": "sha1-T9ca0t/elnibmApcCilZN8svXOk=",
+      "dev": true,
+      "requires": {
+        "cross-spawn": "^4",
+        "signal-exit": "^3.0.0"
+      },
+      "dependencies": {
+        "cross-spawn": {
+          "version": "4.0.2",
+          "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-4.0.2.tgz",
+          "integrity": "sha1-e5JHYhwjrf3ThWAEqCPL45dCTUE=",
+          "dev": true,
+          "requires": {
+            "lru-cache": "^4.0.1",
+            "which": "^1.2.9"
+          }
+        }
+      }
+    },
+    "forever-agent": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz",
+      "integrity": "sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=",
+      "dev": true
+    },
+    "form-data": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.3.3.tgz",
+      "integrity": "sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==",
+      "dev": true,
+      "requires": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.6",
+        "mime-types": "^2.1.12"
+      }
+    },
+    "format": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/format/-/format-0.2.2.tgz",
+      "integrity": "sha1-1hcBB+nv3E7TDJ3DkBbflCtctYs=",
+      "dev": true
+    },
+    "fs-exists-cached": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs-exists-cached/-/fs-exists-cached-1.0.0.tgz",
+      "integrity": "sha1-zyVVTKBQ3EmuZla0HeQiWJidy84=",
+      "dev": true
+    },
+    "fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
+      "dev": true
+    },
+    "fsevents": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.1.2.tgz",
+      "integrity": "sha512-R4wDiBwZ0KzpgOWetKDug1FZcYhqYnUYKtfZYt4mD5SBz76q0KR4Q9o7GIPamsVPGmW3EYPPJ0dOOjvx32ldZA==",
+      "dev": true,
+      "optional": true
+    },
+    "function-loop": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/function-loop/-/function-loop-1.0.2.tgz",
+      "integrity": "sha512-Iw4MzMfS3udk/rqxTiDDCllhGwlOrsr50zViTOO/W6lS/9y6B1J0BD2VZzrnWUYBJsl3aeqjgR5v7bWWhZSYbA==",
+      "dev": true
+    },
+    "functional-red-black-tree": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz",
+      "integrity": "sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=",
+      "dev": true
+    },
+    "get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "dev": true
+    },
+    "getpass": {
+      "version": "0.1.7",
+      "resolved": "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz",
+      "integrity": "sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo=",
+      "dev": true,
+      "requires": {
+        "assert-plus": "^1.0.0"
+      }
+    },
+    "glob": {
+      "version": "7.1.6",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz",
+      "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==",
+      "dev": true,
+      "requires": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.0.4",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      }
+    },
+    "glob-parent": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.0.tgz",
+      "integrity": "sha512-qjtRgnIVmOfnKUE3NJAQEdk+lKrxfw8t5ke7SXtfMTHcjsBfOfWXCQfdb30zfDoZQ2IRSIiidmjtbHZPZ++Ihw==",
+      "dev": true,
+      "requires": {
+        "is-glob": "^4.0.1"
+      }
+    },
+    "globals": {
+      "version": "12.3.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-12.3.0.tgz",
+      "integrity": "sha512-wAfjdLgFsPZsklLJvOBUBmzYE8/CwhEqSBEMRXA3qxIiNtyqvjYurAtIfDh6chlEPUfmTY3MnZh5Hfh4q0UlIw==",
+      "dev": true,
+      "requires": {
+        "type-fest": "^0.8.1"
+      }
+    },
+    "graceful-fs": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.3.tgz",
+      "integrity": "sha512-a30VEBm4PEdx1dRB7MFK7BejejvCvBronbLjht+sHuGYj8PHs7M/5Z+rt5lw551vZ7yfTCj4Vuyy3mSJytDWRQ==",
+      "dev": true
+    },
+    "handlebars": {
+      "version": "4.5.3",
+      "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.5.3.tgz",
+      "integrity": "sha512-3yPecJoJHK/4c6aZhSvxOyG4vJKDshV36VHp0iVCDVh7o9w2vwi3NSnL2MMPj3YdduqaBcu7cGbggJQM0br9xA==",
+      "dev": true,
+      "requires": {
+        "neo-async": "^2.6.0",
+        "optimist": "^0.6.1",
+        "source-map": "^0.6.1",
+        "uglify-js": "^3.1.4"
+      }
+    },
+    "har-schema": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz",
+      "integrity": "sha1-qUwiJOvKwEeCoNkDVSHyRzW37JI=",
+      "dev": true
+    },
+    "har-validator": {
+      "version": "5.1.3",
+      "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.1.3.tgz",
+      "integrity": "sha512-sNvOCzEQNr/qrvJgc3UG/kD4QtlHycrzwS+6mfTrrSq97BvaYcPZZI1ZSqGSPR73Cxn4LKTD4PttRwfU7jWq5g==",
+      "dev": true,
+      "requires": {
+        "ajv": "^6.5.5",
+        "har-schema": "^2.0.0"
+      }
+    },
+    "has-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
+      "dev": true
+    },
+    "hasha": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/hasha/-/hasha-3.0.0.tgz",
+      "integrity": "sha1-UqMvq4Vp1BymmmH/GiFPjrfIvTk=",
+      "dev": true,
+      "requires": {
+        "is-stream": "^1.0.1"
+      }
+    },
+    "hosted-git-info": {
+      "version": "2.8.5",
+      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.5.tgz",
+      "integrity": "sha512-kssjab8CvdXfcXMXVcvsXum4Hwdq9XGtRD3TteMEvEbq0LXyiNQr6AprqKqfeaDXze7SxWvRxdpwE6ku7ikLkg==",
+      "dev": true
+    },
+    "http-signature": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz",
+      "integrity": "sha1-muzZJRFHcvPZW2WmCruPfBj7rOE=",
+      "dev": true,
+      "requires": {
+        "assert-plus": "^1.0.0",
+        "jsprim": "^1.2.2",
+        "sshpk": "^1.7.0"
+      }
+    },
+    "iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "dev": true,
+      "requires": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      }
+    },
+    "ignore": {
+      "version": "4.0.6",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-4.0.6.tgz",
+      "integrity": "sha512-cyFDKrqc/YdcWFniJhzI42+AzS+gNwmUzOSFcRCQYwySuBBBy/KjuxWLZ/FHEH6Moq1NizMOBWyTcv8O4OZIMg==",
+      "dev": true
+    },
+    "import-fresh": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.2.1.tgz",
+      "integrity": "sha512-6e1q1cnWP2RXD9/keSkxHScg508CdXqXWgWBaETNhyuBFz+kUZlKboh+ISK+bU++DmbHimVBrOz/zzPe0sZ3sQ==",
+      "dev": true,
+      "requires": {
+        "parent-module": "^1.0.0",
+        "resolve-from": "^4.0.0"
+      }
+    },
+    "imurmurhash": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=",
+      "dev": true
+    },
+    "inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
+      "dev": true,
+      "requires": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "dev": true
+    },
+    "ini": {
+      "version": "1.3.5",
+      "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.5.tgz",
+      "integrity": "sha512-RZY5huIKCMRWDUqZlEi72f/lmXKMvuszcMBduliQ3nnWbx9X/ZBQO7DijMEYS9EhHBb2qacRUMtC7svLwe0lcw==",
+      "dev": true
+    },
+    "inquirer": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-7.0.1.tgz",
+      "integrity": "sha512-V1FFQ3TIO15det8PijPLFR9M9baSlnRs9nL7zWu1MNVA2T9YVl9ZbrHJhYs7e9X8jeMZ3lr2JH/rdHFgNCBdYw==",
+      "dev": true,
+      "requires": {
+        "ansi-escapes": "^4.2.1",
+        "chalk": "^2.4.2",
+        "cli-cursor": "^3.1.0",
+        "cli-width": "^2.0.0",
+        "external-editor": "^3.0.3",
+        "figures": "^3.0.0",
+        "lodash": "^4.17.15",
+        "mute-stream": "0.0.8",
+        "run-async": "^2.2.0",
+        "rxjs": "^6.5.3",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^5.1.0",
+        "through": "^2.3.6"
+      }
+    },
+    "irregular-plurals": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/irregular-plurals/-/irregular-plurals-2.0.0.tgz",
+      "integrity": "sha512-Y75zBYLkh0lJ9qxeHlMjQ7bSbyiSqNW/UOPWDmzC7cXskL1hekSITh1Oc6JV0XCWWZ9DE8VYSB71xocLk3gmGw==",
+      "dev": true
+    },
+    "is-alphabetical": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-1.0.3.tgz",
+      "integrity": "sha512-eEMa6MKpHFzw38eKm56iNNi6GJ7lf6aLLio7Kr23sJPAECscgRtZvOBYybejWDQ2bM949Y++61PY+udzj5QMLA==",
+      "dev": true
+    },
+    "is-alphanumeric": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-alphanumeric/-/is-alphanumeric-1.0.0.tgz",
+      "integrity": "sha1-Spzvcdr0wAHB2B1j0UDPU/1oifQ=",
+      "dev": true
+    },
+    "is-alphanumerical": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-1.0.3.tgz",
+      "integrity": "sha512-A1IGAPO5AW9vSh7omxIlOGwIqEvpW/TA+DksVOPM5ODuxKlZS09+TEM1E3275lJqO2oJ38vDpeAL3DCIiHE6eA==",
+      "dev": true,
+      "requires": {
+        "is-alphabetical": "^1.0.0",
+        "is-decimal": "^1.0.0"
+      }
+    },
+    "is-arrayish": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
+      "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=",
+      "dev": true
+    },
+    "is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dev": true,
+      "requires": {
+        "binary-extensions": "^2.0.0"
+      }
+    },
+    "is-buffer": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.4.tgz",
+      "integrity": "sha512-Kq1rokWXOPXWuaMAqZiJW4XxsmD9zGx9q4aePabbn3qCRGedtH7Cm+zV8WETitMfu1wdh+Rvd6w5egwSngUX2A==",
+      "dev": true
+    },
+    "is-decimal": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/is-decimal/-/is-decimal-1.0.3.tgz",
+      "integrity": "sha512-bvLSwoDg2q6Gf+E2LEPiklHZxxiSi3XAh4Mav65mKqTfCO1HM3uBs24TjEH8iJX3bbDdLXKJXBTmGzuTUuAEjQ==",
+      "dev": true
+    },
+    "is-empty": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/is-empty/-/is-empty-1.2.0.tgz",
+      "integrity": "sha1-3pu1snhzigWgsJpX4ftNSjQan2s=",
+      "dev": true
+    },
+    "is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=",
+      "dev": true
+    },
+    "is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "dev": true
+    },
+    "is-glob": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.1.tgz",
+      "integrity": "sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==",
+      "dev": true,
+      "requires": {
+        "is-extglob": "^2.1.1"
+      }
+    },
+    "is-hexadecimal": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-1.0.3.tgz",
+      "integrity": "sha512-zxQ9//Q3D/34poZf8fiy3m3XVpbQc7ren15iKqrTtLPwkPD/t3Scy9Imp63FujULGxuK0ZlCwoo5xNpktFgbOA==",
+      "dev": true
+    },
+    "is-hidden": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/is-hidden/-/is-hidden-1.1.2.tgz",
+      "integrity": "sha512-kytBeNVW2QTIqZdJBDKIjP+EkUTzDT07rsc111w/gxqR6wK3ODkOswcpxgED6HU6t7fEhOxqojVZ2a2kU9rj+A==",
+      "dev": true
+    },
+    "is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true
+    },
+    "is-object": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-object/-/is-object-1.0.1.tgz",
+      "integrity": "sha1-iVJojF7C/9awPsyF52ngKQMINHA=",
+      "dev": true
+    },
+    "is-plain-obj": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.0.0.tgz",
+      "integrity": "sha512-EYisGhpgSCwspmIuRHGjROWTon2Xp8Z7U03Wubk/bTL5TTRC5R1rGVgyjzBrk9+ULdH6cRD06KRcw/xfqhVYKQ==",
+      "dev": true
+    },
+    "is-promise": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-2.1.0.tgz",
+      "integrity": "sha1-eaKp7OfwlugPNtKy87wWwf9L8/o=",
+      "dev": true
+    },
+    "is-stream": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz",
+      "integrity": "sha1-EtSj3U5o4Lec6428hBc66A2RykQ=",
+      "dev": true
+    },
+    "is-typedarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz",
+      "integrity": "sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=",
+      "dev": true
+    },
+    "is-whitespace-character": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/is-whitespace-character/-/is-whitespace-character-1.0.3.tgz",
+      "integrity": "sha512-SNPgMLz9JzPccD3nPctcj8sZlX9DAMJSKH8bP7Z6bohCwuNgX8xbWr1eTAYXX9Vpi/aSn8Y1akL9WgM3t43YNQ==",
+      "dev": true
+    },
+    "is-word-character": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/is-word-character/-/is-word-character-1.0.3.tgz",
+      "integrity": "sha512-0wfcrFgOOOBdgRNT9H33xe6Zi6yhX/uoc4U8NBZGeQQB0ctU1dnlNTyL9JM2646bHDTpsDm1Brb3VPoCIMrd/A==",
+      "dev": true
+    },
+    "isarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
+      "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=",
+      "dev": true,
+      "optional": true
+    },
+    "isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=",
+      "dev": true
+    },
+    "isstream": {
+      "version": "0.1.2",
+      "resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz",
+      "integrity": "sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=",
+      "dev": true
+    },
+    "istanbul-lib-coverage": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.5.tgz",
+      "integrity": "sha512-8aXznuEPCJvGnMSRft4udDRDtb1V3pkQkMMI5LI+6HuQz5oQ4J2UFn1H82raA3qJtyOLkkwVqICBQkjnGtn5mA==",
+      "dev": true
+    },
+    "istanbul-lib-hook": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/istanbul-lib-hook/-/istanbul-lib-hook-2.0.7.tgz",
+      "integrity": "sha512-vrRztU9VRRFDyC+aklfLoeXyNdTfga2EI3udDGn4cZ6fpSXpHLV9X6CHvfoMCPtggg8zvDDmC4b9xfu0z6/llA==",
+      "dev": true,
+      "requires": {
+        "append-transform": "^1.0.0"
+      }
+    },
+    "istanbul-lib-instrument": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-3.3.0.tgz",
+      "integrity": "sha512-5nnIN4vo5xQZHdXno/YDXJ0G+I3dAm4XgzfSVTPLQpj/zAV2dV6Juy0yaf10/zrJOJeHoN3fraFe+XRq2bFVZA==",
+      "dev": true,
+      "requires": {
+        "@babel/generator": "^7.4.0",
+        "@babel/parser": "^7.4.3",
+        "@babel/template": "^7.4.0",
+        "@babel/traverse": "^7.4.3",
+        "@babel/types": "^7.4.0",
+        "istanbul-lib-coverage": "^2.0.5",
+        "semver": "^6.0.0"
+      }
+    },
+    "istanbul-lib-processinfo": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/istanbul-lib-processinfo/-/istanbul-lib-processinfo-1.0.0.tgz",
+      "integrity": "sha512-FY0cPmWa4WoQNlvB8VOcafiRoB5nB+l2Pz2xGuXHRSy1KM8QFOYfz/rN+bGMCAeejrY3mrpF5oJHcN0s/garCg==",
+      "dev": true,
+      "requires": {
+        "archy": "^1.0.0",
+        "cross-spawn": "^6.0.5",
+        "istanbul-lib-coverage": "^2.0.3",
+        "rimraf": "^2.6.3",
+        "uuid": "^3.3.2"
+      }
+    },
+    "istanbul-lib-report": {
+      "version": "2.0.8",
+      "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-2.0.8.tgz",
+      "integrity": "sha512-fHBeG573EIihhAblwgxrSenp0Dby6tJMFR/HvlerBsrCTD5bkUuoNtn3gVh29ZCS824cGGBPn7Sg7cNk+2xUsQ==",
+      "dev": true,
+      "requires": {
+        "istanbul-lib-coverage": "^2.0.5",
+        "make-dir": "^2.1.0",
+        "supports-color": "^6.1.0"
+      },
+      "dependencies": {
+        "supports-color": {
+          "version": "6.1.0",
+          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-6.1.0.tgz",
+          "integrity": "sha512-qe1jfm1Mg7Nq/NSh6XE24gPXROEVsWHxC1LIx//XNlD9iw7YZQGjZNjYN7xGaEG6iKdA8EtNFW6R0gjnVXp+wQ==",
+          "dev": true,
+          "requires": {
+            "has-flag": "^3.0.0"
+          }
+        }
+      }
+    },
+    "istanbul-lib-source-maps": {
+      "version": "3.0.6",
+      "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-3.0.6.tgz",
+      "integrity": "sha512-R47KzMtDJH6X4/YW9XTx+jrLnZnscW4VpNN+1PViSYTejLVPWv7oov+Duf8YQSPyVRUvueQqz1TcsC6mooZTXw==",
+      "dev": true,
+      "requires": {
+        "debug": "^4.1.1",
+        "istanbul-lib-coverage": "^2.0.5",
+        "make-dir": "^2.1.0",
+        "rimraf": "^2.6.3",
+        "source-map": "^0.6.1"
+      }
+    },
+    "istanbul-reports": {
+      "version": "2.2.6",
+      "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-2.2.6.tgz",
+      "integrity": "sha512-SKi4rnMyLBKe0Jy2uUdx28h8oG7ph2PPuQPvIAh31d+Ci+lSiEu4C+h3oBPuJ9+mPKhOyW0M8gY4U5NM1WLeXA==",
+      "dev": true,
+      "requires": {
+        "handlebars": "^4.1.2"
+      }
+    },
+    "jackspeak": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-1.4.0.tgz",
+      "integrity": "sha512-VDcSunT+wcccoG46FtzuBAyQKlzhHjli4q31e1fIHGOsRspqNUFjVzGb+7eIFDlTvqLygxapDHPHS0ouT2o/tw==",
+      "dev": true,
+      "requires": {
+        "cliui": "^4.1.0"
+      }
+    },
+    "js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "dev": true
+    },
+    "js-yaml": {
+      "version": "3.13.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.13.1.tgz",
+      "integrity": "sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw==",
+      "dev": true,
+      "requires": {
+        "argparse": "^1.0.7",
+        "esprima": "^4.0.0"
+      }
+    },
+    "jsbn": {
+      "version": "0.1.1",
+      "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz",
+      "integrity": "sha1-peZUwuWi3rXyAdls77yoDA7y9RM=",
+      "dev": true
+    },
+    "jsesc": {
+      "version": "2.5.2",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz",
+      "integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==",
+      "dev": true
+    },
+    "json-parse-better-errors": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz",
+      "integrity": "sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==",
+      "dev": true
+    },
+    "json-schema": {
+      "version": "0.2.3",
+      "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.2.3.tgz",
+      "integrity": "sha1-tIDIkuWaLwWVTOcnvT8qTogvnhM=",
+      "dev": true
+    },
+    "json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "dev": true
+    },
+    "json-stable-stringify-without-jsonify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+      "integrity": "sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=",
+      "dev": true
+    },
+    "json-stringify-safe": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz",
+      "integrity": "sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=",
+      "dev": true
+    },
+    "json5": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.1.1.tgz",
+      "integrity": "sha512-l+3HXD0GEI3huGq1njuqtzYK8OYJyXMkOLtQ53pjWh89tvWS2h6l+1zMkYWqlb57+SiQodKZyvMEFb2X+KrFhQ==",
+      "dev": true,
+      "requires": {
+        "minimist": "^1.2.0"
+      },
+      "dependencies": {
+        "minimist": {
+          "version": "1.2.0",
+          "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
+          "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
+          "dev": true
+        }
+      }
+    },
+    "jsprim": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.4.1.tgz",
+      "integrity": "sha1-MT5mvB5cwG5Di8G3SZwuXFastqI=",
+      "dev": true,
+      "requires": {
+        "assert-plus": "1.0.0",
+        "extsprintf": "1.3.0",
+        "json-schema": "0.2.3",
+        "verror": "1.10.0"
+      }
+    },
+    "lcov-parse": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/lcov-parse/-/lcov-parse-1.0.0.tgz",
+      "integrity": "sha1-6w1GtUER68VhrLTECO+TY73I9+A=",
+      "dev": true
+    },
+    "levn": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz",
+      "integrity": "sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=",
+      "dev": true,
+      "requires": {
+        "prelude-ls": "~1.1.2",
+        "type-check": "~0.3.2"
+      }
+    },
+    "load-json-file": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-4.0.0.tgz",
+      "integrity": "sha1-L19Fq5HjMhYjT9U62rZo607AmTs=",
+      "dev": true,
+      "requires": {
+        "graceful-fs": "^4.1.2",
+        "parse-json": "^4.0.0",
+        "pify": "^3.0.0",
+        "strip-bom": "^3.0.0"
+      },
+      "dependencies": {
+        "pify": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz",
+          "integrity": "sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=",
+          "dev": true
+        }
+      }
+    },
+    "load-plugin": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/load-plugin/-/load-plugin-2.3.1.tgz",
+      "integrity": "sha512-dYB1lbwqHgPTrruy9glukCu8Ya9vzj6TMfouCtj2H/GuJ+8syioisgKTBPxnCi6m8K8jINKfTOxOHngFkUYqHw==",
+      "dev": true,
+      "requires": {
+        "npm-prefix": "^1.2.0",
+        "resolve-from": "^5.0.0"
+      },
+      "dependencies": {
+        "resolve-from": {
+          "version": "5.0.0",
+          "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz",
+          "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==",
+          "dev": true
+        }
+      }
+    },
+    "locate-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz",
+      "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==",
+      "dev": true,
+      "requires": {
+        "p-locate": "^3.0.0",
+        "path-exists": "^3.0.0"
+      }
+    },
+    "lodash": {
+      "version": "4.17.15",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.15.tgz",
+      "integrity": "sha512-8xOcRHvCjnocdS5cpwXQXVzmmh5e5+saE2QGoeQmbKmRS6J3VQppPOIt0MnmE+4xlZoumy0GPG0D0MVIQbNA1A==",
+      "dev": true
+    },
+    "lodash.flattendeep": {
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/lodash.flattendeep/-/lodash.flattendeep-4.4.0.tgz",
+      "integrity": "sha1-+wMJF/hqMTTlvJvsDWngAT3f7bI=",
+      "dev": true
+    },
+    "log-driver": {
+      "version": "1.2.7",
+      "resolved": "https://registry.npmjs.org/log-driver/-/log-driver-1.2.7.tgz",
+      "integrity": "sha512-U7KCmLdqsGHBLeWqYlFA0V0Sl6P08EE1ZrmA9cxjUE0WVqT9qnyVDPz1kzpFEP0jdJuFnasWIfSd7fsaNXkpbg==",
+      "dev": true
+    },
+    "longest-streak": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-2.0.3.tgz",
+      "integrity": "sha512-9lz5IVdpwsKLMzQi0MQ+oD9EA0mIGcWYP7jXMTZVXP8D42PwuAk+M/HBFYQoxt1G5OR8m7aSIgb1UymfWGBWEw==",
+      "dev": true
+    },
+    "loose-envify": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+      "dev": true,
+      "requires": {
+        "js-tokens": "^3.0.0 || ^4.0.0"
+      }
+    },
+    "lru-cache": {
+      "version": "4.1.5",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.5.tgz",
+      "integrity": "sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==",
+      "dev": true,
+      "requires": {
+        "pseudomap": "^1.0.2",
+        "yallist": "^2.1.2"
+      }
+    },
+    "make-dir": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-2.1.0.tgz",
+      "integrity": "sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA==",
+      "dev": true,
+      "requires": {
+        "pify": "^4.0.1",
+        "semver": "^5.6.0"
+      },
+      "dependencies": {
+        "semver": {
+          "version": "5.7.1",
+          "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz",
+          "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==",
+          "dev": true
+        }
+      }
+    },
+    "make-error": {
+      "version": "1.3.5",
+      "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.5.tgz",
+      "integrity": "sha512-c3sIjNUow0+8swNwVpqoH4YCShKNFkMaw6oH1mNS2haDZQqkeZFlHS3dhoeEbKKmJB4vXpJucU6oH75aDYeE9g==",
+      "dev": true
+    },
+    "markdown-escapes": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/markdown-escapes/-/markdown-escapes-1.0.3.tgz",
+      "integrity": "sha512-XUi5HJhhV5R74k8/0H2oCbCiYf/u4cO/rX8tnGkRvrqhsr5BRNU6Mg0yt/8UIx1iIS8220BNJsDb7XnILhLepw==",
+      "dev": true
+    },
+    "markdown-extensions": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/markdown-extensions/-/markdown-extensions-1.1.1.tgz",
+      "integrity": "sha512-WWC0ZuMzCyDHYCasEGs4IPvLyTGftYwh6wIEOULOF0HXcqZlhwRzrK0w2VUlxWA98xnvb/jszw4ZSkJ6ADpM6Q==",
+      "dev": true
+    },
+    "markdown-table": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-1.1.3.tgz",
+      "integrity": "sha512-1RUZVgQlpJSPWYbFSpmudq5nHY1doEIv89gBtF0s4gW1GF2XorxcA/70M5vq7rLv0a6mhOUccRsqkwhwLCIQ2Q==",
+      "dev": true
+    },
+    "mdast-comment-marker": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/mdast-comment-marker/-/mdast-comment-marker-1.1.1.tgz",
+      "integrity": "sha512-TWZDaUtPLwKX1pzDIY48MkSUQRDwX/HqbTB4m3iYdL/zosi/Z6Xqfdv0C0hNVKvzrPjZENrpWDt4p4odeVO0Iw==",
+      "dev": true
+    },
+    "mdast-util-compact": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/mdast-util-compact/-/mdast-util-compact-1.0.4.tgz",
+      "integrity": "sha512-3YDMQHI5vRiS2uygEFYaqckibpJtKq5Sj2c8JioeOQBU6INpKbdWzfyLqFFnDwEcEnRFIdMsguzs5pC1Jp4Isg==",
+      "dev": true,
+      "requires": {
+        "unist-util-visit": "^1.1.0"
+      }
+    },
+    "mdast-util-heading-style": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/mdast-util-heading-style/-/mdast-util-heading-style-1.0.5.tgz",
+      "integrity": "sha512-8zQkb3IUwiwOdUw6jIhnwM6DPyib+mgzQuHAe7j2Hy1rIarU4VUxe472bp9oktqULW3xqZE+Kz6OD4Gi7IA3vw==",
+      "dev": true
+    },
+    "mdast-util-to-string": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-1.0.6.tgz",
+      "integrity": "sha512-868pp48gUPmZIhfKrLbaDneuzGiw3OTDjHc5M1kAepR2CWBJ+HpEsm252K4aXdiP5coVZaJPOqGtVU6Po8xnXg==",
+      "dev": true
+    },
+    "merge-source-map": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/merge-source-map/-/merge-source-map-1.1.0.tgz",
+      "integrity": "sha512-Qkcp7P2ygktpMPh2mCQZaf3jhN6D3Z/qVZHSdWvQ+2Ef5HgRAPBO57A77+ENm0CPx2+1Ce/MYKi3ymqdfuqibw==",
+      "dev": true,
+      "requires": {
+        "source-map": "^0.6.1"
+      }
+    },
+    "mime-db": {
+      "version": "1.42.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.42.0.tgz",
+      "integrity": "sha512-UbfJCR4UAVRNgMpfImz05smAXK7+c+ZntjaA26ANtkXLlOe947Aag5zdIcKQULAiF9Cq4WxBi9jUs5zkA84bYQ==",
+      "dev": true
+    },
+    "mime-types": {
+      "version": "2.1.25",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.25.tgz",
+      "integrity": "sha512-5KhStqB5xpTAeGqKBAMgwaYMnQik7teQN4IAzC7npDv6kzeU6prfkR67bc87J1kWMPGkoaZSq1npmexMgkmEVg==",
+      "dev": true,
+      "requires": {
+        "mime-db": "1.42.0"
+      }
+    },
+    "mimic-fn": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz",
+      "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==",
+      "dev": true
+    },
+    "minimatch": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
+      "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
+      "dev": true,
+      "requires": {
+        "brace-expansion": "^1.1.7"
+      }
+    },
+    "minimist": {
+      "version": "0.0.8",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz",
+      "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=",
+      "dev": true
+    },
+    "minipass": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.1.1.tgz",
+      "integrity": "sha512-UFqVihv6PQgwj8/yTGvl9kPz7xIAY+R5z6XYjRInD3Gk3qx6QGSD6zEcpeG4Dy/lQnv1J6zv8ejV90hyYIKf3w==",
+      "dev": true,
+      "requires": {
+        "yallist": "^4.0.0"
+      },
+      "dependencies": {
+        "yallist": {
+          "version": "4.0.0",
+          "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+          "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+          "dev": true
+        }
+      }
+    },
+    "mkdirp": {
+      "version": "0.5.1",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz",
+      "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=",
+      "dev": true,
+      "requires": {
+        "minimist": "0.0.8"
+      }
+    },
+    "ms": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+      "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
+      "dev": true
+    },
+    "mute-stream": {
+      "version": "0.0.8",
+      "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.8.tgz",
+      "integrity": "sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA==",
+      "dev": true
+    },
+    "natural-compare": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+      "integrity": "sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=",
+      "dev": true
+    },
+    "neo-async": {
+      "version": "2.6.1",
+      "resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.1.tgz",
+      "integrity": "sha512-iyam8fBuCUpWeKPGpaNMetEocMt364qkCsfL9JuhjXX6dRnguRVOfk2GZaDpPjcOKiiXCPINZC1GczQ7iTq3Zw==",
+      "dev": true
+    },
+    "nested-error-stacks": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/nested-error-stacks/-/nested-error-stacks-2.1.0.tgz",
+      "integrity": "sha512-AO81vsIO1k1sM4Zrd6Hu7regmJN1NSiAja10gc4bX3F0wd+9rQmcuHQaHVQCYIEC8iFXnE+mavh23GOt7wBgug==",
+      "dev": true
+    },
+    "nice-try": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/nice-try/-/nice-try-1.0.5.tgz",
+      "integrity": "sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==",
+      "dev": true
+    },
+    "node-modules-regexp": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/node-modules-regexp/-/node-modules-regexp-1.0.0.tgz",
+      "integrity": "sha1-jZ2+KJZKSsVxLpExZCEHxx6Q7EA=",
+      "dev": true
+    },
+    "normalize-package-data": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz",
+      "integrity": "sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==",
+      "dev": true,
+      "requires": {
+        "hosted-git-info": "^2.1.4",
+        "resolve": "^1.10.0",
+        "semver": "2 || 3 || 4 || 5",
+        "validate-npm-package-license": "^3.0.1"
+      },
+      "dependencies": {
+        "semver": {
+          "version": "5.7.1",
+          "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz",
+          "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==",
+          "dev": true
+        }
+      }
+    },
+    "normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true
+    },
+    "npm-prefix": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/npm-prefix/-/npm-prefix-1.2.0.tgz",
+      "integrity": "sha1-5hlFX3B0ulTMZtbQ033Z8b5ry8A=",
+      "dev": true,
+      "requires": {
+        "rc": "^1.1.0",
+        "shellsubstitute": "^1.1.0",
+        "untildify": "^2.1.0"
+      }
+    },
+    "number-is-nan": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz",
+      "integrity": "sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=",
+      "dev": true
+    },
+    "nyc": {
+      "version": "14.1.1",
+      "resolved": "https://registry.npmjs.org/nyc/-/nyc-14.1.1.tgz",
+      "integrity": "sha512-OI0vm6ZGUnoGZv/tLdZ2esSVzDwUC88SNs+6JoSOMVxA+gKMB8Tk7jBwgemLx4O40lhhvZCVw1C+OYLOBOPXWw==",
+      "dev": true,
+      "requires": {
+        "archy": "^1.0.0",
+        "caching-transform": "^3.0.2",
+        "convert-source-map": "^1.6.0",
+        "cp-file": "^6.2.0",
+        "find-cache-dir": "^2.1.0",
+        "find-up": "^3.0.0",
+        "foreground-child": "^1.5.6",
+        "glob": "^7.1.3",
+        "istanbul-lib-coverage": "^2.0.5",
+        "istanbul-lib-hook": "^2.0.7",
+        "istanbul-lib-instrument": "^3.3.0",
+        "istanbul-lib-report": "^2.0.8",
+        "istanbul-lib-source-maps": "^3.0.6",
+        "istanbul-reports": "^2.2.4",
+        "js-yaml": "^3.13.1",
+        "make-dir": "^2.1.0",
+        "merge-source-map": "^1.1.0",
+        "resolve-from": "^4.0.0",
+        "rimraf": "^2.6.3",
+        "signal-exit": "^3.0.2",
+        "spawn-wrap": "^1.4.2",
+        "test-exclude": "^5.2.3",
+        "uuid": "^3.3.2",
+        "yargs": "^13.2.2",
+        "yargs-parser": "^13.0.0"
+      }
+    },
+    "oauth-sign": {
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.9.0.tgz",
+      "integrity": "sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==",
+      "dev": true
+    },
+    "object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=",
+      "dev": true
+    },
+    "once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
+      "dev": true,
+      "requires": {
+        "wrappy": "1"
+      }
+    },
+    "onetime": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.0.tgz",
+      "integrity": "sha512-5NcSkPHhwTVFIQN+TUqXoS5+dlElHXdpAWu9I0HP20YOtIi+aZ0Ct82jdlILDxjLEAWwvm+qj1m6aEtsDVmm6Q==",
+      "dev": true,
+      "requires": {
+        "mimic-fn": "^2.1.0"
+      }
+    },
+    "opener": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/opener/-/opener-1.5.1.tgz",
+      "integrity": "sha512-goYSy5c2UXE4Ra1xixabeVh1guIX/ZV/YokJksb6q2lubWu6UbvPQ20p542/sFIll1nl8JnCyK9oBaOcCWXwvA==",
+      "dev": true
+    },
+    "optimist": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/optimist/-/optimist-0.6.1.tgz",
+      "integrity": "sha1-2j6nRob6IaGaERwybpDrFaAZZoY=",
+      "dev": true,
+      "requires": {
+        "minimist": "~0.0.1",
+        "wordwrap": "~0.0.2"
+      }
+    },
+    "optionator": {
+      "version": "0.8.3",
+      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.3.tgz",
+      "integrity": "sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==",
+      "dev": true,
+      "requires": {
+        "deep-is": "~0.1.3",
+        "fast-levenshtein": "~2.0.6",
+        "levn": "~0.3.0",
+        "prelude-ls": "~1.1.2",
+        "type-check": "~0.3.2",
+        "word-wrap": "~1.2.3"
+      }
+    },
+    "os-homedir": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/os-homedir/-/os-homedir-1.0.2.tgz",
+      "integrity": "sha1-/7xJiDNuDoM94MFox+8VISGqf7M=",
+      "dev": true
+    },
+    "os-tmpdir": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz",
+      "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=",
+      "dev": true
+    },
+    "own-or": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/own-or/-/own-or-1.0.0.tgz",
+      "integrity": "sha1-Tod/vtqaLsgAD7wLyuOWRe6L+Nw=",
+      "dev": true
+    },
+    "own-or-env": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/own-or-env/-/own-or-env-1.0.1.tgz",
+      "integrity": "sha512-y8qULRbRAlL6x2+M0vIe7jJbJx/kmUTzYonRAa2ayesR2qWLswninkVyeJe4x3IEXhdgoNodzjQRKAoEs6Fmrw==",
+      "dev": true,
+      "requires": {
+        "own-or": "^1.0.0"
+      }
+    },
+    "p-limit": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.2.1.tgz",
+      "integrity": "sha512-85Tk+90UCVWvbDavCLKPOLC9vvY8OwEX/RtKF+/1OADJMVlFfEHOiMTPVyxg7mk/dKa+ipdHm0OUkTvCpMTuwg==",
+      "dev": true,
+      "requires": {
+        "p-try": "^2.0.0"
+      }
+    },
+    "p-locate": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz",
+      "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==",
+      "dev": true,
+      "requires": {
+        "p-limit": "^2.0.0"
+      }
+    },
+    "p-try": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz",
+      "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==",
+      "dev": true
+    },
+    "package-hash": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/package-hash/-/package-hash-3.0.0.tgz",
+      "integrity": "sha512-lOtmukMDVvtkL84rJHI7dpTYq+0rli8N2wlnqUcBuDWCfVhRUfOmnR9SsoHFMLpACvEV60dX7rd0rFaYDZI+FA==",
+      "dev": true,
+      "requires": {
+        "graceful-fs": "^4.1.15",
+        "hasha": "^3.0.0",
+        "lodash.flattendeep": "^4.4.0",
+        "release-zalgo": "^1.0.0"
+      }
+    },
+    "parent-module": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+      "dev": true,
+      "requires": {
+        "callsites": "^3.0.0"
+      }
+    },
+    "parse-entities": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-1.2.2.tgz",
+      "integrity": "sha512-NzfpbxW/NPrzZ/yYSoQxyqUZMZXIdCfE0OIN4ESsnptHJECoUk3FZktxNuzQf4tjt5UEopnxpYJbvYuxIFDdsg==",
+      "dev": true,
+      "requires": {
+        "character-entities": "^1.0.0",
+        "character-entities-legacy": "^1.0.0",
+        "character-reference-invalid": "^1.0.0",
+        "is-alphanumerical": "^1.0.0",
+        "is-decimal": "^1.0.0",
+        "is-hexadecimal": "^1.0.0"
+      }
+    },
+    "parse-json": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-4.0.0.tgz",
+      "integrity": "sha1-vjX1Qlvh9/bHRxhPmKeIy5lHfuA=",
+      "dev": true,
+      "requires": {
+        "error-ex": "^1.3.1",
+        "json-parse-better-errors": "^1.0.1"
+      }
+    },
+    "path-exists": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz",
+      "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=",
+      "dev": true
+    },
+    "path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
+      "dev": true
+    },
+    "path-key": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz",
+      "integrity": "sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=",
+      "dev": true
+    },
+    "path-parse": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz",
+      "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==",
+      "dev": true
+    },
+    "path-type": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/path-type/-/path-type-3.0.0.tgz",
+      "integrity": "sha512-T2ZUsdZFHgA3u4e5PfPbjd7HDDpxPnQb5jN0SrDsjNSuVXHJqtwTnWqG0B1jZrgmJ/7lj1EmVIByWt1gxGkWvg==",
+      "dev": true,
+      "requires": {
+        "pify": "^3.0.0"
+      },
+      "dependencies": {
+        "pify": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz",
+          "integrity": "sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=",
+          "dev": true
+        }
+      }
+    },
+    "performance-now": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz",
+      "integrity": "sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=",
+      "dev": true
+    },
+    "picomatch": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.1.1.tgz",
+      "integrity": "sha512-OYMyqkKzK7blWO/+XZYP6w8hH0LDvkBvdvKukti+7kqYFCiEAk+gI3DWnryapc0Dau05ugGTy0foQ6mqn4AHYA==",
+      "dev": true
+    },
+    "pify": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz",
+      "integrity": "sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==",
+      "dev": true
+    },
+    "pirates": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/pirates/-/pirates-3.0.2.tgz",
+      "integrity": "sha512-c5CgUJq6H2k6MJz72Ak1F5sN9n9wlSlJyEnwvpm9/y3WB4E3pHBDT2c6PEiS1vyJvq2bUxUAIu0EGf8Cx4Ic7Q==",
+      "dev": true,
+      "requires": {
+        "node-modules-regexp": "^1.0.0"
+      }
+    },
+    "pkg-dir": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-3.0.0.tgz",
+      "integrity": "sha512-/E57AYkoeQ25qkxMj5PBOVgF8Kiu/h7cYS30Z5+R7WaiCCBfLq58ZI/dSeaEKb9WVJV5n/03QwrN3IeWIFllvw==",
+      "dev": true,
+      "requires": {
+        "find-up": "^3.0.0"
+      }
+    },
+    "plur": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/plur/-/plur-3.1.1.tgz",
+      "integrity": "sha512-t1Ax8KUvV3FFII8ltczPn2tJdjqbd1sIzu6t4JL7nQ3EyeL/lTrj5PWKb06ic5/6XYDr65rQ4uzQEGN70/6X5w==",
+      "dev": true,
+      "requires": {
+        "irregular-plurals": "^2.0.0"
+      }
+    },
+    "prelude-ls": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz",
+      "integrity": "sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=",
+      "dev": true
+    },
+    "process-nextick-args": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
+      "dev": true,
+      "optional": true
+    },
+    "progress": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz",
+      "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==",
+      "dev": true
+    },
+    "prop-types": {
+      "version": "15.7.2",
+      "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.7.2.tgz",
+      "integrity": "sha512-8QQikdH7//R2vurIJSutZ1smHYTcLpRWEOlHnzcWHmBYrOGUysKwSsrC89BCiFj3CbrfJ/nXFdJepOVrY1GCHQ==",
+      "dev": true,
+      "requires": {
+        "loose-envify": "^1.4.0",
+        "object-assign": "^4.1.1",
+        "react-is": "^16.8.1"
+      }
+    },
+    "pseudomap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz",
+      "integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM=",
+      "dev": true
+    },
+    "psl": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/psl/-/psl-1.6.0.tgz",
+      "integrity": "sha512-SYKKmVel98NCOYXpkwUqZqh0ahZeeKfmisiLIcEZdsb+WbLv02g/dI5BUmZnIyOe7RzZtLax81nnb2HbvC2tzA==",
+      "dev": true
+    },
+    "punycode": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz",
+      "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==",
+      "dev": true
+    },
+    "qs": {
+      "version": "6.5.2",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.2.tgz",
+      "integrity": "sha512-N5ZAX4/LxJmF+7wN74pUD6qAh9/wnvdQcjq9TZjevvXzSUo7bfmw91saqMjzGS2xq91/odN2dW/WOl7qQHNDGA==",
+      "dev": true
+    },
+    "rc": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz",
+      "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==",
+      "dev": true,
+      "requires": {
+        "deep-extend": "^0.6.0",
+        "ini": "~1.3.0",
+        "minimist": "^1.2.0",
+        "strip-json-comments": "~2.0.1"
+      },
+      "dependencies": {
+        "minimist": {
+          "version": "1.2.0",
+          "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
+          "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
+          "dev": true
+        },
+        "strip-json-comments": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
+          "integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo=",
+          "dev": true
+        }
+      }
+    },
+    "react": {
+      "version": "16.12.0",
+      "resolved": "https://registry.npmjs.org/react/-/react-16.12.0.tgz",
+      "integrity": "sha512-fglqy3k5E+81pA8s+7K0/T3DBCF0ZDOher1elBFzF7O6arXJgzyu/FW+COxFvAWXJoJN9KIZbT2LXlukwphYTA==",
+      "dev": true,
+      "requires": {
+        "loose-envify": "^1.1.0",
+        "object-assign": "^4.1.1",
+        "prop-types": "^15.6.2"
+      }
+    },
+    "react-is": {
+      "version": "16.12.0",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.12.0.tgz",
+      "integrity": "sha512-rPCkf/mWBtKc97aLL9/txD8DZdemK0vkA3JMLShjlJB3Pj3s+lpf1KaBzMfQrAmhMQB0n1cU/SUGgKKBCe837Q==",
+      "dev": true
+    },
+    "read-pkg": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-3.0.0.tgz",
+      "integrity": "sha1-nLxoaXj+5l0WwA4rGcI3/Pbjg4k=",
+      "dev": true,
+      "requires": {
+        "load-json-file": "^4.0.0",
+        "normalize-package-data": "^2.3.2",
+        "path-type": "^3.0.0"
+      }
+    },
+    "read-pkg-up": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-4.0.0.tgz",
+      "integrity": "sha512-6etQSH7nJGsK0RbG/2TeDzZFa8shjQ1um+SwQQ5cwKy0dhSXdOncEhb1CPpvQG4h7FyOV6EB6YlV0yJvZQNAkA==",
+      "dev": true,
+      "requires": {
+        "find-up": "^3.0.0",
+        "read-pkg": "^3.0.0"
+      }
+    },
+    "readable-stream": {
+      "version": "3.4.0",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.4.0.tgz",
+      "integrity": "sha512-jItXPLmrSR8jmTRmRWJXCnGJsfy85mB3Wd/uINMXA65yrnFo0cPClFIUWzo2najVNSl+mx7/4W8ttlLWJe99pQ==",
+      "dev": true,
+      "requires": {
+        "inherits": "^2.0.3",
+        "string_decoder": "^1.1.1",
+        "util-deprecate": "^1.0.1"
+      }
+    },
+    "readdirp": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.2.0.tgz",
+      "integrity": "sha512-crk4Qu3pmXwgxdSgGhgA/eXiJAPQiX4GMOZZMXnqKxHX7TaoL+3gQVo/WeuAiogr07DpnfjIMpXXa+PAIvwPGQ==",
+      "dev": true,
+      "requires": {
+        "picomatch": "^2.0.4"
+      }
+    },
+    "regenerator-runtime": {
+      "version": "0.13.3",
+      "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.3.tgz",
+      "integrity": "sha512-naKIZz2GQ8JWh///G7L3X6LaQUAMp2lvb1rvwwsURe/VXwD6VMfr+/1NuNw3ag8v2kY1aQ/go5SNn79O9JU7yw==",
+      "dev": true
+    },
+    "regexpp": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/regexpp/-/regexpp-2.0.1.tgz",
+      "integrity": "sha512-lv0M6+TkDVniA3aD1Eg0DVpfU/booSu7Eev3TDO/mZKHBfVjgCGTV4t4buppESEYDtkArYFOxTJWv6S5C+iaNw==",
+      "dev": true
+    },
+    "release-zalgo": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/release-zalgo/-/release-zalgo-1.0.0.tgz",
+      "integrity": "sha1-CXALflB0Mpc5Mw5TXFqQ+2eFFzA=",
+      "dev": true,
+      "requires": {
+        "es6-error": "^4.0.1"
+      }
+    },
+    "remark": {
+      "version": "11.0.2",
+      "resolved": "https://registry.npmjs.org/remark/-/remark-11.0.2.tgz",
+      "integrity": "sha512-bh+eJgn8wgmbHmIBOuwJFdTVRVpl3fcVP6HxmpPWO0ULGP9Qkh6INJh0N5Uy7GqlV7DQYGoqaKiEIpM5LLvJ8w==",
+      "dev": true,
+      "requires": {
+        "remark-parse": "^7.0.0",
+        "remark-stringify": "^7.0.0",
+        "unified": "^8.2.0"
+      }
+    },
+    "remark-cli": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/remark-cli/-/remark-cli-7.0.1.tgz",
+      "integrity": "sha512-CUjBLLSbEay0mNwOO+pptnLIoS8UB6cHlhZVpTRKbtbIcw6YEzEfD7jGjW1HCA8lZK87IfY3/DuWE6DlXu+hfg==",
+      "dev": true,
+      "requires": {
+        "markdown-extensions": "^1.1.0",
+        "remark": "^11.0.0",
+        "unified-args": "^7.0.0"
+      }
+    },
+    "remark-lint": {
+      "version": "6.0.5",
+      "resolved": "https://registry.npmjs.org/remark-lint/-/remark-lint-6.0.5.tgz",
+      "integrity": "sha512-o1I3ddm+KNsTxk60wWGI+p2yU1jB1gcm8jo2Sy6VhJ4ab2TrQIp1oQbp5xeLoFXYSh/NAqCpKjHkCM/BYpkFdQ==",
+      "dev": true,
+      "requires": {
+        "remark-message-control": "^4.0.0"
+      }
+    },
+    "remark-lint-final-newline": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/remark-lint-final-newline/-/remark-lint-final-newline-1.0.3.tgz",
+      "integrity": "sha512-ETAadktv75EwUS3XDhyZUVstXKxfPAEn7SmfN9kZ4+Jb4qo4hHE9gtTOzhE6HxLUxxl9BBhpC5mMO3JcL8UZ5A==",
+      "dev": true,
+      "requires": {
+        "unified-lint-rule": "^1.0.0"
+      }
+    },
+    "remark-lint-hard-break-spaces": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/remark-lint-hard-break-spaces/-/remark-lint-hard-break-spaces-1.0.4.tgz",
+      "integrity": "sha512-YM82UpgliZCZhGNmFxEe7ArfhqR5CplFf2bc0k0+8w3rKWKx7EJcGMar2NK410tIi40gGeWtH/pIEypPJFCCiA==",
+      "dev": true,
+      "requires": {
+        "unified-lint-rule": "^1.0.0",
+        "unist-util-generated": "^1.1.0",
+        "unist-util-position": "^3.0.0",
+        "unist-util-visit": "^1.1.1"
+      }
+    },
+    "remark-lint-list-item-bullet-indent": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/remark-lint-list-item-bullet-indent/-/remark-lint-list-item-bullet-indent-1.0.3.tgz",
+      "integrity": "sha512-iVxQbrgzLpMHG3C6o6wRta/+Bc96etOiBYJnh2zm/aWz6DJ7cGLDykngblP/C4he7LYSeWOD/8Y57HbXZwM2Og==",
+      "dev": true,
+      "requires": {
+        "plur": "^3.0.0",
+        "unified-lint-rule": "^1.0.0",
+        "unist-util-generated": "^1.1.0",
+        "unist-util-position": "^3.0.0",
+        "unist-util-visit": "^1.1.1"
+      }
+    },
+    "remark-lint-list-item-indent": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/remark-lint-list-item-indent/-/remark-lint-list-item-indent-1.0.4.tgz",
+      "integrity": "sha512-Sv0gVH6qP1/nFpbJuyyguB9sAD2o42StD2WbEZeUcEexXwRO4u/YaX0Pm5pMtCiEHyN+qyL6ShKBQMtgol9BeA==",
+      "dev": true,
+      "requires": {
+        "plur": "^3.0.0",
+        "unified-lint-rule": "^1.0.0",
+        "unist-util-generated": "^1.1.0",
+        "unist-util-position": "^3.0.0",
+        "unist-util-visit": "^1.1.1"
+      }
+    },
+    "remark-lint-no-auto-link-without-protocol": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-auto-link-without-protocol/-/remark-lint-no-auto-link-without-protocol-1.0.3.tgz",
+      "integrity": "sha512-k+hg2mXnO4Q9WV+UShPLen5oThvFxcRVWkx2hviVd/nu3eiszBKH3o38csBwjeJoMG3l2ZhdUW8dlOBhq8670Q==",
+      "dev": true,
+      "requires": {
+        "mdast-util-to-string": "^1.0.2",
+        "unified-lint-rule": "^1.0.0",
+        "unist-util-generated": "^1.1.0",
+        "unist-util-position": "^3.0.0",
+        "unist-util-visit": "^1.1.1"
+      }
+    },
+    "remark-lint-no-blockquote-without-marker": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-blockquote-without-marker/-/remark-lint-no-blockquote-without-marker-2.0.3.tgz",
+      "integrity": "sha512-faDzKrA6aKidsRXG6gcIlCO8TexLxIxe+n9B3mdnl8mhZGgE0FfWTkIWVMj0IYps/xVsVMf45KxhXgc1wU9kwg==",
+      "dev": true,
+      "requires": {
+        "unified-lint-rule": "^1.0.0",
+        "unist-util-generated": "^1.1.0",
+        "unist-util-position": "^3.0.0",
+        "unist-util-visit": "^1.1.1",
+        "vfile-location": "^2.0.1"
+      }
+    },
+    "remark-lint-no-duplicate-definitions": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-duplicate-definitions/-/remark-lint-no-duplicate-definitions-1.0.5.tgz",
+      "integrity": "sha512-zKXmfNUODXhJsGQdqfguMG9Nl9v1sLaDsQgMjUtmOSoQRnNud9ThQAZl62eX5jBn5HKcpOifG80tgkyBvU5eEw==",
+      "dev": true,
+      "requires": {
+        "unified-lint-rule": "^1.0.0",
+        "unist-util-generated": "^1.1.0",
+        "unist-util-position": "^3.0.0",
+        "unist-util-stringify-position": "^2.0.0",
+        "unist-util-visit": "^1.4.0"
+      },
+      "dependencies": {
+        "unist-util-stringify-position": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-2.0.1.tgz",
+          "integrity": "sha512-Zqlf6+FRI39Bah8Q6ZnNGrEHUhwJOkHde2MHVk96lLyftfJJckaPslKgzhVcviXj8KcE9UJM9F+a4JEiBUTYgA==",
+          "dev": true,
+          "requires": {
+            "@types/unist": "^2.0.2"
+          }
+        }
+      }
+    },
+    "remark-lint-no-heading-content-indent": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-heading-content-indent/-/remark-lint-no-heading-content-indent-1.0.3.tgz",
+      "integrity": "sha512-7xM6X5E/dt8OXOHdejH+sfYb139a3kMr8ZSSkcp90Ab1y+ZQBNaWsR3mYh8FRKkYPTN5eyd+KjhNpLWyqqCbgg==",
+      "dev": true,
+      "requires": {
+        "mdast-util-heading-style": "^1.0.2",
+        "plur": "^3.0.0",
+        "unified-lint-rule": "^1.0.0",
+        "unist-util-generated": "^1.1.0",
+        "unist-util-position": "^3.0.0",
+        "unist-util-visit": "^1.1.1"
+      }
+    },
+    "remark-lint-no-inline-padding": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-inline-padding/-/remark-lint-no-inline-padding-1.0.4.tgz",
+      "integrity": "sha512-u5rgbDkcfVv645YxxOwoGBBJbsHEwWm/XqnO8EhfKTxkfKOF4ZItG7Ajhj89EDaeXMkvCcB/avBl4bj50eJH3g==",
+      "dev": true,
+      "requires": {
+        "mdast-util-to-string": "^1.0.2",
+        "unified-lint-rule": "^1.0.0",
+        "unist-util-generated": "^1.1.0",
+        "unist-util-visit": "^1.4.0"
+      }
+    },
+    "remark-lint-no-literal-urls": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-literal-urls/-/remark-lint-no-literal-urls-1.0.3.tgz",
+      "integrity": "sha512-H5quyMzl2kaewK+jYD1FI0G1SIinIsIp4DEyOUwIR+vYUoKwo0B4vvW0cmPpD1dgqqxHYx0B2B0JQQKFVWzGiw==",
+      "dev": true,
+      "requires": {
+        "mdast-util-to-string": "^1.0.2",
+        "unified-lint-rule": "^1.0.0",
+        "unist-util-generated": "^1.1.0",
+        "unist-util-position": "^3.0.0",
+        "unist-util-visit": "^1.1.1"
+      }
+    },
+    "remark-lint-no-shortcut-reference-image": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-shortcut-reference-image/-/remark-lint-no-shortcut-reference-image-1.0.3.tgz",
+      "integrity": "sha512-CGm27X54kXp/5ehXejDTsZjqzK4uIhLGcrFzN3k/KjdwunQouEY92AARGrLSEuJ1hQx0bJsmnvr/hvQyWAfNJg==",
+      "dev": true,
+      "requires": {
+        "unified-lint-rule": "^1.0.0",
+        "unist-util-generated": "^1.1.0",
+        "unist-util-visit": "^1.1.1"
+      }
+    },
+    "remark-lint-no-shortcut-reference-link": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-shortcut-reference-link/-/remark-lint-no-shortcut-reference-link-1.0.4.tgz",
+      "integrity": "sha512-FXdMJYqspZBhPlxYqfVgVluVXjxStg0RHJzqrk8G9wS8fCS62AE3reoaoiCahwoH1tfKcA+poktbKqDAmZo7Jg==",
+      "dev": true,
+      "requires": {
+        "unified-lint-rule": "^1.0.0",
+        "unist-util-generated": "^1.1.0",
+        "unist-util-visit": "^1.1.1"
+      }
+    },
+    "remark-lint-no-undefined-references": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-undefined-references/-/remark-lint-no-undefined-references-1.1.1.tgz",
+      "integrity": "sha512-b1eIjWFaCu6m16Ax2uG33o1v+eRYqDTQRUqU6UeQ76JXmDmVtVO75ZuyRpqqE7VTZRW8YLVurXfJPDXfIa5Wng==",
+      "dev": true,
+      "requires": {
+        "collapse-white-space": "^1.0.4",
+        "unified-lint-rule": "^1.0.0",
+        "unist-util-generated": "^1.1.0",
+        "unist-util-visit": "^1.4.0"
+      }
+    },
+    "remark-lint-no-unused-definitions": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-unused-definitions/-/remark-lint-no-unused-definitions-1.0.5.tgz",
+      "integrity": "sha512-Bo22e0RNzc1QMW317KTuStGFDG7uTDUQhm/TrW6Qzud0WXnNnqUyvts+e7wTYoj8VnwhhjyjyoA9lKA3uXMdAQ==",
+      "dev": true,
+      "requires": {
+        "unified-lint-rule": "^1.0.0",
+        "unist-util-generated": "^1.1.0",
+        "unist-util-visit": "^1.4.0"
+      }
+    },
+    "remark-lint-ordered-list-marker-style": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/remark-lint-ordered-list-marker-style/-/remark-lint-ordered-list-marker-style-1.0.3.tgz",
+      "integrity": "sha512-24TmW1eUa/2JlwprZg9jJ8LKLxNGKnlKiI5YOhN4taUp2yv8daqlV9vR54yfn/ZZQh6EQvbIX0jeVY9NYgQUtw==",
+      "dev": true,
+      "requires": {
+        "unified-lint-rule": "^1.0.0",
+        "unist-util-generated": "^1.1.0",
+        "unist-util-position": "^3.0.0",
+        "unist-util-visit": "^1.1.1"
+      }
+    },
+    "remark-message-control": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/remark-message-control/-/remark-message-control-4.2.0.tgz",
+      "integrity": "sha512-WXH2t5ljTyhsXlK1zPBLF3iPHbXl58R94phPMreS1xcHWBZJt6Oiu8RtNjy1poZFb3PqKnbYLJeR/CWcZ1bTFw==",
+      "dev": true,
+      "requires": {
+        "mdast-comment-marker": "^1.0.0",
+        "unified-message-control": "^1.0.0",
+        "xtend": "^4.0.1"
+      }
+    },
+    "remark-parse": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-7.0.2.tgz",
+      "integrity": "sha512-9+my0lQS80IQkYXsMA8Sg6m9QfXYJBnXjWYN5U+kFc5/n69t+XZVXU/ZBYr3cYH8FheEGf1v87rkFDhJ8bVgMA==",
+      "dev": true,
+      "requires": {
+        "collapse-white-space": "^1.0.2",
+        "is-alphabetical": "^1.0.0",
+        "is-decimal": "^1.0.0",
+        "is-whitespace-character": "^1.0.0",
+        "is-word-character": "^1.0.0",
+        "markdown-escapes": "^1.0.0",
+        "parse-entities": "^1.1.0",
+        "repeat-string": "^1.5.4",
+        "state-toggle": "^1.0.0",
+        "trim": "0.0.1",
+        "trim-trailing-lines": "^1.0.0",
+        "unherit": "^1.0.4",
+        "unist-util-remove-position": "^1.0.0",
+        "vfile-location": "^2.0.0",
+        "xtend": "^4.0.1"
+      }
+    },
+    "remark-preset-lint-recommended": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/remark-preset-lint-recommended/-/remark-preset-lint-recommended-3.0.3.tgz",
+      "integrity": "sha512-5sQ34j1Irlsj6Tt4WWRylZ7UU+1jD5es/LfDZBZp/LXDwC4ldGqKpMmCCR6Z00x1jYM1phmS4M+eGqTdah0qkQ==",
+      "dev": true,
+      "requires": {
+        "remark-lint": "^6.0.0",
+        "remark-lint-final-newline": "^1.0.0",
+        "remark-lint-hard-break-spaces": "^1.0.0",
+        "remark-lint-list-item-bullet-indent": "^1.0.0",
+        "remark-lint-list-item-indent": "^1.0.0",
+        "remark-lint-no-auto-link-without-protocol": "^1.0.0",
+        "remark-lint-no-blockquote-without-marker": "^2.0.0",
+        "remark-lint-no-duplicate-definitions": "^1.0.0",
+        "remark-lint-no-heading-content-indent": "^1.0.0",
+        "remark-lint-no-inline-padding": "^1.0.0",
+        "remark-lint-no-literal-urls": "^1.0.0",
+        "remark-lint-no-shortcut-reference-image": "^1.0.0",
+        "remark-lint-no-shortcut-reference-link": "^1.0.0",
+        "remark-lint-no-undefined-references": "^1.0.0",
+        "remark-lint-no-unused-definitions": "^1.0.0",
+        "remark-lint-ordered-list-marker-style": "^1.0.0"
+      }
+    },
+    "remark-stringify": {
+      "version": "7.0.4",
+      "resolved": "https://registry.npmjs.org/remark-stringify/-/remark-stringify-7.0.4.tgz",
+      "integrity": "sha512-qck+8NeA1D0utk1ttKcWAoHRrJxERYQzkHDyn+pF5Z4whX1ug98uCNPPSeFgLSaNERRxnD6oxIug6DzZQth6Pg==",
+      "dev": true,
+      "requires": {
+        "ccount": "^1.0.0",
+        "is-alphanumeric": "^1.0.0",
+        "is-decimal": "^1.0.0",
+        "is-whitespace-character": "^1.0.0",
+        "longest-streak": "^2.0.1",
+        "markdown-escapes": "^1.0.0",
+        "markdown-table": "^1.1.0",
+        "mdast-util-compact": "^1.0.0",
+        "parse-entities": "^1.0.2",
+        "repeat-string": "^1.5.4",
+        "state-toggle": "^1.0.0",
+        "stringify-entities": "^2.0.0",
+        "unherit": "^1.0.4",
+        "xtend": "^4.0.1"
+      }
+    },
+    "repeat-string": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz",
+      "integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc=",
+      "dev": true
+    },
+    "replace-ext": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/replace-ext/-/replace-ext-1.0.0.tgz",
+      "integrity": "sha1-3mMSg3P8v3w8z6TeWkgMRaZ5WOs=",
+      "dev": true
+    },
+    "request": {
+      "version": "2.88.0",
+      "resolved": "https://registry.npmjs.org/request/-/request-2.88.0.tgz",
+      "integrity": "sha512-NAqBSrijGLZdM0WZNsInLJpkJokL72XYjUpnB0iwsRgxh7dB6COrHnTBNwN0E+lHDAJzu7kLAkDeY08z2/A0hg==",
+      "dev": true,
+      "requires": {
+        "aws-sign2": "~0.7.0",
+        "aws4": "^1.8.0",
+        "caseless": "~0.12.0",
+        "combined-stream": "~1.0.6",
+        "extend": "~3.0.2",
+        "forever-agent": "~0.6.1",
+        "form-data": "~2.3.2",
+        "har-validator": "~5.1.0",
+        "http-signature": "~1.2.0",
+        "is-typedarray": "~1.0.0",
+        "isstream": "~0.1.2",
+        "json-stringify-safe": "~5.0.1",
+        "mime-types": "~2.1.19",
+        "oauth-sign": "~0.9.0",
+        "performance-now": "^2.1.0",
+        "qs": "~6.5.2",
+        "safe-buffer": "^5.1.2",
+        "tough-cookie": "~2.4.3",
+        "tunnel-agent": "^0.6.0",
+        "uuid": "^3.3.2"
+      }
+    },
+    "require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=",
+      "dev": true
+    },
+    "require-main-filename": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-2.0.0.tgz",
+      "integrity": "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==",
+      "dev": true
+    },
+    "resolve": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.14.1.tgz",
+      "integrity": "sha512-fn5Wobh4cxbLzuHaE+nphztHy43/b++4M6SsGFC2gB8uYwf0C8LcarfCz1un7UTW8OFQg9iNjZ4xpcFVGebDPg==",
+      "dev": true,
+      "requires": {
+        "path-parse": "^1.0.6"
+      }
+    },
+    "resolve-from": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+      "dev": true
+    },
+    "restore-cursor": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-3.1.0.tgz",
+      "integrity": "sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==",
+      "dev": true,
+      "requires": {
+        "onetime": "^5.1.0",
+        "signal-exit": "^3.0.2"
+      }
+    },
+    "ret": {
+      "version": "0.1.15",
+      "resolved": "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz",
+      "integrity": "sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==",
+      "dev": true
+    },
+    "rimraf": {
+      "version": "2.6.3",
+      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz",
+      "integrity": "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==",
+      "dev": true,
+      "requires": {
+        "glob": "^7.1.3"
+      }
+    },
+    "run-async": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/run-async/-/run-async-2.3.0.tgz",
+      "integrity": "sha1-A3GrSuC91yDUFm19/aZP96RFpsA=",
+      "dev": true,
+      "requires": {
+        "is-promise": "^2.1.0"
+      }
+    },
+    "rxjs": {
+      "version": "6.5.3",
+      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-6.5.3.tgz",
+      "integrity": "sha512-wuYsAYYFdWTAnAaPoKGNhfpWwKZbJW+HgAJ+mImp+Epl7BG8oNWBCTyRM8gba9k4lk8BgWdoYm21Mo/RYhhbgA==",
+      "dev": true,
+      "requires": {
+        "tslib": "^1.9.0"
+      }
+    },
+    "safe-buffer": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.0.tgz",
+      "integrity": "sha512-fZEwUGbVl7kouZs1jCdMLdt95hdIv0ZeHg6L7qPeciMZhZ+/gdesW4wgTARkrFWEpspjEATAzUGPG8N2jJiwbg==",
+      "dev": true
+    },
+    "safe-regex": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/safe-regex/-/safe-regex-1.1.0.tgz",
+      "integrity": "sha1-QKNmnzsHfR6UPURinhV91IAjvy4=",
+      "dev": true,
+      "requires": {
+        "ret": "~0.1.10"
+      }
+    },
+    "safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "dev": true
+    },
+    "semver": {
+      "version": "6.3.0",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
+      "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",
+      "dev": true
+    },
+    "set-blocking": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
+      "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=",
+      "dev": true
+    },
+    "shebang-command": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz",
+      "integrity": "sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=",
+      "dev": true,
+      "requires": {
+        "shebang-regex": "^1.0.0"
+      }
+    },
+    "shebang-regex": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz",
+      "integrity": "sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=",
+      "dev": true
+    },
+    "shellsubstitute": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/shellsubstitute/-/shellsubstitute-1.2.0.tgz",
+      "integrity": "sha1-5PcCpQxRiw9v6YRRiQ1wWvKba3A=",
+      "dev": true
+    },
+    "signal-exit": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz",
+      "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=",
+      "dev": true
+    },
+    "slice-ansi": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-2.1.0.tgz",
+      "integrity": "sha512-Qu+VC3EwYLldKa1fCxuuvULvSJOKEgk9pi8dZeCVK7TqBfUNTH4sFkk4joj8afVSfAYgJoSOetjx9QWOJ5mYoQ==",
+      "dev": true,
+      "requires": {
+        "ansi-styles": "^3.2.0",
+        "astral-regex": "^1.0.0",
+        "is-fullwidth-code-point": "^2.0.0"
+      },
+      "dependencies": {
+        "is-fullwidth-code-point": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
+          "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
+          "dev": true
+        }
+      }
+    },
+    "sliced": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/sliced/-/sliced-1.0.1.tgz",
+      "integrity": "sha1-CzpmK10Ewxd7GSa+qCsD+Dei70E=",
+      "dev": true
+    },
+    "source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "dev": true
+    },
+    "source-map-support": {
+      "version": "0.5.16",
+      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.16.tgz",
+      "integrity": "sha512-efyLRJDr68D9hBBNIPWFjhpFzURh+KJykQwvMyW5UiZzYwoF6l4YMMDIJJEyFWxWCqfyxLzz6tSfUFR+kXXsVQ==",
+      "dev": true,
+      "requires": {
+        "buffer-from": "^1.0.0",
+        "source-map": "^0.6.0"
+      }
+    },
+    "spawn-wrap": {
+      "version": "1.4.3",
+      "resolved": "https://registry.npmjs.org/spawn-wrap/-/spawn-wrap-1.4.3.tgz",
+      "integrity": "sha512-IgB8md0QW/+tWqcavuFgKYR/qIRvJkRLPJDFaoXtLLUaVcCDK0+HeFTkmQHj3eprcYhc+gOl0aEA1w7qZlYezw==",
+      "dev": true,
+      "requires": {
+        "foreground-child": "^1.5.6",
+        "mkdirp": "^0.5.0",
+        "os-homedir": "^1.0.1",
+        "rimraf": "^2.6.2",
+        "signal-exit": "^3.0.2",
+        "which": "^1.3.0"
+      }
+    },
+    "spdx-correct": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.0.tgz",
+      "integrity": "sha512-lr2EZCctC2BNR7j7WzJ2FpDznxky1sjfxvvYEyzxNyb6lZXHODmEoJeFu4JupYlkfha1KZpJyoqiJ7pgA1qq8Q==",
+      "dev": true,
+      "requires": {
+        "spdx-expression-parse": "^3.0.0",
+        "spdx-license-ids": "^3.0.0"
+      }
+    },
+    "spdx-exceptions": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.2.0.tgz",
+      "integrity": "sha512-2XQACfElKi9SlVb1CYadKDXvoajPgBVPn/gOQLrTvHdElaVhr7ZEbqJaRnJLVNeaI4cMEAgVCeBMKF6MWRDCRA==",
+      "dev": true
+    },
+    "spdx-expression-parse": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.0.tgz",
+      "integrity": "sha512-Yg6D3XpRD4kkOmTpdgbUiEJFKghJH03fiC1OPll5h/0sO6neh2jqRDVHOQ4o/LMea0tgCkbMgea5ip/e+MkWyg==",
+      "dev": true,
+      "requires": {
+        "spdx-exceptions": "^2.1.0",
+        "spdx-license-ids": "^3.0.0"
+      }
+    },
+    "spdx-license-ids": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.5.tgz",
+      "integrity": "sha512-J+FWzZoynJEXGphVIS+XEh3kFSjZX/1i9gFBaWQcB+/tmpe2qUsSBABpcxqxnAxFdiUFEgAX1bjYGQvIZmoz9Q==",
+      "dev": true
+    },
+    "sprintf-js": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
+      "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=",
+      "dev": true
+    },
+    "sshpk": {
+      "version": "1.16.1",
+      "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.16.1.tgz",
+      "integrity": "sha512-HXXqVUq7+pcKeLqqZj6mHFUMvXtOJt1uoUx09pFW6011inTMxqI8BA8PM95myrIyyKwdnzjdFjLiE6KBPVtJIg==",
+      "dev": true,
+      "requires": {
+        "asn1": "~0.2.3",
+        "assert-plus": "^1.0.0",
+        "bcrypt-pbkdf": "^1.0.0",
+        "dashdash": "^1.12.0",
+        "ecc-jsbn": "~0.1.1",
+        "getpass": "^0.1.1",
+        "jsbn": "~0.1.0",
+        "safer-buffer": "^2.0.2",
+        "tweetnacl": "~0.14.0"
+      }
+    },
+    "stack-utils": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-1.0.2.tgz",
+      "integrity": "sha512-MTX+MeG5U994cazkjd/9KNAapsHnibjMLnfXodlkXw76JEea0UiNzrqidzo1emMwk7w5Qhc9jd4Bn9TBb1MFwA==",
+      "dev": true
+    },
+    "state-toggle": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/state-toggle/-/state-toggle-1.0.2.tgz",
+      "integrity": "sha512-8LpelPGR0qQM4PnfLiplOQNJcIN1/r2Gy0xKB2zKnIW2YzPMt2sR4I/+gtPjhN7Svh9kw+zqEg2SFwpBO9iNiw==",
+      "dev": true
+    },
+    "string-width": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.0.tgz",
+      "integrity": "sha512-zUz5JD+tgqtuDjMhwIg5uFVV3dtqZ9yQJlZVfq4I01/K5Paj5UHj7VyrQOJvzawSVlKpObApbfD0Ed6yJc+1eg==",
+      "dev": true,
+      "requires": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "dependencies": {
+        "strip-ansi": {
+          "version": "6.0.0",
+          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.0.tgz",
+          "integrity": "sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w==",
+          "dev": true,
+          "requires": {
+            "ansi-regex": "^5.0.0"
+          }
+        }
+      }
+    },
+    "string_decoder": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+      "dev": true,
+      "requires": {
+        "safe-buffer": "~5.2.0"
+      }
+    },
+    "stringify-entities": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-2.0.0.tgz",
+      "integrity": "sha512-fqqhZzXyAM6pGD9lky/GOPq6V4X0SeTAFBl0iXb/BzOegl40gpf/bV3QQP7zULNYvjr6+Dx8SCaDULjVoOru0A==",
+      "dev": true,
+      "requires": {
+        "character-entities-html4": "^1.0.0",
+        "character-entities-legacy": "^1.0.0",
+        "is-alphanumerical": "^1.0.0",
+        "is-decimal": "^1.0.2",
+        "is-hexadecimal": "^1.0.0"
+      }
+    },
+    "strip-ansi": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
+      "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
+      "dev": true,
+      "requires": {
+        "ansi-regex": "^4.1.0"
+      },
+      "dependencies": {
+        "ansi-regex": {
+          "version": "4.1.0",
+          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz",
+          "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==",
+          "dev": true
+        }
+      }
+    },
+    "strip-bom": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz",
+      "integrity": "sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=",
+      "dev": true
+    },
+    "strip-json-comments": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.0.1.tgz",
+      "integrity": "sha512-VTyMAUfdm047mwKl+u79WIdrZxtFtn+nBxHeb844XBQ9uMNTuTHdx2hc5RiAJYqwTj3wc/xe5HLSdJSkJ+WfZw==",
+      "dev": true
+    },
+    "supports-color": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+      "dev": true,
+      "requires": {
+        "has-flag": "^3.0.0"
+      }
+    },
+    "table": {
+      "version": "5.4.6",
+      "resolved": "https://registry.npmjs.org/table/-/table-5.4.6.tgz",
+      "integrity": "sha512-wmEc8m4fjnob4gt5riFRtTu/6+4rSe12TpAELNSqHMfF3IqnA+CH37USM6/YR3qRZv7e56kAEAtd6nKZaxe0Ug==",
+      "dev": true,
+      "requires": {
+        "ajv": "^6.10.2",
+        "lodash": "^4.17.14",
+        "slice-ansi": "^2.1.0",
+        "string-width": "^3.0.0"
+      },
+      "dependencies": {
+        "emoji-regex": {
+          "version": "7.0.3",
+          "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
+          "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==",
+          "dev": true
+        },
+        "is-fullwidth-code-point": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
+          "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
+          "dev": true
+        },
+        "string-width": {
+          "version": "3.1.0",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
+          "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
+          "dev": true,
+          "requires": {
+            "emoji-regex": "^7.0.1",
+            "is-fullwidth-code-point": "^2.0.0",
+            "strip-ansi": "^5.1.0"
+          }
+        }
+      }
+    },
+    "tap": {
+      "version": "14.10.5",
+      "resolved": "https://registry.npmjs.org/tap/-/tap-14.10.5.tgz",
+      "integrity": "sha512-8I8zMFEVu7e7RVcjK1GUNf1vW+6B9TRCZWGgif5siMBfvwTE9/EPN/7aH6W2r+WR2H2YHXcrCJ3XhRitYEVKfQ==",
+      "dev": true,
+      "requires": {
+        "@types/react": "^16.9.16",
+        "async-hook-domain": "^1.1.3",
+        "bind-obj-methods": "^2.0.0",
+        "browser-process-hrtime": "^1.0.0",
+        "chokidar": "^3.3.0",
+        "color-support": "^1.1.0",
+        "coveralls": "^3.0.8",
+        "diff": "^4.0.1",
+        "esm": "^3.2.25",
+        "findit": "^2.0.0",
+        "flow-remove-types": "^2.112.0",
+        "foreground-child": "^1.3.3",
+        "fs-exists-cached": "^1.0.0",
+        "function-loop": "^1.0.2",
+        "glob": "^7.1.6",
+        "import-jsx": "^3.0.0",
+        "ink": "^2.5.0",
+        "isexe": "^2.0.0",
+        "istanbul-lib-processinfo": "^1.0.0",
+        "jackspeak": "^1.4.0",
+        "minipass": "^3.1.1",
+        "mkdirp": "^0.5.1",
+        "nyc": "^14.1.1",
+        "opener": "^1.5.1",
+        "own-or": "^1.0.0",
+        "own-or-env": "^1.0.1",
+        "react": "^16.12.0",
+        "rimraf": "^2.7.1",
+        "signal-exit": "^3.0.0",
+        "source-map-support": "^0.5.16",
+        "stack-utils": "^1.0.2",
+        "tap-mocha-reporter": "^5.0.0",
+        "tap-parser": "^10.0.1",
+        "tap-yaml": "^1.0.0",
+        "tcompare": "^3.0.0",
+        "treport": "^1.0.1",
+        "trivial-deferred": "^1.0.1",
+        "ts-node": "^8.5.2",
+        "typescript": "^3.7.2",
+        "which": "^2.0.2",
+        "write-file-atomic": "^3.0.1",
+        "yaml": "^1.7.2",
+        "yapool": "^1.0.0"
+      },
+      "dependencies": {
+        "@babel/code-frame": {
+          "version": "7.5.5",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "@babel/highlight": "^7.0.0"
+          }
+        },
+        "@babel/core": {
+          "version": "7.7.5",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "@babel/code-frame": "^7.5.5",
+            "@babel/generator": "^7.7.4",
+            "@babel/helpers": "^7.7.4",
+            "@babel/parser": "^7.7.5",
+            "@babel/template": "^7.7.4",
+            "@babel/traverse": "^7.7.4",
+            "@babel/types": "^7.7.4",
+            "convert-source-map": "^1.7.0",
+            "debug": "^4.1.0",
+            "json5": "^2.1.0",
+            "lodash": "^4.17.13",
+            "resolve": "^1.3.2",
+            "semver": "^5.4.1",
+            "source-map": "^0.5.0"
+          },
+          "dependencies": {
+            "source-map": {
+              "version": "0.5.7",
+              "bundled": true,
+              "dev": true
+            }
+          }
+        },
+        "@babel/generator": {
+          "version": "7.7.4",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "@babel/types": "^7.7.4",
+            "jsesc": "^2.5.1",
+            "lodash": "^4.17.13",
+            "source-map": "^0.5.0"
+          },
+          "dependencies": {
+            "source-map": {
+              "version": "0.5.7",
+              "bundled": true,
+              "dev": true
+            }
+          }
+        },
+        "@babel/helper-builder-react-jsx": {
+          "version": "7.7.4",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "@babel/types": "^7.7.4",
+            "esutils": "^2.0.0"
+          }
+        },
+        "@babel/helper-function-name": {
+          "version": "7.7.4",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "@babel/helper-get-function-arity": "^7.7.4",
+            "@babel/template": "^7.7.4",
+            "@babel/types": "^7.7.4"
+          }
+        },
+        "@babel/helper-get-function-arity": {
+          "version": "7.7.4",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "@babel/types": "^7.7.4"
+          }
+        },
+        "@babel/helper-plugin-utils": {
+          "version": "7.0.0",
+          "bundled": true,
+          "dev": true
+        },
+        "@babel/helper-split-export-declaration": {
+          "version": "7.7.4",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "@babel/types": "^7.7.4"
+          }
+        },
+        "@babel/helpers": {
+          "version": "7.7.4",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "@babel/template": "^7.7.4",
+            "@babel/traverse": "^7.7.4",
+            "@babel/types": "^7.7.4"
+          }
+        },
+        "@babel/highlight": {
+          "version": "7.5.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "chalk": "^2.0.0",
+            "esutils": "^2.0.2",
+            "js-tokens": "^4.0.0"
+          },
+          "dependencies": {
+            "chalk": {
+              "version": "2.4.2",
+              "bundled": true,
+              "dev": true,
+              "requires": {
+                "ansi-styles": "^3.2.1",
+                "escape-string-regexp": "^1.0.5",
+                "supports-color": "^5.3.0"
+              }
+            },
+            "supports-color": {
+              "version": "5.5.0",
+              "bundled": true,
+              "dev": true,
+              "requires": {
+                "has-flag": "^3.0.0"
+              }
+            }
+          }
+        },
+        "@babel/parser": {
+          "version": "7.7.5",
+          "bundled": true,
+          "dev": true
+        },
+        "@babel/plugin-proposal-object-rest-spread": {
+          "version": "7.7.4",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "@babel/helper-plugin-utils": "^7.0.0",
+            "@babel/plugin-syntax-object-rest-spread": "^7.7.4"
+          }
+        },
+        "@babel/plugin-syntax-jsx": {
+          "version": "7.7.4",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "@babel/helper-plugin-utils": "^7.0.0"
+          }
+        },
+        "@babel/plugin-syntax-object-rest-spread": {
+          "version": "7.7.4",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "@babel/helper-plugin-utils": "^7.0.0"
+          }
+        },
+        "@babel/plugin-transform-destructuring": {
+          "version": "7.7.4",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "@babel/helper-plugin-utils": "^7.0.0"
+          }
+        },
+        "@babel/plugin-transform-react-jsx": {
+          "version": "7.7.4",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "@babel/helper-builder-react-jsx": "^7.7.4",
+            "@babel/helper-plugin-utils": "^7.0.0",
+            "@babel/plugin-syntax-jsx": "^7.7.4"
+          }
+        },
+        "@babel/runtime": {
+          "version": "7.7.6",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "regenerator-runtime": "^0.13.2"
+          }
+        },
+        "@babel/template": {
+          "version": "7.7.4",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "@babel/code-frame": "^7.0.0",
+            "@babel/parser": "^7.7.4",
+            "@babel/types": "^7.7.4"
+          }
+        },
+        "@babel/traverse": {
+          "version": "7.7.4",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "@babel/code-frame": "^7.5.5",
+            "@babel/generator": "^7.7.4",
+            "@babel/helper-function-name": "^7.7.4",
+            "@babel/helper-split-export-declaration": "^7.7.4",
+            "@babel/parser": "^7.7.4",
+            "@babel/types": "^7.7.4",
+            "debug": "^4.1.0",
+            "globals": "^11.1.0",
+            "lodash": "^4.17.13"
+          }
+        },
+        "@babel/types": {
+          "version": "7.7.4",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "esutils": "^2.0.2",
+            "lodash": "^4.17.13",
+            "to-fast-properties": "^2.0.0"
+          }
+        },
+        "@types/color-name": {
+          "version": "1.1.1",
+          "bundled": true,
+          "dev": true
+        },
+        "@types/prop-types": {
+          "version": "15.7.3",
+          "bundled": true,
+          "dev": true
+        },
+        "@types/react": {
+          "version": "16.9.16",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "@types/prop-types": "*",
+            "csstype": "^2.2.0"
+          }
+        },
+        "ansi-escapes": {
+          "version": "4.3.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "type-fest": "^0.8.1"
+          }
+        },
+        "ansi-regex": {
+          "version": "5.0.0",
+          "bundled": true,
+          "dev": true
+        },
+        "ansi-styles": {
+          "version": "3.2.1",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "color-convert": "^1.9.0"
+          }
+        },
+        "ansicolors": {
+          "version": "0.3.2",
+          "bundled": true,
+          "dev": true
+        },
+        "arrify": {
+          "version": "2.0.1",
+          "bundled": true,
+          "dev": true
+        },
+        "astral-regex": {
+          "version": "2.0.0",
+          "bundled": true,
+          "dev": true
+        },
+        "auto-bind": {
+          "version": "3.0.0",
+          "bundled": true,
+          "dev": true
+        },
+        "caller-callsite": {
+          "version": "2.0.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "callsites": "^2.0.0"
+          }
+        },
+        "caller-path": {
+          "version": "2.0.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "caller-callsite": "^2.0.0"
+          }
+        },
+        "callsites": {
+          "version": "2.0.0",
+          "bundled": true,
+          "dev": true
+        },
+        "cardinal": {
+          "version": "2.1.1",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "ansicolors": "~0.3.2",
+            "redeyed": "~2.1.0"
+          }
+        },
+        "chalk": {
+          "version": "3.0.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "ansi-styles": "^4.1.0",
+            "supports-color": "^7.1.0"
+          },
+          "dependencies": {
+            "ansi-styles": {
+              "version": "4.2.0",
+              "bundled": true,
+              "dev": true,
+              "requires": {
+                "@types/color-name": "^1.1.1",
+                "color-convert": "^2.0.1"
+              }
+            },
+            "color-convert": {
+              "version": "2.0.1",
+              "bundled": true,
+              "dev": true,
+              "requires": {
+                "color-name": "~1.1.4"
+              }
+            },
+            "color-name": {
+              "version": "1.1.4",
+              "bundled": true,
+              "dev": true
+            }
+          }
+        },
+        "ci-info": {
+          "version": "2.0.0",
+          "bundled": true,
+          "dev": true
+        },
+        "cli-cursor": {
+          "version": "3.1.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "restore-cursor": "^3.1.0"
+          }
+        },
+        "cli-truncate": {
+          "version": "2.1.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "slice-ansi": "^3.0.0",
+            "string-width": "^4.2.0"
+          }
+        },
+        "color-convert": {
+          "version": "1.9.3",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "color-name": "1.1.3"
+          }
+        },
+        "color-name": {
+          "version": "1.1.3",
+          "bundled": true,
+          "dev": true
+        },
+        "convert-source-map": {
+          "version": "1.7.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "safe-buffer": "~5.1.1"
+          },
+          "dependencies": {
+            "safe-buffer": {
+              "version": "5.1.2",
+              "bundled": true,
+              "dev": true
+            }
+          }
+        },
+        "csstype": {
+          "version": "2.6.8",
+          "bundled": true,
+          "dev": true
+        },
+        "debug": {
+          "version": "4.1.1",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "ms": "^2.1.1"
+          }
+        },
+        "emoji-regex": {
+          "version": "8.0.0",
+          "bundled": true,
+          "dev": true
+        },
+        "escape-string-regexp": {
+          "version": "1.0.5",
+          "bundled": true,
+          "dev": true
+        },
+        "esprima": {
+          "version": "4.0.1",
+          "bundled": true,
+          "dev": true
+        },
+        "esutils": {
+          "version": "2.0.3",
+          "bundled": true,
+          "dev": true
+        },
+        "events-to-array": {
+          "version": "1.1.2",
+          "bundled": true,
+          "dev": true
+        },
+        "globals": {
+          "version": "11.12.0",
+          "bundled": true,
+          "dev": true
+        },
+        "has-flag": {
+          "version": "3.0.0",
+          "bundled": true,
+          "dev": true
+        },
+        "import-jsx": {
+          "version": "3.0.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "@babel/core": "^7.5.5",
+            "@babel/plugin-proposal-object-rest-spread": "^7.5.5",
+            "@babel/plugin-transform-destructuring": "^7.5.0",
+            "@babel/plugin-transform-react-jsx": "^7.3.0",
+            "caller-path": "^2.0.0",
+            "resolve-from": "^3.0.0"
+          }
+        },
+        "ink": {
+          "version": "2.6.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "ansi-escapes": "^4.2.1",
+            "arrify": "^2.0.1",
+            "auto-bind": "^3.0.0",
+            "chalk": "^3.0.0",
+            "cli-cursor": "^3.1.0",
+            "cli-truncate": "^2.0.0",
+            "is-ci": "^2.0.0",
+            "lodash.throttle": "^4.1.1",
+            "log-update": "^3.0.0",
+            "prop-types": "^15.6.2",
+            "react-reconciler": "^0.24.0",
+            "scheduler": "^0.18.0",
+            "signal-exit": "^3.0.2",
+            "slice-ansi": "^3.0.0",
+            "string-length": "^3.1.0",
+            "widest-line": "^3.1.0",
+            "wrap-ansi": "^6.2.0",
+            "yoga-layout-prebuilt": "^1.9.3"
+          }
+        },
+        "is-ci": {
+          "version": "2.0.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "ci-info": "^2.0.0"
+          }
+        },
+        "is-fullwidth-code-point": {
+          "version": "3.0.0",
+          "bundled": true,
+          "dev": true
+        },
+        "js-tokens": {
+          "version": "4.0.0",
+          "bundled": true,
+          "dev": true
+        },
+        "jsesc": {
+          "version": "2.5.2",
+          "bundled": true,
+          "dev": true
+        },
+        "json5": {
+          "version": "2.1.1",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "minimist": "^1.2.0"
+          }
+        },
+        "lodash": {
+          "version": "4.17.15",
+          "bundled": true,
+          "dev": true
+        },
+        "lodash.throttle": {
+          "version": "4.1.1",
+          "bundled": true,
+          "dev": true
+        },
+        "log-update": {
+          "version": "3.3.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "ansi-escapes": "^3.2.0",
+            "cli-cursor": "^2.1.0",
+            "wrap-ansi": "^5.0.0"
+          },
+          "dependencies": {
+            "ansi-escapes": {
+              "version": "3.2.0",
+              "bundled": true,
+              "dev": true
+            },
+            "ansi-regex": {
+              "version": "4.1.0",
+              "bundled": true,
+              "dev": true
+            },
+            "cli-cursor": {
+              "version": "2.1.0",
+              "bundled": true,
+              "dev": true,
+              "requires": {
+                "restore-cursor": "^2.0.0"
+              }
+            },
+            "emoji-regex": {
+              "version": "7.0.3",
+              "bundled": true,
+              "dev": true
+            },
+            "is-fullwidth-code-point": {
+              "version": "2.0.0",
+              "bundled": true,
+              "dev": true
+            },
+            "mimic-fn": {
+              "version": "1.2.0",
+              "bundled": true,
+              "dev": true
+            },
+            "onetime": {
+              "version": "2.0.1",
+              "bundled": true,
+              "dev": true,
+              "requires": {
+                "mimic-fn": "^1.0.0"
+              }
+            },
+            "restore-cursor": {
+              "version": "2.0.0",
+              "bundled": true,
+              "dev": true,
+              "requires": {
+                "onetime": "^2.0.0",
+                "signal-exit": "^3.0.2"
+              }
+            },
+            "string-width": {
+              "version": "3.1.0",
+              "bundled": true,
+              "dev": true,
+              "requires": {
+                "emoji-regex": "^7.0.1",
+                "is-fullwidth-code-point": "^2.0.0",
+                "strip-ansi": "^5.1.0"
+              }
+            },
+            "strip-ansi": {
+              "version": "5.2.0",
+              "bundled": true,
+              "dev": true,
+              "requires": {
+                "ansi-regex": "^4.1.0"
+              }
+            },
+            "wrap-ansi": {
+              "version": "5.1.0",
+              "bundled": true,
+              "dev": true,
+              "requires": {
+                "ansi-styles": "^3.2.0",
+                "string-width": "^3.0.0",
+                "strip-ansi": "^5.0.0"
+              }
+            }
+          }
+        },
+        "loose-envify": {
+          "version": "1.4.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "js-tokens": "^3.0.0 || ^4.0.0"
+          }
+        },
+        "mimic-fn": {
+          "version": "2.1.0",
+          "bundled": true,
+          "dev": true
+        },
+        "minimist": {
+          "version": "1.2.0",
+          "bundled": true,
+          "dev": true
+        },
+        "minipass": {
+          "version": "3.1.1",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "yallist": "^4.0.0"
+          },
+          "dependencies": {
+            "yallist": {
+              "version": "4.0.0",
+              "bundled": true,
+              "dev": true
+            }
+          }
+        },
+        "ms": {
+          "version": "2.1.2",
+          "bundled": true,
+          "dev": true
+        },
+        "object-assign": {
+          "version": "4.1.1",
+          "bundled": true,
+          "dev": true
+        },
+        "onetime": {
+          "version": "5.1.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "mimic-fn": "^2.1.0"
+          }
+        },
+        "path-parse": {
+          "version": "1.0.6",
+          "bundled": true,
+          "dev": true
+        },
+        "prop-types": {
+          "version": "15.7.2",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "loose-envify": "^1.4.0",
+            "object-assign": "^4.1.1",
+            "react-is": "^16.8.1"
+          }
+        },
+        "punycode": {
+          "version": "2.1.1",
+          "bundled": true,
+          "dev": true
+        },
+        "react-is": {
+          "version": "16.12.0",
+          "bundled": true,
+          "dev": true
+        },
+        "react-reconciler": {
+          "version": "0.24.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "loose-envify": "^1.1.0",
+            "object-assign": "^4.1.1",
+            "prop-types": "^15.6.2",
+            "scheduler": "^0.18.0"
+          }
+        },
+        "redeyed": {
+          "version": "2.1.1",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "esprima": "~4.0.0"
+          }
+        },
+        "regenerator-runtime": {
+          "version": "0.13.3",
+          "bundled": true,
+          "dev": true
+        },
+        "resolve": {
+          "version": "1.13.1",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "path-parse": "^1.0.6"
+          }
+        },
+        "resolve-from": {
+          "version": "3.0.0",
+          "bundled": true,
+          "dev": true
+        },
+        "restore-cursor": {
+          "version": "3.1.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "onetime": "^5.1.0",
+            "signal-exit": "^3.0.2"
+          }
+        },
+        "rimraf": {
+          "version": "2.7.1",
+          "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.7.1.tgz",
+          "integrity": "sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==",
+          "dev": true,
+          "requires": {
+            "glob": "^7.1.3"
+          }
+        },
+        "scheduler": {
+          "version": "0.18.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "loose-envify": "^1.1.0",
+            "object-assign": "^4.1.1"
+          }
+        },
+        "semver": {
+          "version": "5.7.1",
+          "bundled": true,
+          "dev": true
+        },
+        "signal-exit": {
+          "version": "3.0.2",
+          "bundled": true,
+          "dev": true
+        },
+        "slice-ansi": {
+          "version": "3.0.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "ansi-styles": "^4.0.0",
+            "astral-regex": "^2.0.0",
+            "is-fullwidth-code-point": "^3.0.0"
+          },
+          "dependencies": {
+            "ansi-styles": {
+              "version": "4.2.0",
+              "bundled": true,
+              "dev": true,
+              "requires": {
+                "@types/color-name": "^1.1.1",
+                "color-convert": "^2.0.1"
+              }
+            },
+            "color-convert": {
+              "version": "2.0.1",
+              "bundled": true,
+              "dev": true,
+              "requires": {
+                "color-name": "~1.1.4"
+              }
+            },
+            "color-name": {
+              "version": "1.1.4",
+              "bundled": true,
+              "dev": true
+            }
+          }
+        },
+        "string-length": {
+          "version": "3.1.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "astral-regex": "^1.0.0",
+            "strip-ansi": "^5.2.0"
+          },
+          "dependencies": {
+            "ansi-regex": {
+              "version": "4.1.0",
+              "bundled": true,
+              "dev": true
+            },
+            "astral-regex": {
+              "version": "1.0.0",
+              "bundled": true,
+              "dev": true
+            },
+            "strip-ansi": {
+              "version": "5.2.0",
+              "bundled": true,
+              "dev": true,
+              "requires": {
+                "ansi-regex": "^4.1.0"
+              }
+            }
+          }
+        },
+        "string-width": {
+          "version": "4.2.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "emoji-regex": "^8.0.0",
+            "is-fullwidth-code-point": "^3.0.0",
+            "strip-ansi": "^6.0.0"
+          }
+        },
+        "strip-ansi": {
+          "version": "6.0.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "ansi-regex": "^5.0.0"
+          }
+        },
+        "supports-color": {
+          "version": "7.1.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "has-flag": "^4.0.0"
+          },
+          "dependencies": {
+            "has-flag": {
+              "version": "4.0.0",
+              "bundled": true,
+              "dev": true
+            }
+          }
+        },
+        "tap-parser": {
+          "version": "10.0.1",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "events-to-array": "^1.0.1",
+            "minipass": "^3.0.0",
+            "tap-yaml": "^1.0.0"
+          }
+        },
+        "tap-yaml": {
+          "version": "1.0.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "yaml": "^1.5.0"
+          }
+        },
+        "to-fast-properties": {
+          "version": "2.0.0",
+          "bundled": true,
+          "dev": true
+        },
+        "treport": {
+          "version": "1.0.1",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "cardinal": "^2.1.1",
+            "chalk": "^3.0.0",
+            "import-jsx": "^3.0.0",
+            "ink": "^2.5.0",
+            "ms": "^2.1.2",
+            "string-length": "^3.1.0",
+            "tap-parser": "^10.0.1",
+            "unicode-length": "^2.0.2"
+          },
+          "dependencies": {
+            "ansi-regex": {
+              "version": "2.1.1",
+              "bundled": true,
+              "dev": true
+            },
+            "strip-ansi": {
+              "version": "3.0.1",
+              "bundled": true,
+              "dev": true,
+              "requires": {
+                "ansi-regex": "^2.0.0"
+              }
+            },
+            "unicode-length": {
+              "version": "2.0.2",
+              "bundled": true,
+              "dev": true,
+              "requires": {
+                "punycode": "^2.0.0",
+                "strip-ansi": "^3.0.1"
+              }
+            }
+          }
+        },
+        "type-fest": {
+          "version": "0.8.1",
+          "bundled": true,
+          "dev": true
+        },
+        "which": {
+          "version": "2.0.2",
+          "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+          "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+          "dev": true,
+          "requires": {
+            "isexe": "^2.0.0"
+          }
+        },
+        "widest-line": {
+          "version": "3.1.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "string-width": "^4.0.0"
+          }
+        },
+        "wrap-ansi": {
+          "version": "6.2.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "ansi-styles": "^4.0.0",
+            "string-width": "^4.1.0",
+            "strip-ansi": "^6.0.0"
+          },
+          "dependencies": {
+            "ansi-styles": {
+              "version": "4.2.0",
+              "bundled": true,
+              "dev": true,
+              "requires": {
+                "@types/color-name": "^1.1.1",
+                "color-convert": "^2.0.1"
+              }
+            },
+            "color-convert": {
+              "version": "2.0.1",
+              "bundled": true,
+              "dev": true,
+              "requires": {
+                "color-name": "~1.1.4"
+              }
+            },
+            "color-name": {
+              "version": "1.1.4",
+              "bundled": true,
+              "dev": true
+            }
+          }
+        },
+        "yaml": {
+          "version": "1.7.2",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "@babel/runtime": "^7.6.3"
+          }
+        },
+        "yoga-layout-prebuilt": {
+          "version": "1.9.3",
+          "bundled": true,
+          "dev": true
+        }
+      }
+    },
+    "tap-mocha-reporter": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/tap-mocha-reporter/-/tap-mocha-reporter-5.0.0.tgz",
+      "integrity": "sha512-8HlAtdmYGlDZuW83QbF/dc46L7cN+AGhLZcanX3I9ILvxUAl+G2/mtucNPSXecTlG/4iP1hv6oMo0tMhkn3Tsw==",
+      "dev": true,
+      "requires": {
+        "color-support": "^1.1.0",
+        "debug": "^2.1.3",
+        "diff": "^1.3.2",
+        "escape-string-regexp": "^1.0.3",
+        "glob": "^7.0.5",
+        "readable-stream": "^2.1.5",
+        "tap-parser": "^10.0.0",
+        "tap-yaml": "^1.0.0",
+        "unicode-length": "^1.0.0"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "2.6.9",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+          "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+          "dev": true,
+          "requires": {
+            "ms": "2.0.0"
+          }
+        },
+        "diff": {
+          "version": "1.4.0",
+          "resolved": "https://registry.npmjs.org/diff/-/diff-1.4.0.tgz",
+          "integrity": "sha1-fyjS657nsVqX79ic5j3P2qPMur8=",
+          "dev": true
+        },
+        "ms": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+          "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=",
+          "dev": true
+        },
+        "readable-stream": {
+          "version": "2.3.6",
+          "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz",
+          "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "core-util-is": "~1.0.0",
+            "inherits": "~2.0.3",
+            "isarray": "~1.0.0",
+            "process-nextick-args": "~2.0.0",
+            "safe-buffer": "~5.1.1",
+            "string_decoder": "~1.1.1",
+            "util-deprecate": "~1.0.1"
+          }
+        },
+        "safe-buffer": {
+          "version": "5.1.2",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+          "dev": true,
+          "optional": true
+        },
+        "string_decoder": {
+          "version": "1.1.1",
+          "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+          "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "safe-buffer": "~5.1.0"
+          }
+        }
+      }
+    },
+    "tap-parser": {
+      "version": "10.0.1",
+      "resolved": "https://registry.npmjs.org/tap-parser/-/tap-parser-10.0.1.tgz",
+      "integrity": "sha512-qdT15H0DoJIi7zOqVXDn9X0gSM68JjNy1w3VemwTJlDnETjbi6SutnqmBfjDJAwkFS79NJ97gZKqie00ZCGmzg==",
+      "dev": true,
+      "requires": {
+        "events-to-array": "^1.0.1",
+        "minipass": "^3.0.0",
+        "tap-yaml": "^1.0.0"
+      }
+    },
+    "tap-yaml": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/tap-yaml/-/tap-yaml-1.0.0.tgz",
+      "integrity": "sha512-Rxbx4EnrWkYk0/ztcm5u3/VznbyFJpyXO12dDBHKWiDVxy7O2Qw6MRrwO5H6Ww0U5YhRY/4C/VzWmFPhBQc4qQ==",
+      "dev": true,
+      "requires": {
+        "yaml": "^1.5.0"
+      }
+    },
+    "tcompare": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/tcompare/-/tcompare-3.0.4.tgz",
+      "integrity": "sha512-Q3TitMVK59NyKgQyFh+857wTAUE329IzLDehuPgU4nF5e8g+EUQ+yUbjUy1/6ugiNnXztphT+NnqlCXolv9P3A==",
+      "dev": true,
+      "requires": {
+        "diff-frag": "^1.0.1"
+      }
+    },
+    "terser": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-4.4.3.tgz",
+      "integrity": "sha512-0ikKraVtRDKGzHrzkCv5rUNDzqlhmhowOBqC0XqUHFpW+vJ45+20/IFBcebwKfiS2Z9fJin6Eo+F1zLZsxi8RA==",
+      "dev": true,
+      "requires": {
+        "commander": "^2.20.0",
+        "source-map": "~0.6.1",
+        "source-map-support": "~0.5.12"
+      }
+    },
+    "test-exclude": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-5.2.3.tgz",
+      "integrity": "sha512-M+oxtseCFO3EDtAaGH7iiej3CBkzXqFMbzqYAACdzKui4eZA+pq3tZEwChvOdNfa7xxy8BfbmgJSIr43cC/+2g==",
+      "dev": true,
+      "requires": {
+        "glob": "^7.1.3",
+        "minimatch": "^3.0.4",
+        "read-pkg-up": "^4.0.0",
+        "require-main-filename": "^2.0.0"
+      }
+    },
+    "text-table": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
+      "integrity": "sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=",
+      "dev": true
+    },
+    "through": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
+      "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=",
+      "dev": true
+    },
+    "tmp": {
+      "version": "0.0.33",
+      "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz",
+      "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==",
+      "dev": true,
+      "requires": {
+        "os-tmpdir": "~1.0.2"
+      }
+    },
+    "to-fast-properties": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz",
+      "integrity": "sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4=",
+      "dev": true
+    },
+    "to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "requires": {
+        "is-number": "^7.0.0"
+      }
+    },
+    "to-vfile": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/to-vfile/-/to-vfile-6.0.0.tgz",
+      "integrity": "sha512-i9fwXXSsHLu7mzgixc1WjgnqSe6pGpjnzCYoFmrASvEueLfyKf09QAe+XQYu8OAJ62aFqHpe2EKXojeRVvEzqA==",
+      "dev": true,
+      "requires": {
+        "is-buffer": "^2.0.0",
+        "vfile": "^4.0.0"
+      }
+    },
+    "tough-cookie": {
+      "version": "2.4.3",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.4.3.tgz",
+      "integrity": "sha512-Q5srk/4vDM54WJsJio3XNn6K2sCG+CQ8G5Wz6bZhRZoAe/+TxjWB/GlFAnYEbkYVlON9FMk/fE3h2RLpPXo4lQ==",
+      "dev": true,
+      "requires": {
+        "psl": "^1.1.24",
+        "punycode": "^1.4.1"
+      },
+      "dependencies": {
+        "punycode": {
+          "version": "1.4.1",
+          "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz",
+          "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=",
+          "dev": true
+        }
+      }
+    },
+    "trim": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/trim/-/trim-0.0.1.tgz",
+      "integrity": "sha1-WFhUf2spB1fulczMZm+1AITEYN0=",
+      "dev": true
+    },
+    "trim-trailing-lines": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/trim-trailing-lines/-/trim-trailing-lines-1.1.2.tgz",
+      "integrity": "sha512-MUjYItdrqqj2zpcHFTkMa9WAv4JHTI6gnRQGPFLrt5L9a6tRMiDnIqYl8JBvu2d2Tc3lWJKQwlGCp0K8AvCM+Q==",
+      "dev": true
+    },
+    "trivial-deferred": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/trivial-deferred/-/trivial-deferred-1.0.1.tgz",
+      "integrity": "sha1-N21NKdlR1jaKb3oK6FwvTV4GWPM=",
+      "dev": true
+    },
+    "trough": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/trough/-/trough-1.0.4.tgz",
+      "integrity": "sha512-tdzBRDGWcI1OpPVmChbdSKhvSVurznZ8X36AYURAcl+0o2ldlCY2XPzyXNNxwJwwyIU+rIglTCG4kxtNKBQH7Q==",
+      "dev": true
+    },
+    "ts-node": {
+      "version": "8.5.4",
+      "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-8.5.4.tgz",
+      "integrity": "sha512-izbVCRV68EasEPQ8MSIGBNK9dc/4sYJJKYA+IarMQct1RtEot6Xp0bXuClsbUSnKpg50ho+aOAx8en5c+y4OFw==",
+      "dev": true,
+      "requires": {
+        "arg": "^4.1.0",
+        "diff": "^4.0.1",
+        "make-error": "^1.1.1",
+        "source-map-support": "^0.5.6",
+        "yn": "^3.0.0"
+      }
+    },
+    "tslib": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.10.0.tgz",
+      "integrity": "sha512-qOebF53frne81cf0S9B41ByenJ3/IuH8yJKngAX35CmiZySA0khhkovshKK+jGCaMnVomla7gVlIcc3EvKPbTQ==",
+      "dev": true
+    },
+    "tunnel-agent": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz",
+      "integrity": "sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=",
+      "dev": true,
+      "requires": {
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "tweetnacl": {
+      "version": "0.14.5",
+      "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz",
+      "integrity": "sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=",
+      "dev": true
+    },
+    "type-check": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz",
+      "integrity": "sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=",
+      "dev": true,
+      "requires": {
+        "prelude-ls": "~1.1.2"
+      }
+    },
+    "type-fest": {
+      "version": "0.8.1",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz",
+      "integrity": "sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==",
+      "dev": true
+    },
+    "typedarray": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz",
+      "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=",
+      "dev": true
+    },
+    "typedarray-to-buffer": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz",
+      "integrity": "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==",
+      "dev": true,
+      "requires": {
+        "is-typedarray": "^1.0.0"
+      }
+    },
+    "typescript": {
+      "version": "3.7.4",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.7.4.tgz",
+      "integrity": "sha512-A25xv5XCtarLwXpcDNZzCGvW2D1S3/bACratYBx2sax8PefsFhlYmkQicKHvpYflFS8if4zne5zT5kpJ7pzuvw==",
+      "dev": true
+    },
+    "uglify-js": {
+      "version": "3.7.2",
+      "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.7.2.tgz",
+      "integrity": "sha512-uhRwZcANNWVLrxLfNFEdltoPNhECUR3lc+UdJoG9CBpMcSnKyWA94tc3eAujB1GcMY5Uwq8ZMp4qWpxWYDQmaA==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "commander": "~2.20.3",
+        "source-map": "~0.6.1"
+      }
+    },
+    "unherit": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/unherit/-/unherit-1.1.2.tgz",
+      "integrity": "sha512-W3tMnpaMG7ZY6xe/moK04U9fBhi6wEiCYHUW5Mop/wQHf12+79EQGwxYejNdhEz2mkqkBlGwm7pxmgBKMVUj0w==",
+      "dev": true,
+      "requires": {
+        "inherits": "^2.0.1",
+        "xtend": "^4.0.1"
+      }
+    },
+    "unicode-length": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/unicode-length/-/unicode-length-1.0.3.tgz",
+      "integrity": "sha1-Wtp6f+1RhBpBijKM8UlHisg1irs=",
+      "dev": true,
+      "requires": {
+        "punycode": "^1.3.2",
+        "strip-ansi": "^3.0.1"
+      },
+      "dependencies": {
+        "ansi-regex": {
+          "version": "2.1.1",
+          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz",
+          "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=",
+          "dev": true
+        },
+        "punycode": {
+          "version": "1.4.1",
+          "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz",
+          "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=",
+          "dev": true
+        },
+        "strip-ansi": {
+          "version": "3.0.1",
+          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz",
+          "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=",
+          "dev": true,
+          "requires": {
+            "ansi-regex": "^2.0.0"
+          }
+        }
+      }
+    },
+    "unified": {
+      "version": "8.4.2",
+      "resolved": "https://registry.npmjs.org/unified/-/unified-8.4.2.tgz",
+      "integrity": "sha512-JCrmN13jI4+h9UAyKEoGcDZV+i1E7BLFuG7OsaDvTXI5P0qhHX+vZO/kOhz9jn8HGENDKbwSeB0nVOg4gVStGA==",
+      "dev": true,
+      "requires": {
+        "bail": "^1.0.0",
+        "extend": "^3.0.0",
+        "is-plain-obj": "^2.0.0",
+        "trough": "^1.0.0",
+        "vfile": "^4.0.0"
+      }
+    },
+    "unified-args": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/unified-args/-/unified-args-7.1.0.tgz",
+      "integrity": "sha512-soi9Rn7l5c1g0RfElSCHMwaxeiclSI0EsS3uZmMPUOfwMeeeZjLpNmHAowV9iSlQh59iiZhSMyQu9lB8WnIz5g==",
+      "dev": true,
+      "requires": {
+        "camelcase": "^5.0.0",
+        "chalk": "^2.0.0",
+        "chokidar": "^3.0.0",
+        "fault": "^1.0.2",
+        "json5": "^2.0.0",
+        "minimist": "^1.2.0",
+        "text-table": "^0.2.0",
+        "unified-engine": "^7.0.0"
+      },
+      "dependencies": {
+        "minimist": {
+          "version": "1.2.0",
+          "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
+          "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
+          "dev": true
+        }
+      }
+    },
+    "unified-engine": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/unified-engine/-/unified-engine-7.0.0.tgz",
+      "integrity": "sha512-zH/MvcISpWg3JZtCoY/GYBw1WnVHkhnPoMBWpmuvAifCPSS9mzT9EbtimesJp6t2nnr/ojI0mg3TmkO1CjIwVA==",
+      "dev": true,
+      "requires": {
+        "concat-stream": "^2.0.0",
+        "debug": "^4.0.0",
+        "fault": "^1.0.0",
+        "figures": "^3.0.0",
+        "fn-name": "^2.0.1",
+        "glob": "^7.0.3",
+        "ignore": "^5.0.0",
+        "is-empty": "^1.0.0",
+        "is-hidden": "^1.0.1",
+        "is-object": "^1.0.1",
+        "js-yaml": "^3.6.1",
+        "load-plugin": "^2.0.0",
+        "parse-json": "^4.0.0",
+        "to-vfile": "^6.0.0",
+        "trough": "^1.0.0",
+        "unist-util-inspect": "^4.1.2",
+        "vfile-reporter": "^6.0.0",
+        "vfile-statistics": "^1.1.0",
+        "x-is-string": "^0.1.0",
+        "xtend": "^4.0.1"
+      },
+      "dependencies": {
+        "ignore": {
+          "version": "5.1.4",
+          "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.1.4.tgz",
+          "integrity": "sha512-MzbUSahkTW1u7JpKKjY7LCARd1fU5W2rLdxlM4kdkayuCwZImjkpluF9CM1aLewYJguPDqewLam18Y6AU69A8A==",
+          "dev": true
+        }
+      }
+    },
+    "unified-lint-rule": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-1.0.4.tgz",
+      "integrity": "sha512-q9wY6S+d38xRAuWQVOMjBQYi7zGyKkY23ciNafB8JFVmDroyKjtytXHCg94JnhBCXrNqpfojo3+8D+gmF4zxJQ==",
+      "dev": true,
+      "requires": {
+        "wrapped": "^1.0.1"
+      }
+    },
+    "unified-message-control": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/unified-message-control/-/unified-message-control-1.0.4.tgz",
+      "integrity": "sha512-e1dEtN4Z/TvLn/qHm+xeZpzqhJTtfZusFErk336kkZVpqrJYiV9ptxq+SbRPFMlN0OkjDYHmVJ929KYjsMTo3g==",
+      "dev": true,
+      "requires": {
+        "trim": "0.0.1",
+        "unist-util-visit": "^1.0.0",
+        "vfile-location": "^2.0.0"
+      }
+    },
+    "unist-util-generated": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/unist-util-generated/-/unist-util-generated-1.1.4.tgz",
+      "integrity": "sha512-SA7Sys3h3X4AlVnxHdvN/qYdr4R38HzihoEVY2Q2BZu8NHWDnw5OGcC/tXWjQfd4iG+M6qRFNIRGqJmp2ez4Ww==",
+      "dev": true
+    },
+    "unist-util-inspect": {
+      "version": "4.1.4",
+      "resolved": "https://registry.npmjs.org/unist-util-inspect/-/unist-util-inspect-4.1.4.tgz",
+      "integrity": "sha512-7xxyvKiZ1SC9vL5qrMqKub1T31gRHfau4242F69CcaOrXt//5PmRVOmDZ36UAEgiT+tZWzmQmbNZn+mVtnR9HQ==",
+      "dev": true,
+      "requires": {
+        "is-empty": "^1.0.0"
+      }
+    },
+    "unist-util-is": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-2.1.2.tgz",
+      "integrity": "sha512-YkXBK/H9raAmG7KXck+UUpnKiNmUdB+aBGrknfQ4EreE1banuzrKABx3jP6Z5Z3fMSPMQQmeXBlKpCbMwBkxVw==",
+      "dev": true
+    },
+    "unist-util-position": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-3.0.3.tgz",
+      "integrity": "sha512-28EpCBYFvnMeq9y/4w6pbnFmCUfzlsc41NJui5c51hOFjBA1fejcwc+5W4z2+0ECVbScG3dURS3JTVqwenzqZw==",
+      "dev": true
+    },
+    "unist-util-remove-position": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/unist-util-remove-position/-/unist-util-remove-position-1.1.4.tgz",
+      "integrity": "sha512-tLqd653ArxJIPnKII6LMZwH+mb5q+n/GtXQZo6S6csPRs5zB0u79Yw8ouR3wTw8wxvdJFhpP6Y7jorWdCgLO0A==",
+      "dev": true,
+      "requires": {
+        "unist-util-visit": "^1.1.0"
+      }
+    },
+    "unist-util-stringify-position": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-2.0.2.tgz",
+      "integrity": "sha512-nK5n8OGhZ7ZgUwoUbL8uiVRwAbZyzBsB/Ddrlbu6jwwubFza4oe15KlyEaLNMXQW1svOQq4xesUeqA85YrIUQA==",
+      "dev": true,
+      "requires": {
+        "@types/unist": "^2.0.2"
+      }
+    },
+    "unist-util-visit": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-1.4.0.tgz",
+      "integrity": "sha512-FiGu34ziNsZA3ZUteZxSFaczIjGmksfSgdKqBfOejrrfzyUy5b7YrlzT1Bcvi+djkYDituJDy2XB7tGTeBieKw==",
+      "dev": true,
+      "requires": {
+        "unist-util-visit-parents": "^2.0.0"
+      }
+    },
+    "unist-util-visit-parents": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-2.0.1.tgz",
+      "integrity": "sha512-6B0UTiMfdWql4cQ03gDTCSns+64Zkfo2OCbK31Ov0uMizEz+CJeAp0cgZVb5Fhmcd7Bct2iRNywejT0orpbqUA==",
+      "dev": true,
+      "requires": {
+        "unist-util-is": "^2.1.2"
+      }
+    },
+    "untildify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/untildify/-/untildify-2.1.0.tgz",
+      "integrity": "sha1-F+soB5h/dpUunASF/DEdBqgmouA=",
+      "dev": true,
+      "requires": {
+        "os-homedir": "^1.0.0"
+      }
+    },
+    "uri-js": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.2.2.tgz",
+      "integrity": "sha512-KY9Frmirql91X2Qgjry0Wd4Y+YTdrdZheS8TFwvkbLWf/G5KNJDCh6pKL5OZctEW4+0Baa5idK2ZQuELRwPznQ==",
+      "dev": true,
+      "requires": {
+        "punycode": "^2.1.0"
+      }
+    },
+    "util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=",
+      "dev": true
+    },
+    "uuid": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.3.3.tgz",
+      "integrity": "sha512-pW0No1RGHgzlpHJO1nsVrHKpOEIxkGg1xB+v0ZmdNH5OAeAwzAVrCnI2/6Mtx+Uys6iaylxa+D3g4j63IKKjSQ==",
+      "dev": true
+    },
+    "v8-compile-cache": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.1.0.tgz",
+      "integrity": "sha512-usZBT3PW+LOjM25wbqIlZwPeJV+3OSz3M1k1Ws8snlW39dZyYL9lOGC5FgPVHfk0jKmjiDV8Z0mIbVQPiwFs7g==",
+      "dev": true
+    },
+    "validate-npm-package-license": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz",
+      "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==",
+      "dev": true,
+      "requires": {
+        "spdx-correct": "^3.0.0",
+        "spdx-expression-parse": "^3.0.0"
+      }
+    },
+    "verror": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz",
+      "integrity": "sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA=",
+      "dev": true,
+      "requires": {
+        "assert-plus": "^1.0.0",
+        "core-util-is": "1.0.2",
+        "extsprintf": "^1.2.0"
+      }
+    },
+    "vfile": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/vfile/-/vfile-4.0.2.tgz",
+      "integrity": "sha512-yhoTU5cDMSsaeaMfJ5g0bUKYkYmZhAh9fn9TZicxqn+Cw4Z439il2v3oT9S0yjlpqlI74aFOQCt3nOV+pxzlkw==",
+      "dev": true,
+      "requires": {
+        "@types/unist": "^2.0.0",
+        "is-buffer": "^2.0.0",
+        "replace-ext": "1.0.0",
+        "unist-util-stringify-position": "^2.0.0",
+        "vfile-message": "^2.0.0"
+      }
+    },
+    "vfile-location": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-2.0.4.tgz",
+      "integrity": "sha512-KRL5uXQPoUKu+NGvQVL4XLORw45W62v4U4gxJ3vRlDfI9QsT4ZN1PNXn/zQpKUulqGDpYuT0XDfp5q9O87/y/w==",
+      "dev": true
+    },
+    "vfile-message": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-2.0.2.tgz",
+      "integrity": "sha512-gNV2Y2fDvDOOqq8bEe7cF3DXU6QgV4uA9zMR2P8tix11l1r7zju3zry3wZ8sx+BEfuO6WQ7z2QzfWTvqHQiwsA==",
+      "dev": true,
+      "requires": {
+        "@types/unist": "^2.0.0",
+        "unist-util-stringify-position": "^2.0.0"
+      }
+    },
+    "vfile-reporter": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/vfile-reporter/-/vfile-reporter-6.0.0.tgz",
+      "integrity": "sha512-8Is0XxFxWJUhPJdOg3CyZTqd3ICCWg6r304PuBl818ZG91h4FMS3Q+lrOPS+cs5/DZK3H0+AkJdH0J8JEwKtDA==",
+      "dev": true,
+      "requires": {
+        "repeat-string": "^1.5.0",
+        "string-width": "^4.0.0",
+        "supports-color": "^6.0.0",
+        "unist-util-stringify-position": "^2.0.0",
+        "vfile-sort": "^2.1.2",
+        "vfile-statistics": "^1.1.0"
+      },
+      "dependencies": {
+        "supports-color": {
+          "version": "6.1.0",
+          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-6.1.0.tgz",
+          "integrity": "sha512-qe1jfm1Mg7Nq/NSh6XE24gPXROEVsWHxC1LIx//XNlD9iw7YZQGjZNjYN7xGaEG6iKdA8EtNFW6R0gjnVXp+wQ==",
+          "dev": true,
+          "requires": {
+            "has-flag": "^3.0.0"
+          }
+        }
+      }
+    },
+    "vfile-sort": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/vfile-sort/-/vfile-sort-2.2.1.tgz",
+      "integrity": "sha512-5dt7xEhC44h0uRQKhbM2JAe0z/naHphIZlMOygtMBM9Nn0pZdaX5fshhwWit9wvsuP8t/wp43nTDRRErO1WK8g==",
+      "dev": true
+    },
+    "vfile-statistics": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/vfile-statistics/-/vfile-statistics-1.1.3.tgz",
+      "integrity": "sha512-CstaK/ebTz1W3Qp41Bt9Lj/2DmumFsCwC2sKahDNSPh0mPh7/UyMLCoU8ZBX34CRU0d61B4W41yIFsV0NKMZeA==",
+      "dev": true
+    },
+    "vlq": {
+      "version": "0.2.3",
+      "resolved": "https://registry.npmjs.org/vlq/-/vlq-0.2.3.tgz",
+      "integrity": "sha512-DRibZL6DsNhIgYQ+wNdWDL2SL3bKPlVrRiBqV5yuMm++op8W4kGFtaQfCs4KEJn0wBZcHVHJ3eoywX8983k1ow==",
+      "dev": true
+    },
+    "which": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz",
+      "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==",
+      "dev": true,
+      "requires": {
+        "isexe": "^2.0.0"
+      }
+    },
+    "which-module": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/which-module/-/which-module-2.0.0.tgz",
+      "integrity": "sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho=",
+      "dev": true
+    },
+    "word-wrap": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz",
+      "integrity": "sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==",
+      "dev": true
+    },
+    "wordwrap": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.3.tgz",
+      "integrity": "sha1-o9XabNXAvAAI03I0u68b7WMFkQc=",
+      "dev": true
+    },
+    "wrap-ansi": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-2.1.0.tgz",
+      "integrity": "sha1-2Pw9KE3QV5T+hJc8rs3Rz4JP3YU=",
+      "dev": true,
+      "requires": {
+        "string-width": "^1.0.1",
+        "strip-ansi": "^3.0.1"
+      },
+      "dependencies": {
+        "ansi-regex": {
+          "version": "2.1.1",
+          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz",
+          "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=",
+          "dev": true
+        },
+        "is-fullwidth-code-point": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz",
+          "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=",
+          "dev": true,
+          "requires": {
+            "number-is-nan": "^1.0.0"
+          }
+        },
+        "string-width": {
+          "version": "1.0.2",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz",
+          "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=",
+          "dev": true,
+          "requires": {
+            "code-point-at": "^1.0.0",
+            "is-fullwidth-code-point": "^1.0.0",
+            "strip-ansi": "^3.0.0"
+          }
+        },
+        "strip-ansi": {
+          "version": "3.0.1",
+          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz",
+          "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=",
+          "dev": true,
+          "requires": {
+            "ansi-regex": "^2.0.0"
+          }
+        }
+      }
+    },
+    "wrapped": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/wrapped/-/wrapped-1.0.1.tgz",
+      "integrity": "sha1-x4PZ2Aeyc+mwHoUWgKk4yHyQckI=",
+      "dev": true,
+      "requires": {
+        "co": "3.1.0",
+        "sliced": "^1.0.1"
+      }
+    },
+    "wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
+      "dev": true
+    },
+    "write": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/write/-/write-1.0.3.tgz",
+      "integrity": "sha512-/lg70HAjtkUgWPVZhZcm+T4hkL8Zbtp1nFNOn3lRrxnlv50SRBv7cR7RqR+GMsd3hUXy9hWBo4CHTbFTcOYwig==",
+      "dev": true,
+      "requires": {
+        "mkdirp": "^0.5.1"
+      }
+    },
+    "write-file-atomic": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-3.0.1.tgz",
+      "integrity": "sha512-JPStrIyyVJ6oCSz/691fAjFtefZ6q+fP6tm+OS4Qw6o+TGQxNp1ziY2PgS+X/m0V8OWhZiO/m4xSj+Pr4RrZvw==",
+      "dev": true,
+      "requires": {
+        "imurmurhash": "^0.1.4",
+        "is-typedarray": "^1.0.0",
+        "signal-exit": "^3.0.2",
+        "typedarray-to-buffer": "^3.1.5"
+      }
+    },
+    "x-is-string": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/x-is-string/-/x-is-string-0.1.0.tgz",
+      "integrity": "sha1-R0tQhlrzpJqcRlfwWs0UVFj3fYI=",
+      "dev": true
+    },
+    "xtend": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.1.tgz",
+      "integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68=",
+      "dev": true
+    },
+    "y18n": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.0.tgz",
+      "integrity": "sha512-r9S/ZyXu/Xu9q1tYlpsLIsa3EeLXXk0VwlxqTcFRfg9EhMW+17kbt9G0NrgCmhGb5vT2hyhJZLfDGx+7+5Uj/w==",
+      "dev": true
+    },
+    "yallist": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz",
+      "integrity": "sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=",
+      "dev": true
+    },
+    "yaml": {
+      "version": "1.7.2",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-1.7.2.tgz",
+      "integrity": "sha512-qXROVp90sb83XtAoqE8bP9RwAkTTZbugRUTm5YeFCBfNRPEp2YzTeqWiz7m5OORHzEvrA/qcGS8hp/E+MMROYw==",
+      "dev": true,
+      "requires": {
+        "@babel/runtime": "^7.6.3"
+      }
+    },
+    "yapool": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/yapool/-/yapool-1.0.0.tgz",
+      "integrity": "sha1-9pPymjFbUNmp2iZGp6ZkXJaYW2o=",
+      "dev": true
+    },
+    "yargs": {
+      "version": "13.3.0",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-13.3.0.tgz",
+      "integrity": "sha512-2eehun/8ALW8TLoIl7MVaRUrg+yCnenu8B4kBlRxj3GJGDKU1Og7sMXPNm1BYyM1DOJmTZ4YeN/Nwxv+8XJsUA==",
+      "dev": true,
+      "requires": {
+        "cliui": "^5.0.0",
+        "find-up": "^3.0.0",
+        "get-caller-file": "^2.0.1",
+        "require-directory": "^2.1.1",
+        "require-main-filename": "^2.0.0",
+        "set-blocking": "^2.0.0",
+        "string-width": "^3.0.0",
+        "which-module": "^2.0.0",
+        "y18n": "^4.0.0",
+        "yargs-parser": "^13.1.1"
+      },
+      "dependencies": {
+        "cliui": {
+          "version": "5.0.0",
+          "resolved": "https://registry.npmjs.org/cliui/-/cliui-5.0.0.tgz",
+          "integrity": "sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA==",
+          "dev": true,
+          "requires": {
+            "string-width": "^3.1.0",
+            "strip-ansi": "^5.2.0",
+            "wrap-ansi": "^5.1.0"
+          }
+        },
+        "emoji-regex": {
+          "version": "7.0.3",
+          "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
+          "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==",
+          "dev": true
+        },
+        "is-fullwidth-code-point": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
+          "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
+          "dev": true
+        },
+        "string-width": {
+          "version": "3.1.0",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
+          "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
+          "dev": true,
+          "requires": {
+            "emoji-regex": "^7.0.1",
+            "is-fullwidth-code-point": "^2.0.0",
+            "strip-ansi": "^5.1.0"
+          }
+        },
+        "wrap-ansi": {
+          "version": "5.1.0",
+          "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-5.1.0.tgz",
+          "integrity": "sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==",
+          "dev": true,
+          "requires": {
+            "ansi-styles": "^3.2.0",
+            "string-width": "^3.0.0",
+            "strip-ansi": "^5.0.0"
+          }
+        }
+      }
+    },
+    "yargs-parser": {
+      "version": "13.1.1",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-13.1.1.tgz",
+      "integrity": "sha512-oVAVsHz6uFrg3XQheFII8ESO2ssAf9luWuAd6Wexsu4F3OtIW0o8IribPXYrD4WC24LWtPrJlGy87y5udK+dxQ==",
+      "dev": true,
+      "requires": {
+        "camelcase": "^5.0.0",
+        "decamelize": "^1.2.0"
+      }
+    },
+    "yn": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz",
+      "integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==",
+      "dev": true
+    }
+  }
+}

static/lib/Hyphenopoly-master/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "hyphenopoly",
+  "version": "3.4.0",
+  "description": "Hyphenation for node and Polyfill for client-side hyphenation.",
+  "keywords": [
+    "hyphenation",
+    "html",
+    "polyfill",
+    "hyphens",
+    "hyphen",
+    "soft",
+    "hyphenate",
+    "JavaScript"
+  ],
+  "homepage": "https://github.com/mnater/Hyphenopoly",
+  "bugs": "https://github.com/mnater/Hyphenopoly/issues",
+  "license": "MIT",
+  "author": {
+    "name": "Mathias Nater",
+    "email": "mathiasnater@gmail.com"
+  },
+  "files": [
+    "hyphenEngine.asm.js",
+    "hyphenEngine.wasm",
+    "Hyphenopoly_Loader.js",
+    "Hyphenopoly.js",
+    "patterns/",
+    "min/hyphenEngine.asm.js",
+    "min/hyphenEngine.wasm",
+    "min/Hyphenopoly_Loader.js",
+    "min/Hyphenopoly.js",
+    "min/patterns/",
+    "example.js",
+    "example.html"
+  ],
+  "main": "hyphenopoly.module.js",
+  "engines": {
+    "node": ">=8.3.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mnater/Hyphenopoly"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "eslint": "^6.8.0",
+    "eslint-plugin-security": "^1.4.0",
+    "remark-cli": "^7.0.1",
+    "remark-preset-lint-recommended": "^3.0.3",
+    "tap": "^14.10.5",
+    "terser": "^4.4.3"
+  },
+  "remarkConfig": {
+    "plugins": [
+      "remark-preset-lint-recommended"
+    ]
+  },
+  "scripts": {
+    "preinstall3rdparty": "rm -fR third-party",
+    "install3rdparty": "git clone https://github.com/WebAssembly/binaryen.git third-party/binaryen",
+    "postinstall3rdparty": "cd ./third-party/binaryen/ && cmake . && make",
+    "compilewasm": "sh ./tools/compileWASM.sh hyphenEngine",
+    "test": "tap test/*.js --coverage",
+    "testsuite": "open http://127.0.0.1/~mnater/Hyphenopoly/testsuite/ && open http://127.0.0.1/~mnater/Hyphenopoly/min/testsuite/",
+    "lint": "eslint Hyphenopoly_Loader.js Hyphenopoly.js hyphenopoly.module.js test/*.js && npm run lint-md",
+    "lint-md": "remark *.md",
+    "prepare": "npm run minify",
+    "minify": "sh ./tools/minify.sh",
+    "doc": "cd ./docs/ && bundle exec jekyll serve -l -o"
+  },
+  "runkitExampleFilename": "example.js"
+}