diff --git a/node_modules/.bin/mustache b/node_modules/.bin/mustache
new file mode 120000
index 00000000..f8b71975
--- /dev/null
+++ b/node_modules/.bin/mustache
@@ -0,0 +1 @@
+../mustache/bin/mustache
\ No newline at end of file
diff --git a/node_modules/.yarn-integrity b/node_modules/.yarn-integrity
index 0ec0b279..353964c1 100644
--- a/node_modules/.yarn-integrity
+++ b/node_modules/.yarn-integrity
@@ -30,6 +30,7 @@
"sequelize-cli@^5.5.0",
"sequelize@^5.10.1",
"sucrase@^3.10.1",
+ "youch@^2.0.10",
"yup@^0.27.0"
],
"lockfileEntries": {
@@ -138,6 +139,7 @@
"cookie-signature@1.0.6": "https://registry.yarnpkg.com/cookie-signature/-/cookie-signature-1.0.6.tgz#e303a882b342cc3ee8ca513a79999734dab3ae2c",
"cookie@0.3.1": "https://registry.yarnpkg.com/cookie/-/cookie-0.3.1.tgz#e7e0a1f9ef43b4c8ba925c5c5a96e806d16873bb",
"cookie@0.4.0": "https://registry.yarnpkg.com/cookie/-/cookie-0.4.0.tgz#beb437e7022b3b6d49019d088665303ebe9c14ba",
+ "cookie@^0.3.1": "https://registry.yarnpkg.com/cookie/-/cookie-0.3.1.tgz#e7e0a1f9ef43b4c8ba925c5c5a96e806d16873bb",
"copy-descriptor@^0.1.0": "https://registry.yarnpkg.com/copy-descriptor/-/copy-descriptor-0.1.1.tgz#676f6eb3c39997c2ee1ac3a924fd6124748f578d",
"core-js@^2.4.0": "https://registry.yarnpkg.com/core-js/-/core-js-2.6.9.tgz#6b4b214620c834152e179323727fc19741b084f2",
"core-util-is@~1.0.0": "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7",
@@ -434,6 +436,7 @@
"ms@2.1.2": "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009",
"ms@^2.1.1": "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009",
"multer@^1.4.2": "https://registry.yarnpkg.com/multer/-/multer-1.4.2.tgz#2f1f4d12dbaeeba74cb37e623f234bf4d3d2057a",
+ "mustache@^3.0.0": "https://registry.yarnpkg.com/mustache/-/mustache-3.0.1.tgz#873855f23aa8a95b150fb96d9836edbc5a1d248a",
"mute-stream@0.0.7": "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.7.tgz#3075ce93bc21b8fab43e1bc4da7e8115ed1e7bab",
"mz@^2.7.0": "https://registry.yarnpkg.com/mz/-/mz-2.7.0.tgz#95008057a56cafadc2bc63dde7f9ff6955948e32",
"nan@^2.12.1": "https://registry.yarnpkg.com/nan/-/nan-2.14.0.tgz#7818f722027b2459a86f0295d434d1fc2336c52c",
@@ -635,6 +638,7 @@
"split-string@^3.0.2": "https://registry.yarnpkg.com/split-string/-/split-string-3.1.0.tgz#7cb09dda3a86585705c64b39a6466038682e8fe2",
"split@^1.0.0": "https://registry.yarnpkg.com/split/-/split-1.0.1.tgz#605bd9be303aa59fb35f9229fbea0ddec9ea07d9",
"sprintf-js@~1.0.2": "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c",
+ "stack-trace@0.0.10": "https://registry.yarnpkg.com/stack-trace/-/stack-trace-0.0.10.tgz#547c70b347e8d32b4e108ea1a2a159e5fdde19c0",
"static-extend@^0.1.1": "https://registry.yarnpkg.com/static-extend/-/static-extend-0.1.2.tgz#60809c39cbff55337226fd5e0b520f341f1fb5c6",
"statuses@>= 1.5.0 < 2": "https://registry.yarnpkg.com/statuses/-/statuses-1.5.0.tgz#161c7dac177659fd9811f43771fa99381478628c",
"statuses@~1.5.0": "https://registry.yarnpkg.com/statuses/-/statuses-1.5.0.tgz#161c7dac177659fd9811f43771fa99381478628c",
@@ -731,6 +735,7 @@
"yallist@^3.0.3": "https://registry.yarnpkg.com/yallist/-/yallist-3.0.3.tgz#b4b049e314be545e3ce802236d6cd22cd91c3de9",
"yargs-parser@^13.1.1": "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-13.1.1.tgz#d26058532aa06d365fe091f6a1fc06b2f7e5eca0",
"yargs@^13.1.0": "https://registry.yarnpkg.com/yargs/-/yargs-13.3.0.tgz#4c657a55e07e5f2cf947f8a366567c04a0dedc83",
+ "youch@^2.0.10": "https://registry.yarnpkg.com/youch/-/youch-2.0.10.tgz#e0f6312b12304fd330a0c4a0e0925b0123f7d495",
"yup@^0.27.0": "https://registry.yarnpkg.com/yup/-/yup-0.27.0.tgz#f8cb198c8e7dd2124beddc2457571329096b06e7"
},
"files": [],
diff --git a/node_modules/mustache/CHANGELOG.md b/node_modules/mustache/CHANGELOG.md
new file mode 100644
index 00000000..912d7908
--- /dev/null
+++ b/node_modules/mustache/CHANGELOG.md
@@ -0,0 +1,427 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## [3.0.1] / 11 November 2018
+
+ * [#679]: Fix partials not rendering tokens when using custom tags, by [@stackchain].
+
+## [3.0.0] / 16 September 2018
+
+We are very happy to announce a new major version of mustache.js. We want to be very careful not to break projects
+out in the wild, and adhering to [Semantic Versioning](http://semver.org/) we have therefore cut this new major version.
+
+The changes introduced will likely not require any actions for most using projects. The things to look out for that
+might cause unexpected rendering results are described in the migration guide below.
+
+A big shout out and thanks to [@raymond-lam] for this release! Without his contributions with code and issue triaging,
+this release would never have happened.
+
+### Major
+
+* [#618]: Allow rendering properties of primitive types that are not objects, by [@raymond-lam].
+* [#643]: `Writer.prototype.parse` to cache by tags in addition to template string, by [@raymond-lam].
+* [#664]: Fix `Writer.prototype.parse` cache, by [@seminaoki].
+
+### Minor
+
+* [#673]: Add `tags` parameter to `Mustache.render()`, by [@raymond-lam].
+
+### Migrating from mustache.js v2.x to v3.x
+
+#### Rendering properties of primitive types
+
+We have ensured properties of primitive types can be rendered at all times. That means `Array.length`, `String.length`
+and similar. A corner case where this could cause unexpected output follows:
+
+View:
+```
+{
+ stooges: [
+ { name: "Moe" },
+ { name: "Larry" },
+ { name: "Curly" }
+ ]
+}
+```
+
+Template:
+```
+{{#stooges}}
+ {{name}}: {{name.length}} characters
+{{/stooges}}
+```
+
+Output with v3.0:
+```
+ Moe: 3 characters
+ Larry: 5 characters
+ Curly: 5 characters
+```
+
+Output with v2.x:
+```
+ Moe: characters
+ Larry: characters
+ Curly: characters
+```
+
+#### Caching for templates with custom delimiters
+
+We have improved the templates cache to ensure custom delimiters are taken into consideration for the cache.
+This improvement might cause unexpected rendering behaviour for using projects actively using the custom delimiters functionality.
+
+Previously it was possible to use `Mustache.parse()` as a means to set global custom delimiters. If custom
+delimiters were provided as an argument, it would affect all following calls to `Mustache.render()`.
+Consider the following:
+
+```js
+const template = "[[item.title]] [[item.value]]";
+mustache.parse(template, ["[[", "]]"]);
+
+console.log(
+ mustache.render(template, {
+ item: {
+ title: "TEST",
+ value: 1
+ }
+ })
+);
+
+>> TEST 1
+```
+
+The above illustrates the fact that `Mustache.parse()` made mustache.js cache the template without considering
+the custom delimiters provided. This is no longer true.
+
+We no longer encourage using `Mustache.parse()` for this purpose, but have rather added a fourth argument to
+`Mustache.render()` letting you provide custom delimiters when rendering.
+
+If you still need the pre-parse the template and use custom delimiters at the same time, ensure to provide
+the custom delimiters as argument to `Mustache.render()` as well.
+
+## [2.3.2] / 17 August 2018
+
+This release is made to revert changes introduced in [2.3.1] that caused unexpected behaviour for several users.
+
+### Minor
+
+ * [#670]: Rollback template cache causing unexpected behaviour, by [@raymond-lam].
+
+## [2.3.1] / 7 August 2018
+
+### Minor
+
+ * [#643]: `Writer.prototype.parse` to cache by tags in addition to template string, by [@raymond-lam].
+ * [#664]: Fix `Writer.prototype.parse` cache, by [@seminaoki].
+
+### Dev
+
+ * [#666]: Install release tools with npm rather than pre-commit hook & `Rakefile`, by [@phillipj].
+ * [#667], [#668]: Stabilize browser test suite, by [@phillipj].
+
+### Docs
+
+ * [#644]: Document global Mustache.escape overriding capacity, by [@paultopia].
+ * [#657]: Correct `Mustache.parse()` return type documentation, by [@bbrooks].
+
+## [2.3.0] / 8 November 2016
+
+### Minor
+
+ * [#540]: Add optional `output` argument to mustache CLI, by [@wizawu].
+ * [#597]: Add compatibility with amdclean, by [@mightyplow].
+
+### Dev
+
+ * [#553]: Assert `null` lookup when rendering an unescaped value, by [@dasilvacontin].
+ * [#580], [#610]: Ignore eslint for greenkeeper updates, by [@phillipj].
+ * [#560]: Fix CLI tests for Windows, by [@kookookchoozeus].
+ * Run browser tests w/node v4, by [@phillipj].
+
+### Docs
+
+ * [#542]: Add API documentation to README, by [@tomekwi].
+ * [#546]: Add missing syntax highlighting to README code blocks, by [@pra85].
+ * [#569]: Update Ctemplate links in README, by [@mortonfox].
+ * [#592]: Change "loadUser" to "loadUser()" in README, by [@Flaque].
+ * [#593]: Adding doctype to HTML code example in README, by [@calvinf].
+
+### Dependencies
+
+ * eslint -> 2.2.0. Breaking changes fix by [@phillipj]. [#548]
+ * eslint -> 2.5.1.
+ * mocha -> 3.0.2.
+ * zuul -> 3.11.0.
+
+## [2.2.1] / 13 December 2015
+
+### Fixes
+
+ * Improve HTML escaping, by [@phillipj].
+ * Fix inconsistency in defining global mustache object, by [@simast].
+ * Fix switch-case indent error, by [@norfish].
+ * Unpin chai and eslint versions, by [@dasilvacontin].
+ * Update README.md with proper grammar, by [@EvanLovely].
+ * Update mjackson username in README, by [@mjackson].
+ * Remove syntax highlighting in README code sample, by [@imagentleman].
+ * Fix typo in README, by [@Xcrucifier].
+ * Fix link typo in README, by [@keirog].
+
+## [2.2.0] / 15 October 2015
+
+### Added
+
+ * Add Partials support to CLI, by [@palkan].
+
+### Changed
+
+ * Move install instructions to README's top, by [@mateusortiz]
+ * Improved devhook install output, by [@ShashankaNataraj].
+ * Clarifies and improves language in documentation, by [@jfmercer].
+ * Linting CLI tool, by [@phillipj].
+ * npm 2.x and node v4 on Travis, by [@phillipj].
+
+### Fixes
+
+ * Fix README spelling error to "aforementioned", by [@djchie].
+ * Equal error message test in .render() for server and browser, by [@phillipj].
+
+### Dependencies
+
+ * chai -> 3.3.0
+ * eslint -> 1.6.0
+
+## [2.1.3] / 23 July 2015
+
+### Added
+
+ * Throw error when providing .render() with invalid template type, by [@phillipj].
+ * Documents use of string literals containing double quotes, by [@jfmercer].
+
+### Changed
+
+ * Move mustache gif to githubusercontent, by [@Andersos].
+
+### Fixed
+
+ * Update UMD Shim to be resilient to HTMLElement global pollution, by [@mikesherov].
+
+## [2.1.2] / 17 June 2015
+
+### Added
+
+ * Mustache global definition ([#466]) by [@yousefcisco].
+
+## [2.1.1] / 11 June 2015
+
+### Added
+
+ * State that we use semver on the change log, by [@dasilvacontin].
+ * Added version links to change log, by [@dasilvacontin].
+
+### Fixed
+
+ * Bugfix for using values from view's context prototype, by [@phillipj].
+ * Improve test with undefined/null lookup hit using dot notation, by [@dasilvacontin].
+ * Bugfix for null/undefined lookup hit when using dot notation, by [@phillipj].
+ * Remove moot `version` property from bower.json, by [@kkirsche].
+ * bower.json doesn't require a version bump via hook, by [@dasilvacontin].
+
+
+## [2.1.0] / 5 June 2015
+
+ * Added license attribute to package.json, by [@pgilad].
+ * Minor changes to make mustache.js compatible with both WSH and ASP, by [@nagaozen].
+ * Improve CLI view parsing error, by [@phillipj].
+ * Bugfix for view context cache, by [@phillipj].
+
+## [2.0.0] / 27 Mar 2015
+
+ * Fixed lookup not stopping upon finding `undefined` or `null` values, by [@dasilvacontin].
+ * Refactored pre-commit hook, by [@dasilvacontin].
+
+## [1.2.0] / 24 Mar 2015
+
+ * Added -v option to CLI, by [@phillipj].
+ * Bugfix for rendering Number when it serves as the Context, by [@phillipj].
+ * Specified files in package.json for a cleaner install, by [@phillipj].
+
+## [1.1.0] / 18 Feb 2015
+
+ * Refactor Writer.renderTokens() for better readability, by [@phillipj].
+ * Cleanup tests section in readme, by [@phillipj].
+ * Added JSHint to tests/CI, by [@phillipj].
+ * Added node v0.12 on travis, by [@phillipj].
+ * Created command line tool, by [@phillipj].
+ * Added *falsy* to Inverted Sections description in README, by [@kristijanmatic].
+
+## [1.0.0] / 20 Dec 2014
+
+ * Inline tag compilation, by [@mjackson].
+ * Fixed AMD registration, volo package.json entry, by [@jrburke].
+ * Added spm support, by [@afc163].
+ * Only access properties of objects on Context.lookup, by [@cmbuckley].
+
+## [0.8.2] / 17 Mar 2014
+
+ * Supporting Bower through a bower.json file.
+
+## [0.8.1] / 3 Jan 2014
+
+ * Fix usage of partial templates.
+
+## [0.8.0] / 2 Dec 2013
+
+ * Remove compile* writer functions, use mustache.parse instead. Smaller API.
+ * Throw an error when rendering a template that contains higher-order sections and
+ the original template is not provided.
+ * Remove low-level Context.make function.
+ * Better code readability and inline documentation.
+ * Stop caching templates by name.
+
+## [0.7.3] / 5 Nov 2013
+
+ * Don't require the original template to be passed to the rendering function
+ when using compiled templates. This is still required when using higher-order
+ functions in order to be able to extract the portion of the template
+ that was contained by that section. Fixes [#262].
+ * Performance improvements.
+
+## [0.7.2] / 27 Dec 2012
+
+ * Fixed a rendering bug ([#274]) when using nested higher-order sections.
+ * Better error reporting on failed parse.
+ * Converted tests to use mocha instead of vows.
+
+## [0.7.1] / 6 Dec 2012
+
+ * Handle empty templates gracefully. Fixes [#265], [#267], and [#270].
+ * Cache partials by template, not by name. Fixes [#257].
+ * Added Mustache.compileTokens to compile the output of Mustache.parse. Fixes
+ [#258].
+
+## [0.7.0] / 10 Sep 2012
+
+ * Rename Renderer => Writer.
+ * Allow partials to be loaded dynamically using a callback (thanks
+ [@TiddoLangerak] for the suggestion).
+ * Fixed a bug with higher-order sections that prevented them from being
+ passed the raw text of the section from the original template.
+ * More concise token format. Tokens also include start/end indices in the
+ original template.
+ * High-level API is consistent with the Writer API.
+ * Allow partials to be passed to the pre-compiled function (thanks
+ [@fallenice]).
+ * Don't use eval (thanks [@cweider]).
+
+## [0.6.0] / 31 Aug 2012
+
+ * Use JavaScript's definition of falsy when determining whether to render an
+ inverted section or not. Issue [#186].
+ * Use Mustache.escape to escape values inside {{}}. This function may be
+ reassigned to alter the default escaping behavior. Issue [#244].
+ * Fixed a bug that clashed with QUnit (thanks [@kannix]).
+ * Added volo support (thanks [@guybedford]).
+
+[3.0.1]: https://github.com/janl/mustache.js/compare/v3.0.0...v3.0.1
+[3.0.0]: https://github.com/janl/mustache.js/compare/v2.3.2...v3.0.0
+[2.3.2]: https://github.com/janl/mustache.js/compare/v2.3.1...v2.3.2
+[2.3.1]: https://github.com/janl/mustache.js/compare/v2.3.0...v2.3.1
+[2.3.0]: https://github.com/janl/mustache.js/compare/v2.2.1...v2.3.0
+[2.2.1]: https://github.com/janl/mustache.js/compare/v2.2.0...v2.2.1
+[2.2.0]: https://github.com/janl/mustache.js/compare/v2.1.3...v2.2.0
+[2.1.3]: https://github.com/janl/mustache.js/compare/v2.1.2...v2.1.3
+[2.1.2]: https://github.com/janl/mustache.js/compare/v2.1.1...v2.1.2
+[2.1.1]: https://github.com/janl/mustache.js/compare/v2.1.0...v2.1.1
+[2.1.0]: https://github.com/janl/mustache.js/compare/v2.0.0...v2.1.0
+[2.0.0]: https://github.com/janl/mustache.js/compare/v1.2.0...v2.0.0
+[1.2.0]: https://github.com/janl/mustache.js/compare/v1.1.0...v1.2.0
+[1.1.0]: https://github.com/janl/mustache.js/compare/v1.0.0...v1.1.0
+[1.0.0]: https://github.com/janl/mustache.js/compare/0.8.2...v1.0.0
+[0.8.2]: https://github.com/janl/mustache.js/compare/0.8.1...0.8.2
+[0.8.1]: https://github.com/janl/mustache.js/compare/0.8.0...0.8.1
+[0.8.0]: https://github.com/janl/mustache.js/compare/0.7.3...0.8.0
+[0.7.3]: https://github.com/janl/mustache.js/compare/0.7.2...0.7.3
+[0.7.2]: https://github.com/janl/mustache.js/compare/0.7.1...0.7.2
+[0.7.1]: https://github.com/janl/mustache.js/compare/0.7.0...0.7.1
+[0.7.0]: https://github.com/janl/mustache.js/compare/0.6.0...0.7.0
+[0.6.0]: https://github.com/janl/mustache.js/compare/0.5.2...0.6.0
+
+[#186]: https://github.com/janl/mustache.js/issues/186
+[#244]: https://github.com/janl/mustache.js/issues/244
+[#257]: https://github.com/janl/mustache.js/issues/257
+[#258]: https://github.com/janl/mustache.js/issues/258
+[#262]: https://github.com/janl/mustache.js/issues/262
+[#265]: https://github.com/janl/mustache.js/issues/265
+[#267]: https://github.com/janl/mustache.js/issues/267
+[#270]: https://github.com/janl/mustache.js/issues/270
+[#274]: https://github.com/janl/mustache.js/issues/274
+[#466]: https://github.com/janl/mustache.js/issues/466
+[#540]: https://github.com/janl/mustache.js/issues/540
+[#542]: https://github.com/janl/mustache.js/issues/542
+[#546]: https://github.com/janl/mustache.js/issues/546
+[#548]: https://github.com/janl/mustache.js/issues/548
+[#553]: https://github.com/janl/mustache.js/issues/553
+[#560]: https://github.com/janl/mustache.js/issues/560
+[#569]: https://github.com/janl/mustache.js/issues/569
+[#580]: https://github.com/janl/mustache.js/issues/580
+[#592]: https://github.com/janl/mustache.js/issues/592
+[#593]: https://github.com/janl/mustache.js/issues/593
+[#597]: https://github.com/janl/mustache.js/issues/597
+[#610]: https://github.com/janl/mustache.js/issues/610
+[#643]: https://github.com/janl/mustache.js/issues/643
+[#644]: https://github.com/janl/mustache.js/issues/644
+[#657]: https://github.com/janl/mustache.js/issues/657
+[#664]: https://github.com/janl/mustache.js/issues/664
+[#666]: https://github.com/janl/mustache.js/issues/666
+[#667]: https://github.com/janl/mustache.js/issues/667
+[#668]: https://github.com/janl/mustache.js/issues/668
+[#670]: https://github.com/janl/mustache.js/issues/670
+[#618]: https://github.com/janl/mustache.js/issues/618
+[#673]: https://github.com/janl/mustache.js/issues/673
+[#679]: https://github.com/janl/mustache.js/issues/679
+
+[@afc163]: https://github.com/afc163
+[@Andersos]: https://github.com/Andersos
+[@bbrooks]: https://github.com/bbrooks
+[@calvinf]: https://github.com/calvinf
+[@cmbuckley]: https://github.com/cmbuckley
+[@cweider]: https://github.com/cweider
+[@dasilvacontin]: https://github.com/dasilvacontin
+[@djchie]: https://github.com/djchie
+[@EvanLovely]: https://github.com/EvanLovely
+[@fallenice]: https://github.com/fallenice
+[@Flaque]: https://github.com/Flaque
+[@guybedford]: https://github.com/guybedford
+[@imagentleman]: https://github.com/imagentleman
+[@jfmercer]: https://github.com/jfmercer
+[@jrburke]: https://github.com/jrburke
+[@kannix]: https://github.com/kannix
+[@keirog]: https://github.com/keirog
+[@kkirsche]: https://github.com/kkirsche
+[@kookookchoozeus]: https://github.com/kookookchoozeus
+[@kristijanmatic]: https://github.com/kristijanmatic
+[@mateusortiz]: https://github.com/mateusortiz
+[@mightyplow]: https://github.com/mightyplow
+[@mikesherov]: https://github.com/mikesherov
+[@mjackson]: https://github.com/mjackson
+[@mortonfox]: https://github.com/mortonfox
+[@nagaozen]: https://github.com/nagaozen
+[@norfish]: https://github.com/norfish
+[@palkan]: https://github.com/palkan
+[@paultopia]: https://github.com/paultopia
+[@pgilad]: https://github.com/pgilad
+[@phillipj]: https://github.com/phillipj
+[@pra85]: https://github.com/pra85
+[@raymond-lam]: https://github.com/raymond-lam
+[@seminaoki]: https://github.com/seminaoki
+[@ShashankaNataraj]: https://github.com/ShashankaNataraj
+[@simast]: https://github.com/simast
+[@stackchain]: https://github.com/stackchain
+[@TiddoLangerak]: https://github.com/TiddoLangerak
+[@tomekwi]: https://github.com/tomekwi
+[@wizawu]: https://github.com/wizawu
+[@Xcrucifier]: https://github.com/Xcrucifier
+[@yousefcisco]: https://github.com/yousefcisco
diff --git a/node_modules/mustache/LICENSE b/node_modules/mustache/LICENSE
new file mode 100644
index 00000000..4df7d1aa
--- /dev/null
+++ b/node_modules/mustache/LICENSE
@@ -0,0 +1,11 @@
+The MIT License
+
+Copyright (c) 2009 Chris Wanstrath (Ruby)
+Copyright (c) 2010-2014 Jan Lehnardt (JavaScript)
+Copyright (c) 2010-2015 The mustache.js community
+
+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.
diff --git a/node_modules/mustache/README.md b/node_modules/mustache/README.md
new file mode 100644
index 00000000..34b33920
--- /dev/null
+++ b/node_modules/mustache/README.md
@@ -0,0 +1,645 @@
+# mustache.js - Logic-less {{mustache}} templates with JavaScript
+
+> What could be more logical awesome than no logic at all?
+
+[![Build Status](https://travis-ci.org/janl/mustache.js.svg?branch=master)](https://travis-ci.org/janl/mustache.js) [![Gitter chat](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/janl/mustache.js)
+
+[mustache.js](http://github.com/janl/mustache.js) is an implementation of the [mustache](http://mustache.github.com/) template system in JavaScript.
+
+[Mustache](http://mustache.github.com/) is a logic-less template syntax. It can be used for HTML, config files, source code - anything. It works by expanding tags in a template using values provided in a hash or object.
+
+We call it "logic-less" because there are no if statements, else clauses, or for loops. Instead there are only tags. Some tags are replaced with a value, some nothing, and others a series of values.
+
+For a language-agnostic overview of mustache's template syntax, see the `mustache(5)` [manpage](http://mustache.github.com/mustache.5.html).
+
+## Where to use mustache.js?
+
+You can use mustache.js to render mustache templates anywhere you can use JavaScript. This includes web browsers, server-side environments such as [node](http://nodejs.org/), and [CouchDB](http://couchdb.apache.org/) views.
+
+mustache.js ships with support for both the [CommonJS](http://www.commonjs.org/) module API and the [Asynchronous Module Definition](https://github.com/amdjs/amdjs-api/wiki/AMD) API, or AMD.
+
+And this will be your templates after you use Mustache:
+
+!['stache](https://cloud.githubusercontent.com/assets/288977/8779228/a3cf700e-2f02-11e5-869a-300312fb7a00.gif)
+
+## Install
+
+You can get Mustache via npm.
+
+```bash
+$ npm install mustache --save
+```
+or install with bower:
+
+```bash
+$ bower install --save mustache
+```
+
+## Command line tool
+
+mustache.js is shipped with a node based command line tool. It might be installed as a global tool on your computer to render a mustache template of some kind
+
+```bash
+$ npm install -g mustache
+
+$ mustache dataView.json myTemplate.mustache > output.html
+```
+
+also supports stdin.
+
+```bash
+$ cat dataView.json | mustache - myTemplate.mustache > output.html
+```
+
+or as a package.json `devDependency` in a build process maybe?
+
+```bash
+$ npm install mustache --save-dev
+```
+
+```json
+{
+ "scripts": {
+ "build": "mustache dataView.json myTemplate.mustache > public/output.html"
+ }
+}
+```
+```bash
+$ npm run build
+```
+
+The command line tool is basically a wrapper around `Mustache.render` so you get all the features.
+
+If your templates use partials you should pass paths to partials using `-p` flag:
+
+```bash
+$ mustache -p path/to/partial1.mustache -p path/to/partial2.mustache dataView.json myTemplate.mustache
+```
+
+## Who uses mustache.js?
+
+An updated list of mustache.js users is kept [on the Github wiki](http://wiki.github.com/janl/mustache.js/beard-competition). Add yourself or your company if you use mustache.js!
+
+## Contributing
+
+mustache.js is a mature project, but it continues to actively invite maintainers. You can help out a high-profile project that is used in a lot of places on the web. There is [plenty](https://github.com/janl/mustache.js/issues) of [work](https://github.com/janl/mustache.js/pulls) to do. No big commitment required, if all you do is review a single [Pull Request](https://github.com/janl/mustache.js/pulls), you are a maintainer. And a hero.
+
+### Your First Contribution
+
+- review a [Pull Request](https://github.com/janl/mustache.js/pulls)
+- fix an [Issue](https://github.com/janl/mustache.js/issues)
+- update the [documentation](https://github.com/janl/mustache.js#usage)
+- make a website
+- write a tutorial
+
+* * *
+
+## Usage
+
+Below is a quick example how to use mustache.js:
+
+```js
+var view = {
+ title: "Joe",
+ calc: function () {
+ return 2 + 4;
+ }
+};
+
+var output = Mustache.render("{{title}} spends {{calc}}", view);
+```
+
+In this example, the `Mustache.render` function takes two parameters: 1) the [mustache](http://mustache.github.com/) template and 2) a `view` object that contains the data and code needed to render the template.
+
+## API
+
+Following is an [rtype](https://git.io/rtype) signature of the most commonly used functions.
+
+```js
+Mustache.render(
+ template : String,
+ view : Object,
+ partials? : Object,
+ tags = ['{{', '}}'] : Tags,
+) => String
+
+Mustache.parse(
+ template : String,
+ tags = ['{{', '}}'] : Tags,
+) => Token[]
+
+interface Token [String, String, Number, Number, Token[]?, Number?]
+
+interface Tags [String, String]
+
+```
+
+## Templates
+
+A [mustache](http://mustache.github.com/) template is a string that contains any number of mustache tags. Tags are indicated by the double mustaches that surround them. `{{person}}` is a tag, as is `{{#person}}`. In both examples we refer to `person` as the tag's key. There are several types of tags available in mustache.js, described below.
+
+There are several techniques that can be used to load templates and hand them to mustache.js, here are two of them:
+
+#### Include Templates
+
+If you need a template for a dynamic part in a static website, you can consider including the template in the static HTML file to avoid loading templates separately. Here's a small example using `jQuery`:
+
+```html
+
+
+
+
Loading...
+
+
+
+```
+
+```js
+function loadUser() {
+ var template = $('#template').html();
+ Mustache.parse(template); // optional, speeds up future uses
+ var rendered = Mustache.render(template, {name: "Luke"});
+ $('#target').html(rendered);
+}
+```
+
+#### Load External Templates
+
+If your templates reside in individual files, you can load them asynchronously and render them when they arrive. Another example using `jQuery`:
+
+```js
+function loadUser() {
+ $.get('template.mst', function(template) {
+ var rendered = Mustache.render(template, {name: "Luke"});
+ $('#target').html(rendered);
+ });
+}
+```
+
+### Variables
+
+The most basic tag type is a simple variable. A `{{name}}` tag renders the value of the `name` key in the current context. If there is no such key, nothing is rendered.
+
+All variables are HTML-escaped by default. If you want to render unescaped HTML, use the triple mustache: `{{{name}}}`. You can also use `&` to unescape a variable.
+
+If you'd like to change HTML-escaping behavior globally (for example, to template non-HTML formats), you can override Mustache's escape function. For example, to disable all escaping: `Mustache.escape = function(text) {return text;};`.
+
+If you want `{{name}}` _not_ to be interpreted as a mustache tag, but rather to appear exactly as `{{name}}` in the output, you must change and then restore the default delimiter. See the [Custom Delimiters](#custom-delimiters) section for more information.
+
+View:
+
+```json
+{
+ "name": "Chris",
+ "company": "GitHub"
+}
+```
+
+Template:
+
+```
+* {{name}}
+* {{age}}
+* {{company}}
+* {{{company}}}
+* {{&company}}
+{{=<% %>=}}
+* {{company}}
+<%={{ }}=%>
+```
+
+Output:
+
+```html
+* Chris
+*
+* <b>GitHub</b>
+* GitHub
+* GitHub
+* {{company}}
+```
+
+JavaScript's dot notation may be used to access keys that are properties of objects in a view.
+
+View:
+
+```json
+{
+ "name": {
+ "first": "Michael",
+ "last": "Jackson"
+ },
+ "age": "RIP"
+}
+```
+
+Template:
+
+```html
+* {{name.first}} {{name.last}}
+* {{age}}
+```
+
+Output:
+
+```html
+* Michael Jackson
+* RIP
+```
+
+### Sections
+
+Sections render blocks of text one or more times, depending on the value of the key in the current context.
+
+A section begins with a pound and ends with a slash. That is, `{{#person}}` begins a `person` section, while `{{/person}}` ends it. The text between the two tags is referred to as that section's "block".
+
+The behavior of the section is determined by the value of the key.
+
+#### False Values or Empty Lists
+
+If the `person` key does not exist, or exists and has a value of `null`, `undefined`, `false`, `0`, or `NaN`, or is an empty string or an empty list, the block will not be rendered.
+
+View:
+
+```json
+{
+ "person": false
+}
+```
+
+Template:
+
+```html
+Shown.
+{{#person}}
+Never shown!
+{{/person}}
+```
+
+Output:
+
+```html
+Shown.
+```
+
+#### Non-Empty Lists
+
+If the `person` key exists and is not `null`, `undefined`, or `false`, and is not an empty list the block will be rendered one or more times.
+
+When the value is a list, the block is rendered once for each item in the list. The context of the block is set to the current item in the list for each iteration. In this way we can loop over collections.
+
+View:
+
+```json
+{
+ "stooges": [
+ { "name": "Moe" },
+ { "name": "Larry" },
+ { "name": "Curly" }
+ ]
+}
+```
+
+Template:
+
+```html
+{{#stooges}}
+{{name}}
+{{/stooges}}
+```
+
+Output:
+
+```html
+Moe
+Larry
+Curly
+```
+
+When looping over an array of strings, a `.` can be used to refer to the current item in the list.
+
+View:
+
+```json
+{
+ "musketeers": ["Athos", "Aramis", "Porthos", "D'Artagnan"]
+}
+```
+
+Template:
+
+```html
+{{#musketeers}}
+* {{.}}
+{{/musketeers}}
+```
+
+Output:
+
+```html
+* Athos
+* Aramis
+* Porthos
+* D'Artagnan
+```
+
+If the value of a section variable is a function, it will be called in the context of the current item in the list on each iteration.
+
+View:
+
+```js
+{
+ "beatles": [
+ { "firstName": "John", "lastName": "Lennon" },
+ { "firstName": "Paul", "lastName": "McCartney" },
+ { "firstName": "George", "lastName": "Harrison" },
+ { "firstName": "Ringo", "lastName": "Starr" }
+ ],
+ "name": function () {
+ return this.firstName + " " + this.lastName;
+ }
+}
+```
+
+Template:
+
+```html
+{{#beatles}}
+* {{name}}
+{{/beatles}}
+```
+
+Output:
+
+```html
+* John Lennon
+* Paul McCartney
+* George Harrison
+* Ringo Starr
+```
+
+#### Functions
+
+If the value of a section key is a function, it is called with the section's literal block of text, un-rendered, as its first argument. The second argument is a special rendering function that uses the current view as its view argument. It is called in the context of the current view object.
+
+View:
+
+```js
+{
+ "name": "Tater",
+ "bold": function () {
+ return function (text, render) {
+ return "" + render(text) + "";
+ }
+ }
+}
+```
+
+Template:
+
+```html
+{{#bold}}Hi {{name}}.{{/bold}}
+```
+
+Output:
+
+```html
+Hi Tater.
+```
+
+### Inverted Sections
+
+An inverted section opens with `{{^section}}` instead of `{{#section}}`. The block of an inverted section is rendered only if the value of that section's tag is `null`, `undefined`, `false`, *falsy* or an empty list.
+
+View:
+
+```json
+{
+ "repos": []
+}
+```
+
+Template:
+
+```html
+{{#repos}}{{name}}{{/repos}}
+{{^repos}}No repos :({{/repos}}
+```
+
+Output:
+
+```html
+No repos :(
+```
+
+### Comments
+
+Comments begin with a bang and are ignored. The following template:
+
+```html
+
Today{{! ignore me }}.
+```
+
+Will render as follows:
+
+```html
+
Today.
+```
+
+Comments may contain newlines.
+
+### Partials
+
+Partials begin with a greater than sign, like {{> box}}.
+
+Partials are rendered at runtime (as opposed to compile time), so recursive partials are possible. Just avoid infinite loops.
+
+They also inherit the calling context. Whereas in ERB you may have this:
+
+```html+erb
+<%= partial :next_more, :start => start, :size => size %>
+```
+
+Mustache requires only this:
+
+```html
+{{> next_more}}
+```
+
+Why? Because the `next_more.mustache` file will inherit the `size` and `start` variables from the calling context. In this way you may want to think of partials as includes, imports, template expansion, nested templates, or subtemplates, even though those aren't literally the case here.
+
+
+For example, this template and partial:
+
+ base.mustache:
+
Names
+ {{#names}}
+ {{> user}}
+ {{/names}}
+
+ user.mustache:
+ {{name}}
+
+Can be thought of as a single, expanded template:
+
+```html
+
Names
+{{#names}}
+ {{name}}
+{{/names}}
+```
+
+In mustache.js an object of partials may be passed as the third argument to `Mustache.render`. The object should be keyed by the name of the partial, and its value should be the partial text.
+
+```js
+Mustache.render(template, view, {
+ user: userTemplate
+});
+```
+
+### Custom Delimiters
+
+Custom delimiters can be used in place of `{{` and `}}` by setting the new values in JavaScript or in templates.
+
+#### Setting in JavaScript
+
+The `Mustache.tags` property holds an array consisting of the opening and closing tag values. Set custom values by passing a new array of tags to `render()`, which gets honored over the default values, or by overriding the `Mustache.tags` property itself:
+
+```js
+var customTags = [ '<%', '%>' ];
+```
+
+##### Pass Value into Render Method
+```js
+Mustache.render(template, view, {}, customTags);
+```
+
+##### Override Tags Property
+```js
+Mustache.tags = customTags;
+// Subsequent parse() and render() calls will use customTags
+```
+
+#### Setting in Templates
+
+Set Delimiter tags start with an equals sign and change the tag delimiters from `{{` and `}}` to custom strings.
+
+Consider the following contrived example:
+
+```html+erb
+* {{ default_tags }}
+{{=<% %>=}}
+* <% erb_style_tags %>
+<%={{ }}=%>
+* {{ default_tags_again }}
+```
+
+Here we have a list with three items. The first item uses the default tag style, the second uses ERB style as defined by the Set Delimiter tag, and the third returns to the default style after yet another Set Delimiter declaration.
+
+According to [ctemplates](https://htmlpreview.github.io/?https://raw.githubusercontent.com/OlafvdSpek/ctemplate/master/doc/howto.html), this "is useful for languages like TeX, where double-braces may occur in the text and are awkward to use for markup."
+
+Custom delimiters may not contain whitespace or the equals sign.
+
+## Pre-parsing and Caching Templates
+
+By default, when mustache.js first parses a template it keeps the full parsed token tree in a cache. The next time it sees that same template it skips the parsing step and renders the template much more quickly. If you'd like, you can do this ahead of time using `mustache.parse`.
+
+```js
+Mustache.parse(template);
+
+// Then, sometime later.
+Mustache.render(template, view);
+```
+
+## Plugins for JavaScript Libraries
+
+mustache.js may be built specifically for several different client libraries, including the following:
+
+ - [jQuery](http://jquery.com/)
+ - [MooTools](http://mootools.net/)
+ - [Dojo](http://www.dojotoolkit.org/)
+ - [YUI](http://developer.yahoo.com/yui/)
+ - [qooxdoo](http://qooxdoo.org/)
+
+These may be built using [Rake](http://rake.rubyforge.org/) and one of the following commands:
+```bash
+$ rake jquery
+$ rake mootools
+$ rake dojo
+$ rake yui3
+$ rake qooxdoo
+```
+## Testing
+
+In order to run the tests you'll need to install [node](http://nodejs.org/).
+
+You also need to install the sub module containing [Mustache specifications](http://github.com/mustache/spec) in the project root.
+```bash
+$ git submodule init
+$ git submodule update
+```
+Install dependencies.
+```bash
+$ npm install
+```
+Then run the tests.
+```bash
+$ npm test
+```
+The test suite consists of both unit and integration tests. If a template isn't rendering correctly for you, you can make a test for it by doing the following:
+
+ 1. Create a template file named `mytest.mustache` in the `test/_files`
+ directory. Replace `mytest` with the name of your test.
+ 2. Create a corresponding view file named `mytest.js` in the same directory.
+ This file should contain a JavaScript object literal enclosed in
+ parentheses. See any of the other view files for an example.
+ 3. Create a file with the expected output in `mytest.txt` in the same
+ directory.
+
+Then, you can run the test with:
+```bash
+$ TEST=mytest npm run test-render
+```
+### Browser tests
+
+Browser tests are not included in `npm test` as they run for too long, although they are ran automatically on Travis when merged into master. Run browser tests locally in any browser:
+```bash
+$ npm run test-browser-local
+```
+then point your browser to `http://localhost:8080/__zuul`
+
+### Troubleshooting
+
+#### npm install fails
+
+Ensure to have a recent version of npm installed. While developing this project requires npm with support for `^` version ranges.
+```bash
+$ npm install -g npm
+```
+## Thanks
+
+mustache.js wouldn't kick ass if it weren't for these fine souls:
+
+ * Chris Wanstrath / defunkt
+ * Alexander Lang / langalex
+ * Sebastian Cohnen / tisba
+ * J Chris Anderson / jchris
+ * Tom Robinson / tlrobinson
+ * Aaron Quint / quirkey
+ * Douglas Crockford
+ * Nikita Vasilyev / NV
+ * Elise Wood / glytch
+ * Damien Mathieu / dmathieu
+ * Jakub Kuźma / qoobaa
+ * Will Leinweber / will
+ * dpree
+ * Jason Smith / jhs
+ * Aaron Gibralter / agibralter
+ * Ross Boucher / boucher
+ * Matt Sanford / mzsanford
+ * Ben Cherry / bcherry
+ * Michael Jackson / mjackson
+ * Phillip Johnsen / phillipj
+ * David da Silva Contín / dasilvacontin
diff --git a/node_modules/mustache/bin/mustache b/node_modules/mustache/bin/mustache
new file mode 100755
index 00000000..430e8b93
--- /dev/null
+++ b/node_modules/mustache/bin/mustache
@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+
+var fs = require('fs'),
+ path = require('path');
+
+var Mustache = require('..');
+var pkg = require('../package');
+var partials = {};
+
+var partialsPaths = [];
+var partialArgIndex = -1;
+
+while ((partialArgIndex = process.argv.indexOf('-p')) > -1) {
+ partialsPaths.push(process.argv.splice(partialArgIndex, 2)[1]);
+}
+
+var viewArg = process.argv[2];
+var templateArg = process.argv[3];
+var outputArg = process.argv[4];
+
+if (hasVersionArg()) {
+ return console.log(pkg.version);
+}
+
+if (!templateArg || !viewArg) {
+ console.error('Syntax: mustache [output]');
+ process.exit(1);
+}
+
+run(readPartials, readView, readTemplate, render, toStdout);
+
+/**
+ * Runs a list of functions as a waterfall.
+ * Functions are runned one after the other in order, providing each
+ * function the returned values of all the previously invoked functions.
+ * Each function is expected to exit the process if an error occurs.
+ */
+function run (/*args*/) {
+ var values = [];
+ var fns = Array.prototype.slice.call(arguments);
+
+ function invokeNextFn (val) {
+ values.unshift(val);
+ if (fns.length === 0) return;
+ invoke(fns.shift());
+ }
+
+ function invoke (fn) {
+ fn.apply(null, [invokeNextFn].concat(values));
+ }
+
+ invoke(fns.shift());
+}
+
+function readView (cb) {
+ var view = isStdin(viewArg) ? process.openStdin() : fs.createReadStream(viewArg);
+
+ streamToStr(view, function onDone (str) {
+ cb(parseView(str));
+ });
+}
+
+function parseView (str) {
+ try {
+ return JSON.parse(str);
+ } catch (ex) {
+ console.error(
+ 'Shooot, could not parse view as JSON.\n' +
+ 'Tips: functions are not valid JSON and keys / values must be surround with double quotes.\n\n' +
+ ex.stack);
+
+ process.exit(1);
+ }
+}
+
+function readPartials (cb) {
+ if (!partialsPaths.length) return cb();
+ var partialPath = partialsPaths.pop();
+ var partial = fs.createReadStream(partialPath);
+ streamToStr(partial, function onDone (str) {
+ partials[getPartialName(partialPath)] = str;
+ readPartials(cb);
+ });
+}
+
+function readTemplate (cb) {
+ var template = fs.createReadStream(templateArg);
+ streamToStr(template, cb);
+}
+
+function render (cb, templateStr, jsonView) {
+ cb(Mustache.render(templateStr, jsonView, partials));
+}
+
+function toStdout (cb, str) {
+ if (outputArg) {
+ cb(fs.writeFileSync(outputArg, str));
+ } else {
+ cb(process.stdout.write(str));
+ }
+}
+
+function streamToStr (stream, cb) {
+ var data = '';
+
+ stream.on('data', function onData (chunk) {
+ data += chunk;
+ }).once('end', function onEnd () {
+ cb(data.toString());
+ }).on('error', function onError (err) {
+ if (wasNotFound(err)) {
+ console.error('Could not find file:', err.path);
+ } else {
+ console.error('Error while reading file:', err.message);
+ }
+ process.exit(1);
+ });
+}
+
+function isStdin (view) {
+ return view === '-';
+}
+
+function wasNotFound (err) {
+ return err.code && err.code === 'ENOENT';
+}
+
+function hasVersionArg () {
+ return ['--version', '-v'].some(function matchInArgs (opt) {
+ return process.argv.indexOf(opt) > -1;
+ });
+}
+
+function getPartialName (filename) {
+ return path.basename(filename, '.mustache');
+}
diff --git a/node_modules/mustache/mustache.js b/node_modules/mustache/mustache.js
new file mode 100644
index 00000000..8ec1b44c
--- /dev/null
+++ b/node_modules/mustache/mustache.js
@@ -0,0 +1,682 @@
+/*!
+ * mustache.js - Logic-less {{mustache}} templates with JavaScript
+ * http://github.com/janl/mustache.js
+ */
+
+/*global define: false Mustache: true*/
+
+(function defineMustache (global, factory) {
+ if (typeof exports === 'object' && exports && typeof exports.nodeName !== 'string') {
+ factory(exports); // CommonJS
+ } else if (typeof define === 'function' && define.amd) {
+ define(['exports'], factory); // AMD
+ } else {
+ global.Mustache = {};
+ factory(global.Mustache); // script, wsh, asp
+ }
+}(this, function mustacheFactory (mustache) {
+
+ var objectToString = Object.prototype.toString;
+ var isArray = Array.isArray || function isArrayPolyfill (object) {
+ return objectToString.call(object) === '[object Array]';
+ };
+
+ function isFunction (object) {
+ return typeof object === 'function';
+ }
+
+ /**
+ * More correct typeof string handling array
+ * which normally returns typeof 'object'
+ */
+ function typeStr (obj) {
+ return isArray(obj) ? 'array' : typeof obj;
+ }
+
+ function escapeRegExp (string) {
+ return string.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, '\\$&');
+ }
+
+ /**
+ * Null safe way of checking whether or not an object,
+ * including its prototype, has a given property
+ */
+ function hasProperty (obj, propName) {
+ return obj != null && typeof obj === 'object' && (propName in obj);
+ }
+
+ /**
+ * Safe way of detecting whether or not the given thing is a primitive and
+ * whether it has the given property
+ */
+ function primitiveHasOwnProperty (primitive, propName) {
+ return (
+ primitive != null
+ && typeof primitive !== 'object'
+ && primitive.hasOwnProperty
+ && primitive.hasOwnProperty(propName)
+ );
+ }
+
+ // Workaround for https://issues.apache.org/jira/browse/COUCHDB-577
+ // See https://github.com/janl/mustache.js/issues/189
+ var regExpTest = RegExp.prototype.test;
+ function testRegExp (re, string) {
+ return regExpTest.call(re, string);
+ }
+
+ var nonSpaceRe = /\S/;
+ function isWhitespace (string) {
+ return !testRegExp(nonSpaceRe, string);
+ }
+
+ var entityMap = {
+ '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ "'": ''',
+ '/': '/',
+ '`': '`',
+ '=': '='
+ };
+
+ function escapeHtml (string) {
+ return String(string).replace(/[&<>"'`=\/]/g, function fromEntityMap (s) {
+ return entityMap[s];
+ });
+ }
+
+ var whiteRe = /\s*/;
+ var spaceRe = /\s+/;
+ var equalsRe = /\s*=/;
+ var curlyRe = /\s*\}/;
+ var tagRe = /#|\^|\/|>|\{|&|=|!/;
+
+ /**
+ * Breaks up the given `template` string into a tree of tokens. If the `tags`
+ * argument is given here it must be an array with two string values: the
+ * opening and closing tags used in the template (e.g. [ "<%", "%>" ]). Of
+ * course, the default is to use mustaches (i.e. mustache.tags).
+ *
+ * A token is an array with at least 4 elements. The first element is the
+ * mustache symbol that was used inside the tag, e.g. "#" or "&". If the tag
+ * did not contain a symbol (i.e. {{myValue}}) this element is "name". For
+ * all text that appears outside a symbol this element is "text".
+ *
+ * The second element of a token is its "value". For mustache tags this is
+ * whatever else was inside the tag besides the opening symbol. For text tokens
+ * this is the text itself.
+ *
+ * The third and fourth elements of the token are the start and end indices,
+ * respectively, of the token in the original template.
+ *
+ * Tokens that are the root node of a subtree contain two more elements: 1) an
+ * array of tokens in the subtree and 2) the index in the original template at
+ * which the closing tag for that section begins.
+ */
+ function parseTemplate (template, tags) {
+ if (!template)
+ return [];
+
+ var sections = []; // Stack to hold section tokens
+ var tokens = []; // Buffer to hold the tokens
+ var spaces = []; // Indices of whitespace tokens on the current line
+ var hasTag = false; // Is there a {{tag}} on the current line?
+ var nonSpace = false; // Is there a non-space char on the current line?
+
+ // Strips all whitespace tokens array for the current line
+ // if there was a {{#tag}} on it and otherwise only space.
+ function stripSpace () {
+ if (hasTag && !nonSpace) {
+ while (spaces.length)
+ delete tokens[spaces.pop()];
+ } else {
+ spaces = [];
+ }
+
+ hasTag = false;
+ nonSpace = false;
+ }
+
+ var openingTagRe, closingTagRe, closingCurlyRe;
+ function compileTags (tagsToCompile) {
+ if (typeof tagsToCompile === 'string')
+ tagsToCompile = tagsToCompile.split(spaceRe, 2);
+
+ if (!isArray(tagsToCompile) || tagsToCompile.length !== 2)
+ throw new Error('Invalid tags: ' + tagsToCompile);
+
+ openingTagRe = new RegExp(escapeRegExp(tagsToCompile[0]) + '\\s*');
+ closingTagRe = new RegExp('\\s*' + escapeRegExp(tagsToCompile[1]));
+ closingCurlyRe = new RegExp('\\s*' + escapeRegExp('}' + tagsToCompile[1]));
+ }
+
+ compileTags(tags || mustache.tags);
+
+ var scanner = new Scanner(template);
+
+ var start, type, value, chr, token, openSection;
+ while (!scanner.eos()) {
+ start = scanner.pos;
+
+ // Match any text between tags.
+ value = scanner.scanUntil(openingTagRe);
+
+ if (value) {
+ for (var i = 0, valueLength = value.length; i < valueLength; ++i) {
+ chr = value.charAt(i);
+
+ if (isWhitespace(chr)) {
+ spaces.push(tokens.length);
+ } else {
+ nonSpace = true;
+ }
+
+ tokens.push([ 'text', chr, start, start + 1 ]);
+ start += 1;
+
+ // Check for whitespace on the current line.
+ if (chr === '\n')
+ stripSpace();
+ }
+ }
+
+ // Match the opening tag.
+ if (!scanner.scan(openingTagRe))
+ break;
+
+ hasTag = true;
+
+ // Get the tag type.
+ type = scanner.scan(tagRe) || 'name';
+ scanner.scan(whiteRe);
+
+ // Get the tag value.
+ if (type === '=') {
+ value = scanner.scanUntil(equalsRe);
+ scanner.scan(equalsRe);
+ scanner.scanUntil(closingTagRe);
+ } else if (type === '{') {
+ value = scanner.scanUntil(closingCurlyRe);
+ scanner.scan(curlyRe);
+ scanner.scanUntil(closingTagRe);
+ type = '&';
+ } else {
+ value = scanner.scanUntil(closingTagRe);
+ }
+
+ // Match the closing tag.
+ if (!scanner.scan(closingTagRe))
+ throw new Error('Unclosed tag at ' + scanner.pos);
+
+ token = [ type, value, start, scanner.pos ];
+ tokens.push(token);
+
+ if (type === '#' || type === '^') {
+ sections.push(token);
+ } else if (type === '/') {
+ // Check section nesting.
+ openSection = sections.pop();
+
+ if (!openSection)
+ throw new Error('Unopened section "' + value + '" at ' + start);
+
+ if (openSection[1] !== value)
+ throw new Error('Unclosed section "' + openSection[1] + '" at ' + start);
+ } else if (type === 'name' || type === '{' || type === '&') {
+ nonSpace = true;
+ } else if (type === '=') {
+ // Set the tags for the next time around.
+ compileTags(value);
+ }
+ }
+
+ // Make sure there are no open sections when we're done.
+ openSection = sections.pop();
+
+ if (openSection)
+ throw new Error('Unclosed section "' + openSection[1] + '" at ' + scanner.pos);
+
+ return nestTokens(squashTokens(tokens));
+ }
+
+ /**
+ * Combines the values of consecutive text tokens in the given `tokens` array
+ * to a single token.
+ */
+ function squashTokens (tokens) {
+ var squashedTokens = [];
+
+ var token, lastToken;
+ for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
+ token = tokens[i];
+
+ if (token) {
+ if (token[0] === 'text' && lastToken && lastToken[0] === 'text') {
+ lastToken[1] += token[1];
+ lastToken[3] = token[3];
+ } else {
+ squashedTokens.push(token);
+ lastToken = token;
+ }
+ }
+ }
+
+ return squashedTokens;
+ }
+
+ /**
+ * Forms the given array of `tokens` into a nested tree structure where
+ * tokens that represent a section have two additional items: 1) an array of
+ * all tokens that appear in that section and 2) the index in the original
+ * template that represents the end of that section.
+ */
+ function nestTokens (tokens) {
+ var nestedTokens = [];
+ var collector = nestedTokens;
+ var sections = [];
+
+ var token, section;
+ for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
+ token = tokens[i];
+
+ switch (token[0]) {
+ case '#':
+ case '^':
+ collector.push(token);
+ sections.push(token);
+ collector = token[4] = [];
+ break;
+ case '/':
+ section = sections.pop();
+ section[5] = token[2];
+ collector = sections.length > 0 ? sections[sections.length - 1][4] : nestedTokens;
+ break;
+ default:
+ collector.push(token);
+ }
+ }
+
+ return nestedTokens;
+ }
+
+ /**
+ * A simple string scanner that is used by the template parser to find
+ * tokens in template strings.
+ */
+ function Scanner (string) {
+ this.string = string;
+ this.tail = string;
+ this.pos = 0;
+ }
+
+ /**
+ * Returns `true` if the tail is empty (end of string).
+ */
+ Scanner.prototype.eos = function eos () {
+ return this.tail === '';
+ };
+
+ /**
+ * Tries to match the given regular expression at the current position.
+ * Returns the matched text if it can match, the empty string otherwise.
+ */
+ Scanner.prototype.scan = function scan (re) {
+ var match = this.tail.match(re);
+
+ if (!match || match.index !== 0)
+ return '';
+
+ var string = match[0];
+
+ this.tail = this.tail.substring(string.length);
+ this.pos += string.length;
+
+ return string;
+ };
+
+ /**
+ * Skips all text until the given regular expression can be matched. Returns
+ * the skipped string, which is the entire tail if no match can be made.
+ */
+ Scanner.prototype.scanUntil = function scanUntil (re) {
+ var index = this.tail.search(re), match;
+
+ switch (index) {
+ case -1:
+ match = this.tail;
+ this.tail = '';
+ break;
+ case 0:
+ match = '';
+ break;
+ default:
+ match = this.tail.substring(0, index);
+ this.tail = this.tail.substring(index);
+ }
+
+ this.pos += match.length;
+
+ return match;
+ };
+
+ /**
+ * Represents a rendering context by wrapping a view object and
+ * maintaining a reference to the parent context.
+ */
+ function Context (view, parentContext) {
+ this.view = view;
+ this.cache = { '.': this.view };
+ this.parent = parentContext;
+ }
+
+ /**
+ * Creates a new context using the given view with this context
+ * as the parent.
+ */
+ Context.prototype.push = function push (view) {
+ return new Context(view, this);
+ };
+
+ /**
+ * Returns the value of the given name in this context, traversing
+ * up the context hierarchy if the value is absent in this context's view.
+ */
+ Context.prototype.lookup = function lookup (name) {
+ var cache = this.cache;
+
+ var value;
+ if (cache.hasOwnProperty(name)) {
+ value = cache[name];
+ } else {
+ var context = this, intermediateValue, names, index, lookupHit = false;
+
+ while (context) {
+ if (name.indexOf('.') > 0) {
+ intermediateValue = context.view;
+ names = name.split('.');
+ index = 0;
+
+ /**
+ * Using the dot notion path in `name`, we descend through the
+ * nested objects.
+ *
+ * To be certain that the lookup has been successful, we have to
+ * check if the last object in the path actually has the property
+ * we are looking for. We store the result in `lookupHit`.
+ *
+ * This is specially necessary for when the value has been set to
+ * `undefined` and we want to avoid looking up parent contexts.
+ *
+ * In the case where dot notation is used, we consider the lookup
+ * to be successful even if the last "object" in the path is
+ * not actually an object but a primitive (e.g., a string, or an
+ * integer), because it is sometimes useful to access a property
+ * of an autoboxed primitive, such as the length of a string.
+ **/
+ while (intermediateValue != null && index < names.length) {
+ if (index === names.length - 1)
+ lookupHit = (
+ hasProperty(intermediateValue, names[index])
+ || primitiveHasOwnProperty(intermediateValue, names[index])
+ );
+
+ intermediateValue = intermediateValue[names[index++]];
+ }
+ } else {
+ intermediateValue = context.view[name];
+
+ /**
+ * Only checking against `hasProperty`, which always returns `false` if
+ * `context.view` is not an object. Deliberately omitting the check
+ * against `primitiveHasOwnProperty` if dot notation is not used.
+ *
+ * Consider this example:
+ * ```
+ * Mustache.render("The length of a football field is {{#length}}{{length}}{{/length}}.", {length: "100 yards"})
+ * ```
+ *
+ * If we were to check also against `primitiveHasOwnProperty`, as we do
+ * in the dot notation case, then render call would return:
+ *
+ * "The length of a football field is 9."
+ *
+ * rather than the expected:
+ *
+ * "The length of a football field is 100 yards."
+ **/
+ lookupHit = hasProperty(context.view, name);
+ }
+
+ if (lookupHit) {
+ value = intermediateValue;
+ break;
+ }
+
+ context = context.parent;
+ }
+
+ cache[name] = value;
+ }
+
+ if (isFunction(value))
+ value = value.call(this.view);
+
+ return value;
+ };
+
+ /**
+ * A Writer knows how to take a stream of tokens and render them to a
+ * string, given a context. It also maintains a cache of templates to
+ * avoid the need to parse the same template twice.
+ */
+ function Writer () {
+ this.cache = {};
+ }
+
+ /**
+ * Clears all cached templates in this writer.
+ */
+ Writer.prototype.clearCache = function clearCache () {
+ this.cache = {};
+ };
+
+ /**
+ * Parses and caches the given `template` according to the given `tags` or
+ * `mustache.tags` if `tags` is omitted, and returns the array of tokens
+ * that is generated from the parse.
+ */
+ Writer.prototype.parse = function parse (template, tags) {
+ var cache = this.cache;
+ var cacheKey = template + ':' + (tags || mustache.tags).join(':');
+ var tokens = cache[cacheKey];
+
+ if (tokens == null)
+ tokens = cache[cacheKey] = parseTemplate(template, tags);
+
+ return tokens;
+ };
+
+ /**
+ * High-level method that is used to render the given `template` with
+ * the given `view`.
+ *
+ * The optional `partials` argument may be an object that contains the
+ * names and templates of partials that are used in the template. It may
+ * also be a function that is used to load partial templates on the fly
+ * that takes a single argument: the name of the partial.
+ *
+ * If the optional `tags` argument is given here it must be an array with two
+ * string values: the opening and closing tags used in the template (e.g.
+ * [ "<%", "%>" ]). The default is to mustache.tags.
+ */
+ Writer.prototype.render = function render (template, view, partials, tags) {
+ var tokens = this.parse(template, tags);
+ var context = (view instanceof Context) ? view : new Context(view);
+ return this.renderTokens(tokens, context, partials, template, tags);
+ };
+
+ /**
+ * Low-level method that renders the given array of `tokens` using
+ * the given `context` and `partials`.
+ *
+ * Note: The `originalTemplate` is only ever used to extract the portion
+ * of the original template that was contained in a higher-order section.
+ * If the template doesn't use higher-order sections, this argument may
+ * be omitted.
+ */
+ Writer.prototype.renderTokens = function renderTokens (tokens, context, partials, originalTemplate, tags) {
+ var buffer = '';
+
+ var token, symbol, value;
+ for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
+ value = undefined;
+ token = tokens[i];
+ symbol = token[0];
+
+ if (symbol === '#') value = this.renderSection(token, context, partials, originalTemplate);
+ else if (symbol === '^') value = this.renderInverted(token, context, partials, originalTemplate);
+ else if (symbol === '>') value = this.renderPartial(token, context, partials, tags);
+ else if (symbol === '&') value = this.unescapedValue(token, context);
+ else if (symbol === 'name') value = this.escapedValue(token, context);
+ else if (symbol === 'text') value = this.rawValue(token);
+
+ if (value !== undefined)
+ buffer += value;
+ }
+
+ return buffer;
+ };
+
+ Writer.prototype.renderSection = function renderSection (token, context, partials, originalTemplate) {
+ var self = this;
+ var buffer = '';
+ var value = context.lookup(token[1]);
+
+ // This function is used to render an arbitrary template
+ // in the current context by higher-order sections.
+ function subRender (template) {
+ return self.render(template, context, partials);
+ }
+
+ if (!value) return;
+
+ if (isArray(value)) {
+ for (var j = 0, valueLength = value.length; j < valueLength; ++j) {
+ buffer += this.renderTokens(token[4], context.push(value[j]), partials, originalTemplate);
+ }
+ } else if (typeof value === 'object' || typeof value === 'string' || typeof value === 'number') {
+ buffer += this.renderTokens(token[4], context.push(value), partials, originalTemplate);
+ } else if (isFunction(value)) {
+ if (typeof originalTemplate !== 'string')
+ throw new Error('Cannot use higher-order sections without the original template');
+
+ // Extract the portion of the original template that the section contains.
+ value = value.call(context.view, originalTemplate.slice(token[3], token[5]), subRender);
+
+ if (value != null)
+ buffer += value;
+ } else {
+ buffer += this.renderTokens(token[4], context, partials, originalTemplate);
+ }
+ return buffer;
+ };
+
+ Writer.prototype.renderInverted = function renderInverted (token, context, partials, originalTemplate) {
+ var value = context.lookup(token[1]);
+
+ // Use JavaScript's definition of falsy. Include empty arrays.
+ // See https://github.com/janl/mustache.js/issues/186
+ if (!value || (isArray(value) && value.length === 0))
+ return this.renderTokens(token[4], context, partials, originalTemplate);
+ };
+
+ Writer.prototype.renderPartial = function renderPartial (token, context, partials, tags) {
+ if (!partials) return;
+
+ var value = isFunction(partials) ? partials(token[1]) : partials[token[1]];
+ if (value != null)
+ return this.renderTokens(this.parse(value, tags), context, partials, value);
+ };
+
+ Writer.prototype.unescapedValue = function unescapedValue (token, context) {
+ var value = context.lookup(token[1]);
+ if (value != null)
+ return value;
+ };
+
+ Writer.prototype.escapedValue = function escapedValue (token, context) {
+ var value = context.lookup(token[1]);
+ if (value != null)
+ return mustache.escape(value);
+ };
+
+ Writer.prototype.rawValue = function rawValue (token) {
+ return token[1];
+ };
+
+ mustache.name = 'mustache.js';
+ mustache.version = '3.0.1';
+ mustache.tags = [ '{{', '}}' ];
+
+ // All high-level mustache.* functions use this writer.
+ var defaultWriter = new Writer();
+
+ /**
+ * Clears all cached templates in the default writer.
+ */
+ mustache.clearCache = function clearCache () {
+ return defaultWriter.clearCache();
+ };
+
+ /**
+ * Parses and caches the given template in the default writer and returns the
+ * array of tokens it contains. Doing this ahead of time avoids the need to
+ * parse templates on the fly as they are rendered.
+ */
+ mustache.parse = function parse (template, tags) {
+ return defaultWriter.parse(template, tags);
+ };
+
+ /**
+ * Renders the `template` with the given `view` and `partials` using the
+ * default writer. If the optional `tags` argument is given here it must be an
+ * array with two string values: the opening and closing tags used in the
+ * template (e.g. [ "<%", "%>" ]). The default is to mustache.tags.
+ */
+ mustache.render = function render (template, view, partials, tags) {
+ if (typeof template !== 'string') {
+ throw new TypeError('Invalid template! Template should be a "string" ' +
+ 'but "' + typeStr(template) + '" was given as the first ' +
+ 'argument for mustache#render(template, view, partials)');
+ }
+
+ return defaultWriter.render(template, view, partials, tags);
+ };
+
+ // This is here for backwards compatibility with 0.4.x.,
+ /*eslint-disable */ // eslint wants camel cased function name
+ mustache.to_html = function to_html (template, view, partials, send) {
+ /*eslint-enable*/
+
+ var result = mustache.render(template, view, partials);
+
+ if (isFunction(send)) {
+ send(result);
+ } else {
+ return result;
+ }
+ };
+
+ // Export the escaping function so that the user may override it.
+ // See https://github.com/janl/mustache.js/issues/244
+ mustache.escape = escapeHtml;
+
+ // Export these mainly for testing, but also for advanced usage.
+ mustache.Scanner = Scanner;
+ mustache.Context = Context;
+ mustache.Writer = Writer;
+
+ return mustache;
+}));
diff --git a/node_modules/mustache/mustache.min.js b/node_modules/mustache/mustache.min.js
new file mode 100644
index 00000000..7ad4c009
--- /dev/null
+++ b/node_modules/mustache/mustache.min.js
@@ -0,0 +1 @@
+(function defineMustache(global,factory){if(typeof exports==="object"&&exports&&typeof exports.nodeName!=="string"){factory(exports)}else if(typeof define==="function"&&define.amd){define(["exports"],factory)}else{global.Mustache={};factory(global.Mustache)}})(this,function mustacheFactory(mustache){var objectToString=Object.prototype.toString;var isArray=Array.isArray||function isArrayPolyfill(object){return objectToString.call(object)==="[object Array]"};function isFunction(object){return typeof object==="function"}function typeStr(obj){return isArray(obj)?"array":typeof obj}function escapeRegExp(string){return string.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g,"\\$&")}function hasProperty(obj,propName){return obj!=null&&typeof obj==="object"&&propName in obj}function primitiveHasOwnProperty(primitive,propName){return primitive!=null&&typeof primitive!=="object"&&primitive.hasOwnProperty&&primitive.hasOwnProperty(propName)}var regExpTest=RegExp.prototype.test;function testRegExp(re,string){return regExpTest.call(re,string)}var nonSpaceRe=/\S/;function isWhitespace(string){return!testRegExp(nonSpaceRe,string)}var entityMap={"&":"&","<":"<",">":">",'"':""","'":"'","/":"/","`":"`","=":"="};function escapeHtml(string){return String(string).replace(/[&<>"'`=\/]/g,function fromEntityMap(s){return entityMap[s]})}var whiteRe=/\s*/;var spaceRe=/\s+/;var equalsRe=/\s*=/;var curlyRe=/\s*\}/;var tagRe=/#|\^|\/|>|\{|&|=|!/;function parseTemplate(template,tags){if(!template)return[];var sections=[];var tokens=[];var spaces=[];var hasTag=false;var nonSpace=false;function stripSpace(){if(hasTag&&!nonSpace){while(spaces.length)delete tokens[spaces.pop()]}else{spaces=[]}hasTag=false;nonSpace=false}var openingTagRe,closingTagRe,closingCurlyRe;function compileTags(tagsToCompile){if(typeof tagsToCompile==="string")tagsToCompile=tagsToCompile.split(spaceRe,2);if(!isArray(tagsToCompile)||tagsToCompile.length!==2)throw new Error("Invalid tags: "+tagsToCompile);openingTagRe=new RegExp(escapeRegExp(tagsToCompile[0])+"\\s*");closingTagRe=new RegExp("\\s*"+escapeRegExp(tagsToCompile[1]));closingCurlyRe=new RegExp("\\s*"+escapeRegExp("}"+tagsToCompile[1]))}compileTags(tags||mustache.tags);var scanner=new Scanner(template);var start,type,value,chr,token,openSection;while(!scanner.eos()){start=scanner.pos;value=scanner.scanUntil(openingTagRe);if(value){for(var i=0,valueLength=value.length;i0?sections[sections.length-1][4]:nestedTokens;break;default:collector.push(token)}}return nestedTokens}function Scanner(string){this.string=string;this.tail=string;this.pos=0}Scanner.prototype.eos=function eos(){return this.tail===""};Scanner.prototype.scan=function scan(re){var match=this.tail.match(re);if(!match||match.index!==0)return"";var string=match[0];this.tail=this.tail.substring(string.length);this.pos+=string.length;return string};Scanner.prototype.scanUntil=function scanUntil(re){var index=this.tail.search(re),match;switch(index){case-1:match=this.tail;this.tail="";break;case 0:match="";break;default:match=this.tail.substring(0,index);this.tail=this.tail.substring(index)}this.pos+=match.length;return match};function Context(view,parentContext){this.view=view;this.cache={".":this.view};this.parent=parentContext}Context.prototype.push=function push(view){return new Context(view,this)};Context.prototype.lookup=function lookup(name){var cache=this.cache;var value;if(cache.hasOwnProperty(name)){value=cache[name]}else{var context=this,intermediateValue,names,index,lookupHit=false;while(context){if(name.indexOf(".")>0){intermediateValue=context.view;names=name.split(".");index=0;while(intermediateValue!=null&&index")value=this.renderPartial(token,context,partials,tags);else if(symbol==="&")value=this.unescapedValue(token,context);else if(symbol==="name")value=this.escapedValue(token,context);else if(symbol==="text")value=this.rawValue(token);if(value!==undefined)buffer+=value}return buffer};Writer.prototype.renderSection=function renderSection(token,context,partials,originalTemplate){var self=this;var buffer="";var value=context.lookup(token[1]);function subRender(template){return self.render(template,context,partials)}if(!value)return;if(isArray(value)){for(var j=0,valueLength=value.length;j",
+ "homepage": "https://github.com/janl/mustache.js",
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/janl/mustache.js.git"
+ },
+ "keywords": [
+ "mustache",
+ "template",
+ "templates",
+ "ejs"
+ ],
+ "main": "./mustache.js",
+ "bin": {
+ "mustache": "./bin/mustache"
+ },
+ "files": [
+ "mustache.js",
+ "mustache.min.js",
+ "bin",
+ "wrappers",
+ "LICENSE"
+ ],
+ "volo": {
+ "url": "https://raw.github.com/janl/mustache.js/{version}/mustache.js"
+ },
+ "engines": {
+ "npm": ">=1.4.0"
+ },
+ "scripts": {
+ "pretest": "eslint mustache.js bin/mustache",
+ "test": "mocha --reporter spec test/*-test.js",
+ "test-render": "mocha --reporter spec test/render-test",
+ "pre-test-browser": "node test/create-browser-suite.js",
+ "test-browser": "npm run pre-test-browser && zuul -- test/context-test.js test/parse-test.js test/scanner-test.js test/render-test-browser.js",
+ "test-browser-local": "npm run pre-test-browser && zuul --local 8080 -- test/context-test.js test/scanner-test.js test/parse-test.js test/render-test-browser.js"
+ },
+ "devDependencies": {
+ "chai": "^3.4.0",
+ "eslint": "2.5.1",
+ "jshint": "^2.9.5",
+ "mocha": "^3.0.2",
+ "uglify-js": "^3.4.6",
+ "zuul": "^3.11.0",
+ "zuul-ngrok": "nolanlawson/zuul-ngrok#patch-1"
+ },
+ "spm": {
+ "main": "mustache.js",
+ "ignore": [
+ "test",
+ "wrappers"
+ ]
+ },
+ "greenkeeper": {
+ "ignore": [
+ "eslint"
+ ]
+ },
+ "license": "MIT"
+}
diff --git a/node_modules/mustache/wrappers/dojo/mustache.js.post b/node_modules/mustache/wrappers/dojo/mustache.js.post
new file mode 100644
index 00000000..eeeb4b7f
--- /dev/null
+++ b/node_modules/mustache/wrappers/dojo/mustache.js.post
@@ -0,0 +1,4 @@
+
+ dojox.mustache = dojo.hitch(Mustache, "render");
+
+})();
\ No newline at end of file
diff --git a/node_modules/mustache/wrappers/dojo/mustache.js.pre b/node_modules/mustache/wrappers/dojo/mustache.js.pre
new file mode 100644
index 00000000..f87f3cd7
--- /dev/null
+++ b/node_modules/mustache/wrappers/dojo/mustache.js.pre
@@ -0,0 +1,9 @@
+/*
+Shameless port of a shameless port
+@defunkt => @janl => @aq => @voodootikigod
+
+See http://github.com/defunkt/mustache for more info.
+*/
+
+dojo.provide("dojox.mustache._base");
+(function(){
diff --git a/node_modules/mustache/wrappers/jquery/mustache.js.post b/node_modules/mustache/wrappers/jquery/mustache.js.post
new file mode 100644
index 00000000..3209e915
--- /dev/null
+++ b/node_modules/mustache/wrappers/jquery/mustache.js.post
@@ -0,0 +1,13 @@
+ $.mustache = function (template, view, partials) {
+ return Mustache.render(template, view, partials);
+ };
+
+ $.fn.mustache = function (view, partials) {
+ return $(this).map(function (i, elm) {
+ var template = $.trim($(elm).html());
+ var output = $.mustache(template, view, partials);
+ return $(output).get();
+ });
+ };
+
+})(jQuery);
diff --git a/node_modules/mustache/wrappers/jquery/mustache.js.pre b/node_modules/mustache/wrappers/jquery/mustache.js.pre
new file mode 100644
index 00000000..b4d8af5e
--- /dev/null
+++ b/node_modules/mustache/wrappers/jquery/mustache.js.pre
@@ -0,0 +1,9 @@
+/*
+Shameless port of a shameless port
+@defunkt => @janl => @aq
+
+See http://github.com/defunkt/mustache for more info.
+*/
+
+;(function($) {
+
diff --git a/node_modules/mustache/wrappers/mootools/mustache.js.post b/node_modules/mustache/wrappers/mootools/mustache.js.post
new file mode 100644
index 00000000..aa9b8fab
--- /dev/null
+++ b/node_modules/mustache/wrappers/mootools/mustache.js.post
@@ -0,0 +1,5 @@
+
+ Object.implement('mustache', function(view, partials){
+ return Mustache.render(view, this, partials);
+ });
+})();
diff --git a/node_modules/mustache/wrappers/mootools/mustache.js.pre b/node_modules/mustache/wrappers/mootools/mustache.js.pre
new file mode 100644
index 00000000..9839f993
--- /dev/null
+++ b/node_modules/mustache/wrappers/mootools/mustache.js.pre
@@ -0,0 +1,2 @@
+(function(){
+
diff --git a/node_modules/mustache/wrappers/qooxdoo/mustache.js.post b/node_modules/mustache/wrappers/qooxdoo/mustache.js.post
new file mode 100644
index 00000000..6488b9c9
--- /dev/null
+++ b/node_modules/mustache/wrappers/qooxdoo/mustache.js.post
@@ -0,0 +1,9 @@
+/**
+ * Above is the original mustache code.
+ */
+
+// EXPOSE qooxdoo variant
+qx.bom.Template.version = this.Mustache.version;
+qx.bom.Template.render = this.Mustache.render;
+
+}).call({});
\ No newline at end of file
diff --git a/node_modules/mustache/wrappers/qooxdoo/mustache.js.pre b/node_modules/mustache/wrappers/qooxdoo/mustache.js.pre
new file mode 100644
index 00000000..1512a004
--- /dev/null
+++ b/node_modules/mustache/wrappers/qooxdoo/mustache.js.pre
@@ -0,0 +1,172 @@
+/* ************************************************************************
+
+ qooxdoo - the new era of web development
+
+ http://qooxdoo.org
+
+ Copyright:
+ 2004-2012 1&1 Internet AG, Germany, http://www.1und1.de
+
+ License:
+ LGPL: http://www.gnu.org/licenses/lgpl.html
+ EPL: http://www.eclipse.org/org/documents/epl-v10.php
+ See the LICENSE file in the project's top-level directory for details.
+
+ Authors:
+ * Martin Wittemann (martinwittemann)
+
+ ======================================================================
+
+ This class contains code based on the following work:
+
+ * Mustache.js version 0.8.0
+
+ Code:
+ https://github.com/janl/mustache.js
+
+ Copyright:
+ (c) 2009 Chris Wanstrath (Ruby)
+ (c) 2010 Jan Lehnardt (JavaScript)
+
+ License:
+ MIT: http://www.opensource.org/licenses/mit-license.php
+
+ ----------------------------------------------------------------------
+
+ Copyright (c) 2009 Chris Wanstrath (Ruby)
+ Copyright (c) 2010 Jan Lehnardt (JavaScript)
+
+ 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.
+
+************************************************************************ */
+
+/**
+ * The is a template class which can be used for HTML templating. In fact,
+ * this is a wrapper for mustache.js which is a "framework-agnostic way to
+ * render logic-free views".
+ *
+ * Here is a basic example how to use it:
+ * Template:
+ *
+ * var template = "Hi, my name is {{name}}!";
+ * var view = {name: "qooxdoo"};
+ * qx.bom.Template.render(template, view);
+ * // return "Hi, my name is qooxdoo!"
+ *
+ *
+ * For further details, please visit the mustache.js documentation here:
+ * https://github.com/janl/mustache.js/blob/master/README.md
+ *
+ * @ignore(module)
+ */
+qx.Bootstrap.define("qx.bom.Template", {
+ statics : {
+ /** Contains the mustache.js version. */
+ version: null,
+
+ /**
+ * Original and only template method of mustache.js. For further
+ * documentation, please visit https://github.com/janl/mustache.js
+ *
+ * @signature function(template, view, partials)
+ * @param template {String} The String containing the template.
+ * @param view {Object} The object holding the data to render.
+ * @param partials {Object} Object holding parts of a template.
+ * @return {String} The parsed template.
+ */
+ render: null,
+
+ /**
+ * Combines {@link #render} and {@link #get}. Input is equal to {@link #render}
+ * and output is equal to {@link #get}. The advantage over {@link #get}
+ * is that you don't need a HTML template but can use a template
+ * string and still get a DOM element. Keep in mind that templates
+ * can only have one root element.
+ *
+ * @param template {String} The String containing the template.
+ * @param view {Object} The object holding the data to render.
+ * @param partials {Object} Object holding parts of a template.
+ * @return {Element} A DOM element holding the parsed template data.
+ */
+ renderToNode : function(template, view, partials) {
+ var renderedTmpl = this.render(template, view, partials);
+ return this._createNodeFromTemplate(renderedTmpl);
+ },
+
+ /**
+ * Helper method which provides you with a direct access to templates
+ * stored as HTML in the DOM. The DOM node with the given ID will be used
+ * as a template, parsed and a new DOM node will be returned containing the
+ * parsed data. Keep in mind to have only one root DOM element in the the
+ * template.
+ * Additionally, you should not put the template into a regular, hidden
+ * DOM element because the template may not be valid HTML due to the containing
+ * mustache tags. We suggest to put it into a script tag with the type
+ * text/template.
+ *
+ * @param id {String} The id of the HTML template in the DOM.
+ * @param view {Object} The object holding the data to render.
+ * @param partials {Object} Object holding parts of a template.
+ * @return {Element} A DOM element holding the parsed template data.
+ */
+ get : function(id, view, partials) {
+ // get the content stored in the DOM
+ var template = document.getElementById(id);
+ return this.renderToNode(template.innerHTML, view, partials);
+ },
+
+ /**
+ * Accepts a parsed template and returns a (potentially nested) node.
+ *
+ * @param template {String} The String containing the template.
+ * @return {Element} A DOM element holding the parsed template data.
+ */
+ _createNodeFromTemplate : function(template) {
+ // template is text only (no html elems) so use text node
+ if (template.search(/<|>/) === -1) {
+ return document.createTextNode(template);
+ }
+
+ // template has html elems so convert string into DOM nodes
+ var helper = qx.dom.Element.create("div");
+ helper.innerHTML = template;
+
+ return helper.children[0];
+ }
+ }
+});
+
+(function() {
+// prevent using CommonJS exports object,
+// by shadowing global exports object
+var exports;
+
+// prevent using AMD compatible loader,
+// by shadowing global define function
+var define;
+
+/**
+ * Below is the original mustache.js code. Snapshot date is mentioned in
+ * the head of this file.
+ * @ignore(exports)
+ * @ignore(define.*)
+ * @ignore(module.*)
+ * @lint ignoreNoLoopBlock()
+ */
diff --git a/node_modules/mustache/wrappers/yui3/mustache.js.post b/node_modules/mustache/wrappers/yui3/mustache.js.post
new file mode 100644
index 00000000..3decbf83
--- /dev/null
+++ b/node_modules/mustache/wrappers/yui3/mustache.js.post
@@ -0,0 +1,4 @@
+
+ Y.mustache = Mustache.render;
+
+}, "0");
diff --git a/node_modules/mustache/wrappers/yui3/mustache.js.pre b/node_modules/mustache/wrappers/yui3/mustache.js.pre
new file mode 100644
index 00000000..280de869
--- /dev/null
+++ b/node_modules/mustache/wrappers/yui3/mustache.js.pre
@@ -0,0 +1 @@
+YUI.add("mustache", function(Y) {
diff --git a/node_modules/stack-trace/.npmignore b/node_modules/stack-trace/.npmignore
new file mode 100644
index 00000000..b59f7e3a
--- /dev/null
+++ b/node_modules/stack-trace/.npmignore
@@ -0,0 +1 @@
+test/
\ No newline at end of file
diff --git a/node_modules/stack-trace/License b/node_modules/stack-trace/License
new file mode 100644
index 00000000..11ec094e
--- /dev/null
+++ b/node_modules/stack-trace/License
@@ -0,0 +1,19 @@
+Copyright (c) 2011 Felix Geisendörfer (felix@debuggable.com)
+
+ 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.
diff --git a/node_modules/stack-trace/Makefile b/node_modules/stack-trace/Makefile
new file mode 100644
index 00000000..a7ce31d3
--- /dev/null
+++ b/node_modules/stack-trace/Makefile
@@ -0,0 +1,11 @@
+SHELL := /bin/bash
+
+test:
+ @./test/run.js
+
+release:
+ git push
+ git push --tags
+ npm publish .
+
+.PHONY: test
diff --git a/node_modules/stack-trace/Readme.md b/node_modules/stack-trace/Readme.md
new file mode 100644
index 00000000..fcd1b97c
--- /dev/null
+++ b/node_modules/stack-trace/Readme.md
@@ -0,0 +1,98 @@
+# stack-trace
+
+Get v8 stack traces as an array of CallSite objects.
+
+## Install
+
+``` bash
+npm install stack-trace
+```
+
+## Usage
+
+The stack-trace module makes it easy for you to capture the current stack:
+
+``` javascript
+var stackTrace = require('stack-trace');
+var trace = stackTrace.get();
+
+require('assert').strictEqual(trace[0].getFileName(), __filename);
+```
+
+However, sometimes you have already popped the stack you are interested in,
+and all you have left is an `Error` object. This module can help:
+
+``` javascript
+var stackTrace = require('stack-trace');
+var err = new Error('something went wrong');
+var trace = stackTrace.parse(err);
+
+require('assert').strictEqual(trace[0].getFileName(), __filename);
+```
+
+Please note that parsing the `Error#stack` property is not perfect, only
+certain properties can be retrieved with it as noted in the API docs below.
+
+## Long stack traces
+
+stack-trace works great with [long-stack-traces][], when parsing an `err.stack`
+that has crossed the event loop boundary, a `CallSite` object returning
+`'----------------------------------------'` for `getFileName()` is created.
+All other methods of the event loop boundary call site return `null`.
+
+[long-stack-traces]: https://github.com/tlrobinson/long-stack-traces
+
+## API
+
+### stackTrace.get([belowFn])
+
+Returns an array of `CallSite` objects, where element `0` is the current call
+site.
+
+When passing a function on the current stack as the `belowFn` parameter, the
+returned array will only include `CallSite` objects below this function.
+
+### stackTrace.parse(err)
+
+Parses the `err.stack` property of an `Error` object into an array compatible
+with those returned by `stackTrace.get()`. However, only the following methods
+are implemented on the returned `CallSite` objects.
+
+* getTypeName
+* getFunctionName
+* getMethodName
+* getFileName
+* getLineNumber
+* getColumnNumber
+* isNative
+
+Note: Except `getFunctionName()`, all of the above methods return exactly the
+same values as you would get from `stackTrace.get()`. `getFunctionName()`
+is sometimes a little different, but still useful.
+
+### CallSite
+
+The official v8 CallSite object API can be found [here][v8stackapi]. A quick
+excerpt:
+
+> A CallSite object defines the following methods:
+>
+> * **getThis**: returns the value of this
+> * **getTypeName**: returns the type of this as a string. This is the name of the function stored in the constructor field of this, if available, otherwise the object's [[Class]] internal property.
+> * **getFunction**: returns the current function
+> * **getFunctionName**: returns the name of the current function, typically its name property. If a name property is not available an attempt will be made to try to infer a name from the function's context.
+> * **getMethodName**: returns the name of the property of this or one of its prototypes that holds the current function
+> * **getFileName**: if this function was defined in a script returns the name of the script
+> * **getLineNumber**: if this function was defined in a script returns the current line number
+> * **getColumnNumber**: if this function was defined in a script returns the current column number
+> * **getEvalOrigin**: if this function was created using a call to eval returns a CallSite object representing the location where eval was called
+> * **isToplevel**: is this a toplevel invocation, that is, is this the global object?
+> * **isEval**: does this call take place in code defined by a call to eval?
+> * **isNative**: is this call in native V8 code?
+> * **isConstructor**: is this a constructor call?
+
+[v8stackapi]: http://code.google.com/p/v8/wiki/JavaScriptStackTraceApi
+
+## License
+
+stack-trace is licensed under the MIT license.
diff --git a/node_modules/stack-trace/lib/stack-trace.js b/node_modules/stack-trace/lib/stack-trace.js
new file mode 100644
index 00000000..cbadd58f
--- /dev/null
+++ b/node_modules/stack-trace/lib/stack-trace.js
@@ -0,0 +1,136 @@
+exports.get = function(belowFn) {
+ var oldLimit = Error.stackTraceLimit;
+ Error.stackTraceLimit = Infinity;
+
+ var dummyObject = {};
+
+ var v8Handler = Error.prepareStackTrace;
+ Error.prepareStackTrace = function(dummyObject, v8StackTrace) {
+ return v8StackTrace;
+ };
+ Error.captureStackTrace(dummyObject, belowFn || exports.get);
+
+ var v8StackTrace = dummyObject.stack;
+ Error.prepareStackTrace = v8Handler;
+ Error.stackTraceLimit = oldLimit;
+
+ return v8StackTrace;
+};
+
+exports.parse = function(err) {
+ if (!err.stack) {
+ return [];
+ }
+
+ var self = this;
+ var lines = err.stack.split('\n').slice(1);
+
+ return lines
+ .map(function(line) {
+ if (line.match(/^\s*[-]{4,}$/)) {
+ return self._createParsedCallSite({
+ fileName: line,
+ lineNumber: null,
+ functionName: null,
+ typeName: null,
+ methodName: null,
+ columnNumber: null,
+ 'native': null,
+ });
+ }
+
+ var lineMatch = line.match(/at (?:(.+)\s+\()?(?:(.+?):(\d+)(?::(\d+))?|([^)]+))\)?/);
+ if (!lineMatch) {
+ return;
+ }
+
+ var object = null;
+ var method = null;
+ var functionName = null;
+ var typeName = null;
+ var methodName = null;
+ var isNative = (lineMatch[5] === 'native');
+
+ if (lineMatch[1]) {
+ functionName = lineMatch[1];
+ var methodStart = functionName.lastIndexOf('.');
+ if (functionName[methodStart-1] == '.')
+ methodStart--;
+ if (methodStart > 0) {
+ object = functionName.substr(0, methodStart);
+ method = functionName.substr(methodStart + 1);
+ var objectEnd = object.indexOf('.Module');
+ if (objectEnd > 0) {
+ functionName = functionName.substr(objectEnd + 1);
+ object = object.substr(0, objectEnd);
+ }
+ }
+ typeName = null;
+ }
+
+ if (method) {
+ typeName = object;
+ methodName = method;
+ }
+
+ if (method === '') {
+ methodName = null;
+ functionName = null;
+ }
+
+ var properties = {
+ fileName: lineMatch[2] || null,
+ lineNumber: parseInt(lineMatch[3], 10) || null,
+ functionName: functionName,
+ typeName: typeName,
+ methodName: methodName,
+ columnNumber: parseInt(lineMatch[4], 10) || null,
+ 'native': isNative,
+ };
+
+ return self._createParsedCallSite(properties);
+ })
+ .filter(function(callSite) {
+ return !!callSite;
+ });
+};
+
+function CallSite(properties) {
+ for (var property in properties) {
+ this[property] = properties[property];
+ }
+}
+
+var strProperties = [
+ 'this',
+ 'typeName',
+ 'functionName',
+ 'methodName',
+ 'fileName',
+ 'lineNumber',
+ 'columnNumber',
+ 'function',
+ 'evalOrigin'
+];
+var boolProperties = [
+ 'topLevel',
+ 'eval',
+ 'native',
+ 'constructor'
+];
+strProperties.forEach(function (property) {
+ CallSite.prototype[property] = null;
+ CallSite.prototype['get' + property[0].toUpperCase() + property.substr(1)] = function () {
+ return this[property];
+ }
+});
+boolProperties.forEach(function (property) {
+ CallSite.prototype[property] = false;
+ CallSite.prototype['is' + property[0].toUpperCase() + property.substr(1)] = function () {
+ return this[property];
+ }
+});
+
+exports._createParsedCallSite = function(properties) {
+ return new CallSite(properties);
+};
diff --git a/node_modules/stack-trace/package.json b/node_modules/stack-trace/package.json
new file mode 100644
index 00000000..9cd0d074
--- /dev/null
+++ b/node_modules/stack-trace/package.json
@@ -0,0 +1,21 @@
+{
+ "author": "Felix Geisendörfer (http://debuggable.com/)",
+ "name": "stack-trace",
+ "description": "Get v8 stack traces as an array of CallSite objects.",
+ "version": "0.0.10",
+ "homepage": "https://github.com/felixge/node-stack-trace",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/felixge/node-stack-trace.git"
+ },
+ "main": "./lib/stack-trace",
+ "engines": {
+ "node": "*"
+ },
+ "license": "MIT",
+ "dependencies": {},
+ "devDependencies": {
+ "far": "0.0.3",
+ "long-stack-traces": "0.1.2"
+ }
+}
diff --git a/node_modules/youch/CHANGELOG.md b/node_modules/youch/CHANGELOG.md
new file mode 100644
index 00000000..0c53f023
--- /dev/null
+++ b/node_modules/youch/CHANGELOG.md
@@ -0,0 +1,106 @@
+
+## [2.0.10](https://github.com/poppinss/youch/compare/v2.0.9...v2.0.10) (2018-09-29)
+
+
+### Features
+
+* **links:** add support for font awesome icons and lazy load css files ([1bd258a](https://github.com/poppinss/youch/commit/1bd258a))
+
+
+
+
+## [2.0.9](https://github.com/poppinss/youch/compare/v2.0.8...v2.0.9) (2018-08-11)
+
+
+### Bug Fixes
+
+* **docs:** remove outdated link from Contributing ([#7](https://github.com/poppinss/youch/issues/7)) ([4edf88c](https://github.com/poppinss/youch/commit/4edf88c))
+* **frame:** do not crash when filepath does not exist ([#6](https://github.com/poppinss/youch/issues/6)) ([dac572d](https://github.com/poppinss/youch/commit/dac572d))
+
+
+### Features
+
+* **frame:** handle common Webpack setup ([#8](https://github.com/poppinss/youch/issues/8)) ([896474c](https://github.com/poppinss/youch/commit/896474c))
+
+
+
+
+## [2.0.8](https://github.com/poppinss/youch/compare/v2.0.7...v2.0.8) (2018-06-18)
+
+
+
+
+## [2.0.7](https://github.com/poppinss/youch/compare/v2.0.6...v2.0.7) (2018-01-10)
+
+
+### Features
+
+* **frame:** attach isModule and isNative props to frame ([46e8bbe](https://github.com/poppinss/youch/commit/46e8bbe))
+
+
+
+
+## [2.0.6](https://github.com/poppinss/youch/compare/v2.0.5...v2.0.6) (2018-01-09)
+
+
+
+
+## [2.0.5](https://github.com/poppinss/youch/compare/v2.0.4...v2.0.5) (2017-06-13)
+
+
+### Bug Fixes
+
+* **template:** improve css for smaller screens ([b07c77d](https://github.com/poppinss/youch/commit/b07c77d))
+
+
+
+
+## [2.0.4](https://github.com/poppinss/youch/compare/v2.0.3...v2.0.4) (2017-01-31)
+
+
+### Bug Fixes
+
+* **test:** use mocha instead of japa ([8bf7039](https://github.com/poppinss/youch/commit/8bf7039))
+
+
+
+
+## [2.0.3](https://github.com/poppinss/youch/compare/v2.0.2...v2.0.3) (2017-01-30)
+
+
+### Bug Fixes
+
+* **regex:** use plain regex over path.sep ([db3e2dc](https://github.com/poppinss/youch/commit/db3e2dc))
+
+
+
+
+## [2.0.2](https://github.com/poppinss/youch/compare/v2.0.0...v2.0.2) (2017-01-27)
+
+
+### Bug Fixes
+
+* **package:** fix path to main file ([5ad3b4a](https://github.com/poppinss/youch/commit/5ad3b4a))
+
+
+
+
+## [2.0.1](https://github.com/poppinss/youch/compare/v2.0.0...v2.0.1) (2017-01-26)
+
+
+### Bug Fixes
+
+* **package:** fix path to main file ([5ad3b4a](https://github.com/poppinss/youch/commit/5ad3b4a))
+
+
+
+
+# 2.0.0 (2017-01-26)
+
+
+### Features
+
+* initial implementation ([aba222a](https://github.com/poppinss/youch/commit/aba222a))
+
+
+
diff --git a/node_modules/youch/LICENSE.md b/node_modules/youch/LICENSE.md
new file mode 100644
index 00000000..cf422833
--- /dev/null
+++ b/node_modules/youch/LICENSE.md
@@ -0,0 +1,19 @@
+Copyright (c) 2018 virk.officials@gmail.com
+
+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.
diff --git a/node_modules/youch/README.md b/node_modules/youch/README.md
new file mode 100644
index 00000000..7759c2bd
--- /dev/null
+++ b/node_modules/youch/README.md
@@ -0,0 +1,119 @@
+# Youch!
+> Pretty error reporting for Node.js :rocket:
+
+
+
+