diff --git a/.github/workflows/rollingversions.yml b/.github/workflows/rollingversions.yml
new file mode 100644
index 000000000..fe688f79d
--- /dev/null
+++ b/.github/workflows/rollingversions.yml
@@ -0,0 +1,33 @@
+name: Release
+on:
+  repository_dispatch:
+    types: [rollingversions_publish_approved]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [10.x, 12.x, 14.x]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{ matrix.node-version }}
+      - run: yarn install --forzen-lockfile
+      - run: yarn prettier:check
+      - run: yarn test
+
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 12.x
+      - run: yarn install --forzen-lockfile
+      - run: echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > ~/.npmrc
+      - run: npx rollingversions publish
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 000000000..0dcf9c96a
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,27 @@
+name: Test
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [10.x, 12.x, 14.x]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{ matrix.node-version }}
+      - run: yarn install --forzen-lockfile
+      - run: yarn prettier:check
+      - run: yarn test
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 3c2bbf83d..000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,21 +0,0 @@
-language: node_js
-node_js:
-  - "6"
-  - "8"
-  - "10"
-  - "12"
-
-# Use faster Docker architecture on Travis.
-sudo: false
-
-script: yarn test
-# TODO: coverage
-# after_success: npm run coveralls
-
-notifications:
-  webhooks:
-    urls:
-      - https://webhooks.gitter.im/e/dd893be75c6b9908987d
-    on_success: change
-    on_failure: always
-    on_start:   never
diff --git a/.yarnrc b/.yarnrc
deleted file mode 100644
index 24efd034b..000000000
--- a/.yarnrc
+++ /dev/null
@@ -1 +0,0 @@
-workspaces-experimental true
\ No newline at end of file
diff --git a/lerna.json b/lerna.json
deleted file mode 100644
index 3059f1f32..000000000
--- a/lerna.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "lerna": "3.10.8",
-  "packages": ["packages/*"],
-  "npmClient": "yarn",
-  "useWorkspaces": true,
-  "version": "independent",
-  "registry": "https://registry.npmjs.org/"
-}
\ No newline at end of file
diff --git a/package.json b/package.json
index 6172c2cc0..1087ae2d9 100644
--- a/package.json
+++ b/package.json
@@ -1,10 +1,12 @@
 {
   "name": "pug-monorepo",
   "private": true,
+  "workspaces": [
+    "packages/*"
+  ],
   "devDependencies": {
     "coveralls": "3.0.9",
     "jest": "24.9.0",
-    "lerna": "3.20.2",
     "prettier": "1.19.1"
   },
   "repository": {
@@ -12,11 +14,9 @@
     "url": "https://github.com/pugjs/pug.git"
   },
   "scripts": {
+    "prettier:check": "prettier --ignore-path .gitignore --list-different './**/*.js'",
     "format": "prettier --ignore-path .gitignore --write './**/*.js'",
-    "bootstrap": "lerna bootstrap",
-    "clean": "lerna clean",
-    "release": "lerna publish",
-    "pretest": "lerna run pretest",
+    "pretest": "wsrun --stages --exclude-missing --fast-exit --collect-logs build",
     "test": "jest",
     "coverage": "jest --coverage",
     "coveralls": "jest --coverage --coverageReporters=text-lcov | coveralls",
@@ -30,13 +30,7 @@
     ]
   },
   "license": "MIT",
-  "workspaces": [
-    "packages/*"
-  ],
-  "resolutions": {
-    "jstransformer-markdown-it": "2.0.0",
-    "mkdirp": "0.5.1",
-    "shallow-clone": "2.0.0",
-    "stylus": "0.54.5"
+  "dependencies": {
+    "wsrun": "^5.2.0"
   }
 }
diff --git a/packages/pug-attrs/index.js b/packages/pug-attrs/index.js
index 50d732144..9850ac390 100644
--- a/packages/pug-attrs/index.js
+++ b/packages/pug-attrs/index.js
@@ -6,10 +6,10 @@ var runtime = require('pug-runtime');
 var stringify = require('js-stringify');
 
 function isConstant(src) {
-  return constantinople(src, {pug: runtime, 'pug_interp': undefined});
+  return constantinople(src, {pug: runtime, pug_interp: undefined});
 }
 function toConstant(src) {
-  return constantinople.toConstant(src, {pug: runtime, 'pug_interp': undefined});
+  return constantinople.toConstant(src, {pug: runtime, pug_interp: undefined});
 }
 
 module.exports = compileAttrs;
@@ -21,15 +21,23 @@ module.exports = compileAttrs;
  */
 function compileAttrs(attrs, options) {
   assert(Array.isArray(attrs), 'Attrs should be an array');
-  assert(attrs.every(function (attr) {
-    return attr &&
-      typeof attr === 'object' &&
-      typeof attr.name === 'string' &&
-      (typeof attr.val === 'string' || typeof attr.val === 'boolean') &&
-      typeof attr.mustEscape === 'boolean';
-  }), 'All attributes should be supplied as an object of the form {name, val, mustEscape}');
+  assert(
+    attrs.every(function(attr) {
+      return (
+        attr &&
+        typeof attr === 'object' &&
+        typeof attr.name === 'string' &&
+        (typeof attr.val === 'string' || typeof attr.val === 'boolean') &&
+        typeof attr.mustEscape === 'boolean'
+      );
+    }),
+    'All attributes should be supplied as an object of the form {name, val, mustEscape}'
+  );
   assert(options && typeof options === 'object', 'Options should be an object');
-  assert(typeof options.terse === 'boolean', 'Options.terse should be a boolean');
+  assert(
+    typeof options.terse === 'boolean',
+    'Options.terse should be a boolean'
+  );
   assert(
     typeof options.runtime === 'function',
     'Options.runtime should be a function that takes a runtime function name and returns the source code that will evaluate to that function at runtime'
@@ -46,7 +54,9 @@ function compileAttrs(attrs, options) {
   function addAttribute(key, val, mustEscape, buf) {
     if (isConstant(val)) {
       if (options.format === 'html') {
-        var str = stringify(runtime.attr(key, toConstant(val), mustEscape, options.terse));
+        var str = stringify(
+          runtime.attr(key, toConstant(val), mustEscape, options.terse)
+        );
         var last = buf[buf.length - 1];
         if (last && last[last.length - 1] === str[0]) {
           buf[buf.length - 1] = last.substr(0, last.length - 1) + str.substr(1);
@@ -62,7 +72,18 @@ function compileAttrs(attrs, options) {
       }
     } else {
       if (options.format === 'html') {
-        buf.push(options.runtime('attr') + '("' + key + '", ' + val + ', ' + stringify(mustEscape) + ', ' + stringify(options.terse) + ')');
+        buf.push(
+          options.runtime('attr') +
+            '("' +
+            key +
+            '", ' +
+            val +
+            ', ' +
+            stringify(mustEscape) +
+            ', ' +
+            stringify(options.terse) +
+            ')'
+        );
       } else {
         if (mustEscape) {
           val = options.runtime('escape') + '(' + val + ')';
@@ -72,7 +93,7 @@ function compileAttrs(attrs, options) {
     }
   }
 
-  attrs.forEach(function(attr){
+  attrs.forEach(function(attr) {
     var key = attr.name;
     var val = attr.val;
     var mustEscape = attr.mustEscape;
@@ -101,16 +122,23 @@ function compileAttrs(attrs, options) {
         classesBuf
       );
     } else {
-      classes = classes.map(function (cls, i) {
+      classes = classes.map(function(cls, i) {
         if (isConstant(cls)) {
-          cls = stringify(classEscaping[i] ? runtime.escape(toConstant(cls)) : toConstant(cls));
+          cls = stringify(
+            classEscaping[i] ? runtime.escape(toConstant(cls)) : toConstant(cls)
+          );
           classEscaping[i] = false;
         }
         return cls;
       });
       addAttribute(
         'class',
-        options.runtime('classes') + '([' + classes.join(',') + '], ' + stringify(classEscaping) + ')',
+        options.runtime('classes') +
+          '([' +
+          classes.join(',') +
+          '], ' +
+          stringify(classEscaping) +
+          ')',
         false,
         classesBuf
       );
diff --git a/packages/pug-attrs/test/index.test.js b/packages/pug-attrs/test/index.test.js
index 1fb0d56d1..7bb8854ae 100644
--- a/packages/pug-attrs/test/index.test.js
+++ b/packages/pug-attrs/test/index.test.js
@@ -9,88 +9,293 @@ function test(input, expected, locals) {
   var opts = options;
   locals = locals || {};
   locals.pug = locals.pug || require('pug-runtime');
-  it(utils.inspect(input).replace(/\n/g, '') + ' => ' + utils.inspect(expected), function () {
-    var src = attrs(input, opts);
-    var localKeys = Object.keys(locals).sort();
-    var output = Function(localKeys.join(', '), 'return (' + src + ');').apply(null, localKeys.map(function (key) { return locals[key]; }));
-    if (opts.format === 'html') {
-      expect(output).toBe(expected);
-    } else {
-      expect(output).toEqual(expected);
+  it(
+    utils.inspect(input).replace(/\n/g, '') + ' => ' + utils.inspect(expected),
+    function() {
+      var src = attrs(input, opts);
+      var localKeys = Object.keys(locals).sort();
+      var output = Function(
+        localKeys.join(', '),
+        'return (' + src + ');'
+      ).apply(
+        null,
+        localKeys.map(function(key) {
+          return locals[key];
+        })
+      );
+      if (opts.format === 'html') {
+        expect(output).toBe(expected);
+      } else {
+        expect(output).toEqual(expected);
+      }
     }
-  });
+  );
 }
 function withOptions(opts, fn) {
-  describe('options: ' + utils.inspect(opts), function () {
+  describe('options: ' + utils.inspect(opts), function() {
     options = opts;
     fn();
   });
 }
 
-withOptions({terse: true, format: 'html', runtime: function (name) { return 'pug.' + name; }}, function () {
-  test([], '');
-  test([{name: 'foo', val: 'false', mustEscape: true}], '');
-  test([{name: 'foo', val: 'true', mustEscape: true}], ' foo');
-  test([{name: 'foo', val: false, mustEscape: true}], '');
-  test([{name: 'foo', val: true, mustEscape: true}], ' foo');
-  test([{name: 'foo', val: 'foo', mustEscape: true}], '', {foo: false});
-  test([{name: 'foo', val: 'foo', mustEscape: true}], ' foo', {foo: true});
-  test([{name: 'foo', val: '"foo"', mustEscape: true}], ' foo="foo"');
-  test([{name: 'foo', val: '"foo"', mustEscape: true}, {name: 'bar', val: '"bar"', mustEscape: true}], ' foo="foo" bar="bar"');
-  test([{name: 'foo', val: 'foo', mustEscape: true}], ' foo="fooo"', {foo: 'fooo'});
-  test([{name: 'foo', val: 'foo', mustEscape: true}, {name: 'bar', val: 'bar', mustEscape: true}], ' foo="fooo" bar="baro"', {foo: 'fooo', bar: 'baro'});
-  test([{name: 'style', val: '{color: "red"}', mustEscape: true}], ' style="color:red;"');
-  test([{name: 'style', val: '{color: color}', mustEscape: true}], ' style="color:red;"', {color: 'red'});
-  test([{name: 'class', val: '"foo"', mustEscape: true}, {name: 'class', val: '["bar", "baz"]', mustEscape: true}], ' class="foo bar baz"');
-  test([{name: 'class', val: '{foo: foo}', mustEscape: true}, {name: 'class', val: '["bar", "baz"]', mustEscape: true}], ' class="foo bar baz"', {foo: true});
-  test([{name: 'class', val: '{foo: foo}', mustEscape: true}, {name: 'class', val: '["bar", "baz"]', mustEscape: true}], ' class="bar baz"', {foo: false});
-  test([{name: 'class', val: 'foo', mustEscape: true}, {name: 'class', val: '"<str>"', mustEscape: true}], ' class="&lt;foo&gt; &lt;str&gt;"', {foo: '<foo>'});
-  test([{name: 'foo', val: '"foo"', mustEscape: true}, {name: 'class', val: '["bar", "baz"]', mustEscape: true}], ' class="bar baz" foo="foo"');
-  test([{name: 'class', val: '["bar", "baz"]', mustEscape: true}, {name: 'foo', val: '"foo"', mustEscape: true}], ' class="bar baz" foo="foo"');
-  test([{name: 'foo', val: '"<foo>"', mustEscape: false}], ' foo="<foo>"');
-  test([{name: 'foo', val: '"<foo>"', mustEscape: true}], ' foo="&lt;foo&gt;"');
-  test([{name: 'foo', val: 'foo', mustEscape: false}], ' foo="<foo>"', {foo: '<foo>'});
-  test([{name: 'foo', val: 'foo', mustEscape: true}], ' foo="&lt;foo&gt;"', {foo: '<foo>'});
-});
-withOptions({terse: false, format: 'html', runtime: function (name) { return 'pug.' + name; }}, function () {
-  test([{name: 'foo', val: 'false', mustEscape: true}], '');
-  test([{name: 'foo', val: 'true', mustEscape: true}], ' foo="foo"');
-  test([{name: 'foo', val: false, mustEscape: true}], '');
-  test([{name: 'foo', val: true, mustEscape: true}], ' foo="foo"');
-  test([{name: 'foo', val: 'foo', mustEscape: true}], '', {foo: false});
-  test([{name: 'foo', val: 'foo', mustEscape: true}], ' foo="foo"', {foo: true});
-});
+withOptions(
+  {
+    terse: true,
+    format: 'html',
+    runtime: function(name) {
+      return 'pug.' + name;
+    },
+  },
+  function() {
+    test([], '');
+    test([{name: 'foo', val: 'false', mustEscape: true}], '');
+    test([{name: 'foo', val: 'true', mustEscape: true}], ' foo');
+    test([{name: 'foo', val: false, mustEscape: true}], '');
+    test([{name: 'foo', val: true, mustEscape: true}], ' foo');
+    test([{name: 'foo', val: 'foo', mustEscape: true}], '', {foo: false});
+    test([{name: 'foo', val: 'foo', mustEscape: true}], ' foo', {foo: true});
+    test([{name: 'foo', val: '"foo"', mustEscape: true}], ' foo="foo"');
+    test(
+      [
+        {name: 'foo', val: '"foo"', mustEscape: true},
+        {name: 'bar', val: '"bar"', mustEscape: true},
+      ],
+      ' foo="foo" bar="bar"'
+    );
+    test([{name: 'foo', val: 'foo', mustEscape: true}], ' foo="fooo"', {
+      foo: 'fooo',
+    });
+    test(
+      [
+        {name: 'foo', val: 'foo', mustEscape: true},
+        {name: 'bar', val: 'bar', mustEscape: true},
+      ],
+      ' foo="fooo" bar="baro"',
+      {foo: 'fooo', bar: 'baro'}
+    );
+    test(
+      [{name: 'style', val: '{color: "red"}', mustEscape: true}],
+      ' style="color:red;"'
+    );
+    test(
+      [{name: 'style', val: '{color: color}', mustEscape: true}],
+      ' style="color:red;"',
+      {color: 'red'}
+    );
+    test(
+      [
+        {name: 'class', val: '"foo"', mustEscape: true},
+        {name: 'class', val: '["bar", "baz"]', mustEscape: true},
+      ],
+      ' class="foo bar baz"'
+    );
+    test(
+      [
+        {name: 'class', val: '{foo: foo}', mustEscape: true},
+        {name: 'class', val: '["bar", "baz"]', mustEscape: true},
+      ],
+      ' class="foo bar baz"',
+      {foo: true}
+    );
+    test(
+      [
+        {name: 'class', val: '{foo: foo}', mustEscape: true},
+        {name: 'class', val: '["bar", "baz"]', mustEscape: true},
+      ],
+      ' class="bar baz"',
+      {foo: false}
+    );
+    test(
+      [
+        {name: 'class', val: 'foo', mustEscape: true},
+        {name: 'class', val: '"<str>"', mustEscape: true},
+      ],
+      ' class="&lt;foo&gt; &lt;str&gt;"',
+      {foo: '<foo>'}
+    );
+    test(
+      [
+        {name: 'foo', val: '"foo"', mustEscape: true},
+        {name: 'class', val: '["bar", "baz"]', mustEscape: true},
+      ],
+      ' class="bar baz" foo="foo"'
+    );
+    test(
+      [
+        {name: 'class', val: '["bar", "baz"]', mustEscape: true},
+        {name: 'foo', val: '"foo"', mustEscape: true},
+      ],
+      ' class="bar baz" foo="foo"'
+    );
+    test([{name: 'foo', val: '"<foo>"', mustEscape: false}], ' foo="<foo>"');
+    test(
+      [{name: 'foo', val: '"<foo>"', mustEscape: true}],
+      ' foo="&lt;foo&gt;"'
+    );
+    test([{name: 'foo', val: 'foo', mustEscape: false}], ' foo="<foo>"', {
+      foo: '<foo>',
+    });
+    test([{name: 'foo', val: 'foo', mustEscape: true}], ' foo="&lt;foo&gt;"', {
+      foo: '<foo>',
+    });
+  }
+);
+withOptions(
+  {
+    terse: false,
+    format: 'html',
+    runtime: function(name) {
+      return 'pug.' + name;
+    },
+  },
+  function() {
+    test([{name: 'foo', val: 'false', mustEscape: true}], '');
+    test([{name: 'foo', val: 'true', mustEscape: true}], ' foo="foo"');
+    test([{name: 'foo', val: false, mustEscape: true}], '');
+    test([{name: 'foo', val: true, mustEscape: true}], ' foo="foo"');
+    test([{name: 'foo', val: 'foo', mustEscape: true}], '', {foo: false});
+    test([{name: 'foo', val: 'foo', mustEscape: true}], ' foo="foo"', {
+      foo: true,
+    });
+  }
+);
 
-withOptions({terse: true, format: 'object', runtime: function (name) { return 'pug.' + name; }}, function () {
-  test([], {});
-  test([{name: 'foo', val: 'false', mustEscape: true}], {foo: false});
-  test([{name: 'foo', val: 'true', mustEscape: true}], {foo: true});
-  test([{name: 'foo', val: false, mustEscape: true}], {foo: false});
-  test([{name: 'foo', val: true, mustEscape: true}], {foo: true});
-  test([{name: 'foo', val: 'foo', mustEscape: true}], {foo: false}, {foo: false});
-  test([{name: 'foo', val: 'foo', mustEscape: true}], {foo: true}, {foo: true});
-  test([{name: 'foo', val: '"foo"', mustEscape: true}], {foo: 'foo'});
-  test([{name: 'foo', val: '"foo"', mustEscape: true}, {name: 'bar', val: '"bar"', mustEscape: true}], {foo: 'foo', bar: 'bar'});
-  test([{name: 'foo', val: 'foo', mustEscape: true}], {foo: 'fooo'}, {foo: 'fooo'});
-  test([{name: 'foo', val: 'foo', mustEscape: true}, {name: 'bar', val: 'bar', mustEscape: true}], {foo: 'fooo', bar: 'baro'}, {foo: 'fooo', bar: 'baro'});
-  test([{name: 'style', val: '{color: "red"}', mustEscape: true}], {style: 'color:red;'});
-  test([{name: 'style', val: '{color: color}', mustEscape: true}], {style: 'color:red;'}, {color: 'red'});
-  test([{name: 'class', val: '"foo"', mustEscape: true}, {name: 'class', val: '["bar", "baz"]', mustEscape: true}], {'class': 'foo bar baz'});
-  test([{name: 'class', val: '{foo: foo}', mustEscape: true}, {name: 'class', val: '["bar", "baz"]', mustEscape: true}], {'class': 'foo bar baz'}, {foo: true});
-  test([{name: 'class', val: '{foo: foo}', mustEscape: true}, {name: 'class', val: '["bar", "baz"]', mustEscape: true}], {'class': 'bar baz'}, {foo: false});
-  test([{name: 'class', val: 'foo', mustEscape: true}, {name: 'class', val: '"<str>"', mustEscape: true}], {'class': '&lt;foo&gt; &lt;str&gt;'}, {foo: '<foo>'});
-  test([{name: 'foo', val: '"foo"', mustEscape: true}, {name: 'class', val: '["bar", "baz"]', mustEscape: true}], {'class': 'bar baz', foo: 'foo'});
-  test([{name: 'class', val: '["bar", "baz"]', mustEscape: true}, {name: 'foo', val: '"foo"', mustEscape: true}], {'class': 'bar baz', foo: 'foo'});
-  test([{name: 'foo', val: '"<foo>"', mustEscape: false}], {foo: "<foo>"});
-  test([{name: 'foo', val: '"<foo>"', mustEscape: true}], {foo: "&lt;foo&gt;"});
-  test([{name: 'foo', val: 'foo', mustEscape: false}], {foo: "<foo>"}, {foo: '<foo>'});
-  test([{name: 'foo', val: 'foo', mustEscape: true}], {foo: "&lt;foo&gt;"}, {foo: '<foo>'});
-});
-withOptions({terse: false, format: 'object', runtime: function (name) { return 'pug.' + name; }}, function () {
-  test([{name: 'foo', val: 'false', mustEscape: true}], {foo: false});
-  test([{name: 'foo', val: 'true', mustEscape: true}], {foo: true});
-  test([{name: 'foo', val: false, mustEscape: true}], {foo: false});
-  test([{name: 'foo', val: true, mustEscape: true}], {foo: true});
-  test([{name: 'foo', val: 'foo', mustEscape: true}], {foo: false}, {foo: false});
-  test([{name: 'foo', val: 'foo', mustEscape: true}], {foo: true}, {foo: true});
-});
+withOptions(
+  {
+    terse: true,
+    format: 'object',
+    runtime: function(name) {
+      return 'pug.' + name;
+    },
+  },
+  function() {
+    test([], {});
+    test([{name: 'foo', val: 'false', mustEscape: true}], {foo: false});
+    test([{name: 'foo', val: 'true', mustEscape: true}], {foo: true});
+    test([{name: 'foo', val: false, mustEscape: true}], {foo: false});
+    test([{name: 'foo', val: true, mustEscape: true}], {foo: true});
+    test(
+      [{name: 'foo', val: 'foo', mustEscape: true}],
+      {foo: false},
+      {foo: false}
+    );
+    test(
+      [{name: 'foo', val: 'foo', mustEscape: true}],
+      {foo: true},
+      {foo: true}
+    );
+    test([{name: 'foo', val: '"foo"', mustEscape: true}], {foo: 'foo'});
+    test(
+      [
+        {name: 'foo', val: '"foo"', mustEscape: true},
+        {name: 'bar', val: '"bar"', mustEscape: true},
+      ],
+      {foo: 'foo', bar: 'bar'}
+    );
+    test(
+      [{name: 'foo', val: 'foo', mustEscape: true}],
+      {foo: 'fooo'},
+      {foo: 'fooo'}
+    );
+    test(
+      [
+        {name: 'foo', val: 'foo', mustEscape: true},
+        {name: 'bar', val: 'bar', mustEscape: true},
+      ],
+      {foo: 'fooo', bar: 'baro'},
+      {foo: 'fooo', bar: 'baro'}
+    );
+    test([{name: 'style', val: '{color: "red"}', mustEscape: true}], {
+      style: 'color:red;',
+    });
+    test(
+      [{name: 'style', val: '{color: color}', mustEscape: true}],
+      {style: 'color:red;'},
+      {color: 'red'}
+    );
+    test(
+      [
+        {name: 'class', val: '"foo"', mustEscape: true},
+        {name: 'class', val: '["bar", "baz"]', mustEscape: true},
+      ],
+      {class: 'foo bar baz'}
+    );
+    test(
+      [
+        {name: 'class', val: '{foo: foo}', mustEscape: true},
+        {name: 'class', val: '["bar", "baz"]', mustEscape: true},
+      ],
+      {class: 'foo bar baz'},
+      {foo: true}
+    );
+    test(
+      [
+        {name: 'class', val: '{foo: foo}', mustEscape: true},
+        {name: 'class', val: '["bar", "baz"]', mustEscape: true},
+      ],
+      {class: 'bar baz'},
+      {foo: false}
+    );
+    test(
+      [
+        {name: 'class', val: 'foo', mustEscape: true},
+        {name: 'class', val: '"<str>"', mustEscape: true},
+      ],
+      {class: '&lt;foo&gt; &lt;str&gt;'},
+      {foo: '<foo>'}
+    );
+    test(
+      [
+        {name: 'foo', val: '"foo"', mustEscape: true},
+        {name: 'class', val: '["bar", "baz"]', mustEscape: true},
+      ],
+      {class: 'bar baz', foo: 'foo'}
+    );
+    test(
+      [
+        {name: 'class', val: '["bar", "baz"]', mustEscape: true},
+        {name: 'foo', val: '"foo"', mustEscape: true},
+      ],
+      {class: 'bar baz', foo: 'foo'}
+    );
+    test([{name: 'foo', val: '"<foo>"', mustEscape: false}], {foo: '<foo>'});
+    test([{name: 'foo', val: '"<foo>"', mustEscape: true}], {
+      foo: '&lt;foo&gt;',
+    });
+    test(
+      [{name: 'foo', val: 'foo', mustEscape: false}],
+      {foo: '<foo>'},
+      {foo: '<foo>'}
+    );
+    test(
+      [{name: 'foo', val: 'foo', mustEscape: true}],
+      {foo: '&lt;foo&gt;'},
+      {foo: '<foo>'}
+    );
+  }
+);
+withOptions(
+  {
+    terse: false,
+    format: 'object',
+    runtime: function(name) {
+      return 'pug.' + name;
+    },
+  },
+  function() {
+    test([{name: 'foo', val: 'false', mustEscape: true}], {foo: false});
+    test([{name: 'foo', val: 'true', mustEscape: true}], {foo: true});
+    test([{name: 'foo', val: false, mustEscape: true}], {foo: false});
+    test([{name: 'foo', val: true, mustEscape: true}], {foo: true});
+    test(
+      [{name: 'foo', val: 'foo', mustEscape: true}],
+      {foo: false},
+      {foo: false}
+    );
+    test(
+      [{name: 'foo', val: 'foo', mustEscape: true}],
+      {foo: true},
+      {foo: true}
+    );
+  }
+);
diff --git a/packages/pug-code-gen/index.js b/packages/pug-code-gen/index.js
index 5c45c6dbd..a75929ce9 100644
--- a/packages/pug-code-gen/index.js
+++ b/packages/pug-code-gen/index.js
@@ -13,7 +13,7 @@ var addWith = require('with');
 // This is used to prevent pretty printing inside certain tags
 var WHITE_SPACE_SENSITIVE_TAGS = {
   pre: true,
-  textarea: true
+  textarea: true,
 };
 
 var INTERNAL_VARIABLES = [
@@ -23,21 +23,20 @@ var INTERNAL_VARIABLES = [
   'pug_debug_filename',
   'pug_debug_line',
   'pug_debug_sources',
-  'pug_html'
+  'pug_html',
 ];
 
 module.exports = generateCode;
 module.exports.CodeGenerator = Compiler;
 function generateCode(ast, options) {
-  return (new Compiler(ast, options)).compile();
+  return new Compiler(ast, options).compile();
 }
 
-
 function isConstant(src) {
-  return constantinople(src, {pug: runtime, 'pug_interp': undefined});
+  return constantinople(src, {pug: runtime, pug_interp: undefined});
 }
 function toConstant(src) {
-  return constantinople.toConstant(src, {pug: runtime, 'pug_interp': undefined});
+  return constantinople.toConstant(src, {pug: runtime, pug_interp: undefined});
 }
 
 /**
@@ -71,15 +70,14 @@ function Compiler(node, options) {
   if (this.debug && this.inlineRuntimeFunctions) {
     this.runtimeFunctionsUsed.push('rethrow');
   }
-};
+}
 
 /**
  * Compiler prototype.
  */
 
 Compiler.prototype = {
-
-  runtime: function (name) {
+  runtime: function(name) {
     if (this.inlineRuntimeFunctions) {
       this.runtimeFunctionsUsed.push(name);
       return 'pug_' + name;
@@ -88,7 +86,7 @@ Compiler.prototype = {
     }
   },
 
-  error: function (message, code, node) {
+  error: function(message, code, node) {
     var err = makeError(code, message, {
       line: node.line,
       column: node.column,
@@ -103,9 +101,9 @@ Compiler.prototype = {
    * @api public
    */
 
-  compile: function(){
+  compile: function() {
     this.buf = [];
-    if (this.pp) this.buf.push("var pug_indent = [];");
+    if (this.pp) this.buf.push('var pug_indent = [];');
     this.lastBufferedIdx = -1;
     this.visit(this.node);
     if (!this.dynamicMixins) {
@@ -115,7 +113,11 @@ Compiler.prototype = {
         var mixin = this.mixins[mixinNames[i]];
         if (!mixin.used) {
           for (var x = 0; x < mixin.instances.length; x++) {
-            for (var y = mixin.instances[x].start; y < mixin.instances[x].end; y++) {
+            for (
+              var y = mixin.instances[x].start;
+              y < mixin.instances[x].end;
+              y++
+            ) {
               this.buf[y] = '';
             }
           }
@@ -123,31 +125,51 @@ Compiler.prototype = {
       }
     }
     var js = this.buf.join('\n');
-    var globals = this.options.globals ? this.options.globals.concat(INTERNAL_VARIABLES) : INTERNAL_VARIABLES;
+    var globals = this.options.globals
+      ? this.options.globals.concat(INTERNAL_VARIABLES)
+      : INTERNAL_VARIABLES;
     if (this.options.self) {
       js = 'var self = locals || {};' + js;
     } else {
-      js = addWith('locals || {}', js, globals.concat(this.runtimeFunctionsUsed.map(function (name) { return 'pug_' + name; })));
+      js = addWith(
+        'locals || {}',
+        js,
+        globals.concat(
+          this.runtimeFunctionsUsed.map(function(name) {
+            return 'pug_' + name;
+          })
+        )
+      );
     }
     if (this.debug) {
       if (this.options.includeSources) {
-        js = 'var pug_debug_sources = ' + stringify(this.options.includeSources) + ';\n' + js;
+        js =
+          'var pug_debug_sources = ' +
+          stringify(this.options.includeSources) +
+          ';\n' +
+          js;
       }
-      js = 'var pug_debug_filename, pug_debug_line;' +
+      js =
+        'var pug_debug_filename, pug_debug_line;' +
         'try {' +
         js +
         '} catch (err) {' +
         (this.inlineRuntimeFunctions ? 'pug_rethrow' : 'pug.rethrow') +
         '(err, pug_debug_filename, pug_debug_line' +
-        (
-          this.options.includeSources
+        (this.options.includeSources
           ? ', pug_debug_sources[pug_debug_filename]'
-          : ''
-        ) +
+          : '') +
         ');' +
         '}';
     }
-    return buildRuntime(this.runtimeFunctionsUsed) + 'function ' + (this.options.templateName || 'template') + '(locals) {var pug_html = "", pug_mixins = {}, pug_interp;' + js + ';return pug_html;}';
+    return (
+      buildRuntime(this.runtimeFunctionsUsed) +
+      'function ' +
+      (this.options.templateName || 'template') +
+      '(locals) {var pug_html = "", pug_mixins = {}, pug_interp;' +
+      js +
+      ';return pug_html;}'
+    );
   },
 
   /**
@@ -159,7 +181,7 @@ Compiler.prototype = {
    * @api public
    */
 
-  setDoctype: function(name){
+  setDoctype: function(name) {
     this.doctype = doctypes[name.toLowerCase()] || '<!DOCTYPE ' + name + '>';
     this.terse = this.doctype.toLowerCase() == '<!doctype html>';
     this.xml = 0 == this.doctype.indexOf('<?xml');
@@ -173,20 +195,27 @@ Compiler.prototype = {
    * @api public
    */
 
-  buffer: function (str) {
+  buffer: function(str) {
     var self = this;
 
     str = stringify(str);
     str = str.substr(1, str.length - 2);
 
-    if (this.lastBufferedIdx == this.buf.length && this.bufferedConcatenationCount < 100) {
+    if (
+      this.lastBufferedIdx == this.buf.length &&
+      this.bufferedConcatenationCount < 100
+    ) {
       if (this.lastBufferedType === 'code') {
         this.lastBuffered += ' + "';
         this.bufferedConcatenationCount++;
       }
       this.lastBufferedType = 'text';
       this.lastBuffered += str;
-      this.buf[this.lastBufferedIdx - 1] = 'pug_html = pug_html + ' + this.bufferStartChar + this.lastBuffered + '";';
+      this.buf[this.lastBufferedIdx - 1] =
+        'pug_html = pug_html + ' +
+        this.bufferStartChar +
+        this.lastBuffered +
+        '";';
     } else {
       this.bufferedConcatenationCount = 0;
       this.buf.push('pug_html = pug_html + "' + str + '";');
@@ -204,16 +233,23 @@ Compiler.prototype = {
    * @api public
    */
 
-  bufferExpression: function (src) {
+  bufferExpression: function(src) {
     if (isConstant(src)) {
-      return this.buffer(toConstant(src) + '')
+      return this.buffer(toConstant(src) + '');
     }
-    if (this.lastBufferedIdx == this.buf.length && this.bufferedConcatenationCount < 100) {
+    if (
+      this.lastBufferedIdx == this.buf.length &&
+      this.bufferedConcatenationCount < 100
+    ) {
       this.bufferedConcatenationCount++;
       if (this.lastBufferedType === 'text') this.lastBuffered += '"';
       this.lastBufferedType = 'code';
       this.lastBuffered += ' + (' + src + ')';
-      this.buf[this.lastBufferedIdx - 1] = 'pug_html = pug_html + (' + this.bufferStartChar + this.lastBuffered + ');';
+      this.buf[this.lastBufferedIdx - 1] =
+        'pug_html = pug_html + (' +
+        this.bufferStartChar +
+        this.lastBuffered +
+        ');';
     } else {
       this.bufferedConcatenationCount = 0;
       this.buf.push('pug_html = pug_html + (' + src + ');');
@@ -233,7 +269,7 @@ Compiler.prototype = {
    * @api public
    */
 
-  prettyIndent: function(offset, newline){
+  prettyIndent: function(offset, newline) {
     offset = offset || 0;
     newline = newline ? '\n' : '';
     this.buffer(newline + Array(this.indents + offset).join(this.pp));
@@ -248,13 +284,20 @@ Compiler.prototype = {
    * @api public
    */
 
-  visit: function(node, parent){
+  visit: function(node, parent) {
     var debug = this.debug;
 
     if (!node) {
       var msg;
       if (parent) {
-        msg = 'A child of ' + parent.type + ' (' + (parent.filename || 'Pug') + ':' + parent.line + ')';
+        msg =
+          'A child of ' +
+          parent.type +
+          ' (' +
+          (parent.filename || 'Pug') +
+          ':' +
+          parent.line +
+          ')';
       } else {
         msg = 'A top-level node';
       }
@@ -265,7 +308,8 @@ Compiler.prototype = {
     if (debug && node.debug !== false && node.type !== 'Block') {
       if (node.line) {
         var js = ';pug_debug_line = ' + node.line;
-        if (node.filename) js += ';pug_debug_filename = ' + stringify(node.filename);
+        if (node.filename)
+          js += ';pug_debug_filename = ' + stringify(node.filename);
         this.buf.push(js + ';');
       }
     }
@@ -273,23 +317,30 @@ Compiler.prototype = {
     if (!this['visit' + node.type]) {
       var msg;
       if (parent) {
-        msg = 'A child of ' + parent.type
+        msg = 'A child of ' + parent.type;
       } else {
         msg = 'A top-level node';
       }
-      msg += ' (' + (node.filename || 'Pug') + ':' + node.line + ')'
-           + ' is of type ' + node.type + ','
-           + ' which is not supported by pug-code-gen.'
+      msg +=
+        ' (' +
+        (node.filename || 'Pug') +
+        ':' +
+        node.line +
+        ')' +
+        ' is of type ' +
+        node.type +
+        ',' +
+        ' which is not supported by pug-code-gen.';
       switch (node.type) {
-      case 'Filter':
-        msg += ' Please use pug-filters to preprocess this AST.'
-        break;
-      case 'Extends':
-      case 'Include':
-      case 'NamedBlock':
-      case 'FileReference': // unlikely but for the sake of completeness
-        msg += ' Please use pug-linker to preprocess this AST.'
-        break;
+        case 'Filter':
+          msg += ' Please use pug-filters to preprocess this AST.';
+          break;
+        case 'Extends':
+        case 'Include':
+        case 'NamedBlock':
+        case 'FileReference': // unlikely but for the sake of completeness
+          msg += ' Please use pug-linker to preprocess this AST.';
+          break;
       }
       throw new TypeError(msg);
     }
@@ -304,7 +355,7 @@ Compiler.prototype = {
    * @api public
    */
 
-  visitNode: function(node){
+  visitNode: function(node) {
     return this['visit' + node.type](node);
   },
 
@@ -315,7 +366,7 @@ Compiler.prototype = {
    * @api public
    */
 
-  visitCase: function(node){
+  visitCase: function(node) {
     this.buf.push('switch (' + node.expr + '){');
     this.visit(node.block, node);
     this.buf.push('}');
@@ -328,7 +379,7 @@ Compiler.prototype = {
    * @api public
    */
 
-  visitWhen: function(node){
+  visitWhen: function(node) {
     if ('default' == node.expr) {
       this.buf.push('default:');
     } else {
@@ -347,11 +398,11 @@ Compiler.prototype = {
    * @api public
    */
 
-  visitLiteral: function(node){
+  visitLiteral: function(node) {
     this.buffer(node.str);
   },
 
-  visitNamedBlock: function(block){
+  visitNamedBlock: function(block) {
     return this.visitBlock(block);
   },
   /**
@@ -361,20 +412,30 @@ Compiler.prototype = {
    * @api public
    */
 
-  visitBlock: function(block){
+  visitBlock: function(block) {
     var escapePrettyMode = this.escapePrettyMode;
     var pp = this.pp;
 
     // Pretty print multi-line text
-    if (pp && block.nodes.length > 1 && !escapePrettyMode &&
-        block.nodes[0].type === 'Text' && block.nodes[1].type === 'Text' ) {
+    if (
+      pp &&
+      block.nodes.length > 1 &&
+      !escapePrettyMode &&
+      block.nodes[0].type === 'Text' &&
+      block.nodes[1].type === 'Text'
+    ) {
       this.prettyIndent(1, true);
     }
     for (var i = 0; i < block.nodes.length; ++i) {
       // Pretty print text
-      if (pp && i > 0 && !escapePrettyMode &&
-          block.nodes[i].type === 'Text' && block.nodes[i-1].type === 'Text' &&
-          /\n$/.test(block.nodes[i - 1].val)) {
+      if (
+        pp &&
+        i > 0 &&
+        !escapePrettyMode &&
+        block.nodes[i].type === 'Text' &&
+        block.nodes[i - 1].type === 'Text' &&
+        /\n$/.test(block.nodes[i - 1].val)
+      ) {
         this.prettyIndent(1, false);
       }
       this.visit(block.nodes[i], block);
@@ -388,10 +449,13 @@ Compiler.prototype = {
    * @api public
    */
 
-  visitMixinBlock: function(block){
-    if (this.pp) this.buf.push("pug_indent.push('" + Array(this.indents + 1).join(this.pp) + "');");
+  visitMixinBlock: function(block) {
+    if (this.pp)
+      this.buf.push(
+        "pug_indent.push('" + Array(this.indents + 1).join(this.pp) + "');"
+      );
     this.buf.push('block && block();');
-    if (this.pp) this.buf.push("pug_indent.pop();");
+    if (this.pp) this.buf.push('pug_indent.pop();');
   },
 
   /**
@@ -403,7 +467,7 @@ Compiler.prototype = {
    * @api public
    */
 
-  visitDoctype: function(doctype){
+  visitDoctype: function(doctype) {
     if (doctype && (doctype.val || !this.doctype)) {
       this.setDoctype(doctype.val || 'html');
     }
@@ -420,24 +484,29 @@ Compiler.prototype = {
    * @api public
    */
 
-  visitMixin: function(mixin){
+  visitMixin: function(mixin) {
     var name = 'pug_mixins[';
     var args = mixin.args || '';
     var block = mixin.block;
     var attrs = mixin.attrs;
     var attrsBlocks = this.attributeBlocks(mixin.attributeBlocks);
     var pp = this.pp;
-    var dynamic = mixin.name[0]==='#';
+    var dynamic = mixin.name[0] === '#';
     var key = mixin.name;
     if (dynamic) this.dynamicMixins = true;
-    name += (dynamic ? mixin.name.substr(2,mixin.name.length-3):'"'+mixin.name+'"')+']';
+    name +=
+      (dynamic
+        ? mixin.name.substr(2, mixin.name.length - 3)
+        : '"' + mixin.name + '"') + ']';
 
     this.mixins[key] = this.mixins[key] || {used: false, instances: []};
     if (mixin.call) {
       this.mixins[key].used = true;
-      if (pp) this.buf.push("pug_indent.push('" + Array(this.indents + 1).join(pp) + "');")
+      if (pp)
+        this.buf.push(
+          "pug_indent.push('" + Array(this.indents + 1).join(pp) + "');"
+        );
       if (block || attrs.length || attrsBlocks.length) {
-
         this.buf.push(name + '.call({');
 
         if (block) {
@@ -464,7 +533,13 @@ Compiler.prototype = {
             attrsBlocks.unshift(val);
           }
           if (attrsBlocks.length > 1) {
-            this.buf.push('attributes: ' + this.runtime('merge') + '([' + attrsBlocks.join(',') + '])');
+            this.buf.push(
+              'attributes: ' +
+                this.runtime('merge') +
+                '([' +
+                attrsBlocks.join(',') +
+                '])'
+            );
           } else {
             this.buf.push('attributes: ' + attrsBlocks[0]);
           }
@@ -478,25 +553,33 @@ Compiler.prototype = {
         } else {
           this.buf.push('});');
         }
-
       } else {
         this.buf.push(name + '(' + args + ');');
       }
-      if (pp) this.buf.push("pug_indent.pop();")
+      if (pp) this.buf.push('pug_indent.pop();');
     } else {
       var mixin_start = this.buf.length;
       args = args ? args.split(',') : [];
       var rest;
       if (args.length && /^\.\.\./.test(args[args.length - 1].trim())) {
-        rest = args.pop().trim().replace(/^\.\.\./, '');
+        rest = args
+          .pop()
+          .trim()
+          .replace(/^\.\.\./, '');
       }
       // we need use pug_interp here for v8: https://code.google.com/p/v8/issues/detail?id=4165
       // once fixed, use this: this.buf.push(name + ' = function(' + args.join(',') + '){');
       this.buf.push(name + ' = pug_interp = function(' + args.join(',') + '){');
-      this.buf.push('var block = (this && this.block), attributes = (this && this.attributes) || {};');
+      this.buf.push(
+        'var block = (this && this.block), attributes = (this && this.attributes) || {};'
+      );
       if (rest) {
         this.buf.push('var ' + rest + ' = [];');
-        this.buf.push('for (pug_interp = ' + args.length + '; pug_interp < arguments.length; pug_interp++) {');
+        this.buf.push(
+          'for (pug_interp = ' +
+            args.length +
+            '; pug_interp < arguments.length; pug_interp++) {'
+        );
         this.buf.push('  ' + rest + '.push(arguments[pug_interp]);');
         this.buf.push('}');
       }
@@ -518,18 +601,19 @@ Compiler.prototype = {
    * @api public
    */
 
-  visitTag: function(tag, interpolated){
+  visitTag: function(tag, interpolated) {
     this.indents++;
-    var name = tag.name
-      , pp = this.pp
-      , self = this;
+    var name = tag.name,
+      pp = this.pp,
+      self = this;
 
     function bufferName() {
       if (interpolated) self.bufferExpression(tag.expr);
       else self.buffer(name);
     }
 
-    if (WHITE_SPACE_SENSITIVE_TAGS[tag.name] === true) this.escapePrettyMode = true;
+    if (WHITE_SPACE_SENSITIVE_TAGS[tag.name] === true)
+      this.escapePrettyMode = true;
 
     if (!this.hasCompiledTag) {
       if (!this.hasCompiledDoctype && 'html' == name) {
@@ -539,37 +623,56 @@ Compiler.prototype = {
     }
 
     // pretty print
-    if (pp && !tag.isInline)
-      this.prettyIndent(0, true);
+    if (pp && !tag.isInline) this.prettyIndent(0, true);
     if (tag.selfClosing || (!this.xml && selfClosing[tag.name])) {
       this.buffer('<');
       bufferName();
-      this.visitAttributes(tag.attrs, this.attributeBlocks(tag.attributeBlocks));
+      this.visitAttributes(
+        tag.attrs,
+        this.attributeBlocks(tag.attributeBlocks)
+      );
       if (this.terse && !tag.selfClosing) {
         this.buffer('>');
       } else {
         this.buffer('/>');
       }
       // if it is non-empty throw an error
-      if (tag.code ||
-          tag.block &&
+      if (
+        tag.code ||
+        (tag.block &&
           !(tag.block.type === 'Block' && tag.block.nodes.length === 0) &&
-          tag.block.nodes.some(function (tag) {
-            return tag.type !== 'Text' || !/^\s*$/.test(tag.val)
-          })) {
-        this.error(name + ' is a self closing element: <'+name+'/> but contains nested content.', 'SELF_CLOSING_CONTENT', tag);
+          tag.block.nodes.some(function(tag) {
+            return tag.type !== 'Text' || !/^\s*$/.test(tag.val);
+          }))
+      ) {
+        this.error(
+          name +
+            ' is a self closing element: <' +
+            name +
+            '/> but contains nested content.',
+          'SELF_CLOSING_CONTENT',
+          tag
+        );
       }
     } else {
       // Optimize attributes buffering
       this.buffer('<');
       bufferName();
-      this.visitAttributes(tag.attrs, this.attributeBlocks(tag.attributeBlocks));
+      this.visitAttributes(
+        tag.attrs,
+        this.attributeBlocks(tag.attributeBlocks)
+      );
       this.buffer('>');
       if (tag.code) this.visitCode(tag.code);
       this.visit(tag.block, tag);
 
       // pretty print
-      if (pp && !tag.isInline && WHITE_SPACE_SENSITIVE_TAGS[tag.name] !== true && !tagCanInline(tag))
+      if (
+        pp &&
+        !tag.isInline &&
+        WHITE_SPACE_SENSITIVE_TAGS[tag.name] !== true &&
+        !tagCanInline(tag)
+      )
         this.prettyIndent(0, true);
 
       this.buffer('</');
@@ -577,7 +680,8 @@ Compiler.prototype = {
       this.buffer('>');
     }
 
-    if (WHITE_SPACE_SENSITIVE_TAGS[tag.name] === true) this.escapePrettyMode = false;
+    if (WHITE_SPACE_SENSITIVE_TAGS[tag.name] === true)
+      this.escapePrettyMode = false;
 
     this.indents--;
   },
@@ -600,7 +704,7 @@ Compiler.prototype = {
    * @api public
    */
 
-  visitText: function(text){
+  visitText: function(text) {
     this.buffer(text.val);
   },
 
@@ -611,7 +715,7 @@ Compiler.prototype = {
    * @api public
    */
 
-  visitComment: function(comment){
+  visitComment: function(comment) {
     if (!comment.buffer) return;
     if (this.pp) this.prettyIndent(1, true);
     this.buffer('<!--' + comment.val + '-->');
@@ -635,7 +739,7 @@ Compiler.prototype = {
    * @api public
    */
 
-  visitBlockComment: function(comment){
+  visitBlockComment: function(comment) {
     if (!comment.buffer) return;
     if (this.pp) this.prettyIndent(1, true);
     this.buffer('<!--' + (comment.val || ''));
@@ -653,7 +757,7 @@ Compiler.prototype = {
    * @api public
    */
 
-  visitCode: function(code){
+  visitCode: function(code) {
     // Wrap code blocks with {}.
     // we only wrap unbuffered code blocks ATM
     // since they are usually flow control
@@ -661,8 +765,9 @@ Compiler.prototype = {
     // Buffer code
     if (code.buffer) {
       var val = code.val.trim();
-      val = 'null == (pug_interp = '+val+') ? "" : pug_interp';
-      if (code.mustEscape !== false) val = this.runtime('escape') + '(' + val + ')';
+      val = 'null == (pug_interp = ' + val + ') ? "" : pug_interp';
+      if (code.mustEscape !== false)
+        val = this.runtime('escape') + '(' + val + ')';
       this.bufferExpression(val);
     } else {
       this.buf.push(code.val);
@@ -683,14 +788,14 @@ Compiler.prototype = {
    * @api public
    */
 
-  visitConditional: function(cond){
+  visitConditional: function(cond) {
     var test = cond.test;
     this.buf.push('if (' + test + ') {');
     this.visit(cond.consequent, cond);
-    this.buf.push('}')
+    this.buf.push('}');
     if (cond.alternate) {
       if (cond.alternate.type === 'Conditional') {
-        this.buf.push('else')
+        this.buf.push('else');
         this.visitConditional(cond.alternate);
       } else {
         this.buf.push('else {');
@@ -707,7 +812,7 @@ Compiler.prototype = {
    * @api public
    */
 
-  visitWhile: function(loop){
+  visitWhile: function(loop) {
     var test = loop.test;
     this.buf.push('while (' + test + ') {');
     this.visit(loop.block, loop);
@@ -721,23 +826,41 @@ Compiler.prototype = {
    * @api public
    */
 
-  visitEach: function(each){
+  visitEach: function(each) {
     var indexVarName = each.key || 'pug_index' + this.eachCount;
     this.eachCount++;
 
-    this.buf.push(''
-      + '// iterate ' + each.obj + '\n'
-      + ';(function(){\n'
-      + '  var $$obj = ' + each.obj + ';\n'
-      + '  if (\'number\' == typeof $$obj.length) {');
+    this.buf.push(
+      '' +
+        '// iterate ' +
+        each.obj +
+        '\n' +
+        ';(function(){\n' +
+        '  var $$obj = ' +
+        each.obj +
+        ';\n' +
+        "  if ('number' == typeof $$obj.length) {"
+    );
 
     if (each.alternate) {
       this.buf.push('    if ($$obj.length) {');
     }
 
-    this.buf.push(''
-      + '      for (var ' + indexVarName + ' = 0, $$l = $$obj.length; ' + indexVarName + ' < $$l; ' + indexVarName + '++) {\n'
-      + '        var ' + each.val + ' = $$obj[' + indexVarName + '];');
+    this.buf.push(
+      '' +
+        '      for (var ' +
+        indexVarName +
+        ' = 0, $$l = $$obj.length; ' +
+        indexVarName +
+        ' < $$l; ' +
+        indexVarName +
+        '++) {\n' +
+        '        var ' +
+        each.val +
+        ' = $$obj[' +
+        indexVarName +
+        '];'
+    );
 
     this.visit(each.block, each);
 
@@ -749,12 +872,20 @@ Compiler.prototype = {
       this.buf.push('    }');
     }
 
-    this.buf.push(''
-      + '  } else {\n'
-      + '    var $$l = 0;\n'
-      + '    for (var ' + indexVarName + ' in $$obj) {\n'
-      + '      $$l++;\n'
-      + '      var ' + each.val + ' = $$obj[' + indexVarName + '];');
+    this.buf.push(
+      '' +
+        '  } else {\n' +
+        '    var $$l = 0;\n' +
+        '    for (var ' +
+        indexVarName +
+        ' in $$obj) {\n' +
+        '      $$l++;\n' +
+        '      var ' +
+        each.val +
+        ' = $$obj[' +
+        indexVarName +
+        '];'
+    );
 
     this.visit(each.block, each);
 
@@ -767,10 +898,18 @@ Compiler.prototype = {
     this.buf.push('  }\n}).call(this);\n');
   },
 
-  visitEachOf: function(each){
-    this.buf.push(''
-      + '// iterate ' + each.obj + '\n'
-      + 'for (const ' + each.val + ' of ' + each.obj + ') {\n')
+  visitEachOf: function(each) {
+    this.buf.push(
+      '' +
+        '// iterate ' +
+        each.obj +
+        '\n' +
+        'for (const ' +
+        each.val +
+        ' of ' +
+        each.obj +
+        ') {\n'
+    );
 
     this.visit(each.block, each);
 
@@ -784,16 +923,32 @@ Compiler.prototype = {
    * @api public
    */
 
-  visitAttributes: function(attrs, attributeBlocks){
+  visitAttributes: function(attrs, attributeBlocks) {
     if (attributeBlocks.length) {
       if (attrs.length) {
         var val = this.attrs(attrs);
         attributeBlocks.unshift(val);
       }
       if (attributeBlocks.length > 1) {
-        this.bufferExpression(this.runtime('attrs') + '(' + this.runtime('merge') + '([' + attributeBlocks.join(',') + ']), ' + stringify(this.terse) + ')');
+        this.bufferExpression(
+          this.runtime('attrs') +
+            '(' +
+            this.runtime('merge') +
+            '([' +
+            attributeBlocks.join(',') +
+            ']), ' +
+            stringify(this.terse) +
+            ')'
+        );
       } else {
-        this.bufferExpression(this.runtime('attrs') + '(' + attributeBlocks[0] + ', ' + stringify(this.terse) + ')');
+        this.bufferExpression(
+          this.runtime('attrs') +
+            '(' +
+            attributeBlocks[0] +
+            ', ' +
+            stringify(this.terse) +
+            ')'
+        );
       }
     } else if (attrs.length) {
       this.attrs(attrs, true);
@@ -804,13 +959,13 @@ Compiler.prototype = {
    * Compile attributes.
    */
 
-  attrs: function(attrs, buffer){
+  attrs: function(attrs, buffer) {
     var res = compileAttrs(attrs, {
       terse: this.terse,
       format: buffer ? 'html' : 'object',
-      runtime: this.runtime.bind(this)
+      runtime: this.runtime.bind(this),
     });
-    if (buffer)  {
+    if (buffer) {
       this.bufferExpression(res);
     }
     return res;
@@ -820,15 +975,18 @@ Compiler.prototype = {
    * Compile attribute blocks.
    */
 
-  attributeBlocks: function (attributeBlocks) {
-    return attributeBlocks && attributeBlocks.slice().map(function(attrBlock){
-      return attrBlock.val;
-    });
-  }
+  attributeBlocks: function(attributeBlocks) {
+    return (
+      attributeBlocks &&
+      attributeBlocks.slice().map(function(attrBlock) {
+        return attrBlock.val;
+      })
+    );
+  },
 };
 
 function tagCanInline(tag) {
-  function isInline(node){
+  function isInline(node) {
     // Recurse if the node is a block
     if (node.type === 'Block') return node.nodes.every(isInline);
     // When there is a YieldBlock here, it is an indication that the file is
diff --git a/packages/pug-error/index.js b/packages/pug-error/index.js
index 2ec94c56b..9bc75135d 100644
--- a/packages/pug-error/index.js
+++ b/packages/pug-error/index.js
@@ -13,19 +13,21 @@ function makeError(code, message, options) {
     var start = Math.max(line - 3, 0);
     var end = Math.min(lines.length, line + 3);
     // Error context
-    var context = lines.slice(start, end).map(function(text, i){
-      var curr = i + start + 1;
-      var preamble = (curr == line ? '  > ' : '    ')
-        + curr
-        + '| ';
-      var out = preamble + text;
-      if (curr === line && column > 0) {
-        out += '\n';
-        out += Array(preamble.length + column).join('-') + '^';
-      }
-      return out;
-    }).join('\n');
-    fullMessage = (filename || 'Pug') + ':' + location + '\n' + context + '\n\n' + message;
+    var context = lines
+      .slice(start, end)
+      .map(function(text, i) {
+        var curr = i + start + 1;
+        var preamble = (curr == line ? '  > ' : '    ') + curr + '| ';
+        var out = preamble + text;
+        if (curr === line && column > 0) {
+          out += '\n';
+          out += Array(preamble.length + column).join('-') + '^';
+        }
+        return out;
+      })
+      .join('\n');
+    fullMessage =
+      (filename || 'Pug') + ':' + location + '\n' + context + '\n\n' + message;
   } else {
     fullMessage = (filename || 'Pug') + ':' + location + '\n\n' + message;
   }
@@ -36,13 +38,13 @@ function makeError(code, message, options) {
   err.column = column;
   err.filename = filename;
   err.src = src;
-  err.toJSON = function () {
+  err.toJSON = function() {
     return {
       code: this.code,
       msg: this.msg,
       line: this.line,
       column: this.column,
-      filename: this.filename
+      filename: this.filename,
     };
   };
   return err;
diff --git a/packages/pug-error/test/index.test.js b/packages/pug-error/test/index.test.js
index 4ad01ef90..19aca14a3 100644
--- a/packages/pug-error/test/index.test.js
+++ b/packages/pug-error/test/index.test.js
@@ -3,19 +3,30 @@
 var assert = require('assert');
 var error = require('../');
 
-describe('with a source', function () {
-  test('and a filename', function () {
-    var err = error('MY_CODE', 'My message', {line: 3, filename: 'myfile', src: 'foo\nbar\nbaz\nbash\nbing'});
-    expect(err.message).toBe('myfile:3\n    1| foo\n    2| bar\n  > 3| baz\n    4| bash\n    5| bing\n\nMy message');
+describe('with a source', function() {
+  test('and a filename', function() {
+    var err = error('MY_CODE', 'My message', {
+      line: 3,
+      filename: 'myfile',
+      src: 'foo\nbar\nbaz\nbash\nbing',
+    });
+    expect(err.message).toBe(
+      'myfile:3\n    1| foo\n    2| bar\n  > 3| baz\n    4| bash\n    5| bing\n\nMy message'
+    );
     expect(err.code).toBe('PUG:MY_CODE');
     expect(err.msg).toBe('My message');
     expect(err.line).toBe(3);
     expect(err.filename).toBe('myfile');
     expect(err.src).toBe('foo\nbar\nbaz\nbash\nbing');
   });
-  test('and no filename', function () {
-    var err = error('MY_CODE', 'My message', {line: 3, src: 'foo\nbar\nbaz\nbash\nbing'});
-    expect(err.message).toBe('Pug:3\n    1| foo\n    2| bar\n  > 3| baz\n    4| bash\n    5| bing\n\nMy message');
+  test('and no filename', function() {
+    var err = error('MY_CODE', 'My message', {
+      line: 3,
+      src: 'foo\nbar\nbaz\nbash\nbing',
+    });
+    expect(err.message).toBe(
+      'Pug:3\n    1| foo\n    2| bar\n  > 3| baz\n    4| bash\n    5| bing\n\nMy message'
+    );
     expect(err.code).toBe('PUG:MY_CODE');
     expect(err.msg).toBe('My message');
     expect(err.line).toBe(3);
@@ -24,8 +35,8 @@ describe('with a source', function () {
   });
 });
 
-describe('without source', function () {
-  test('and with a filename', function () {
+describe('without source', function() {
+  test('and with a filename', function() {
     var err = error('MY_CODE', 'My message', {line: 3, filename: 'myfile'});
     expect(err.message).toBe('myfile:3\n\nMy message');
     expect(err.code).toBe('PUG:MY_CODE');
@@ -34,7 +45,7 @@ describe('without source', function () {
     expect(err.filename).toBe('myfile');
     expect(err.src).toBe(undefined);
   });
-  test('and with no filename', function () {
+  test('and with no filename', function() {
     var err = error('MY_CODE', 'My message', {line: 3});
     expect(err.message).toBe('Pug:3\n\nMy message');
     expect(err.code).toBe('PUG:MY_CODE');
@@ -45,17 +56,24 @@ describe('without source', function () {
   });
 });
 
-describe('with column', function () {
-  test('and with a filename', function () {
-    var err = error('MY_CODE', 'My message', {line: 3, column: 2, filename: 'myfile', src: 'foo\nbar\nbaz\nbash\nbing'});
-    expect(err.message).toBe('myfile:3:2\n    1| foo\n    2| bar\n  > 3| baz\n--------^\n    4| bash\n    5| bing\n\nMy message');
+describe('with column', function() {
+  test('and with a filename', function() {
+    var err = error('MY_CODE', 'My message', {
+      line: 3,
+      column: 2,
+      filename: 'myfile',
+      src: 'foo\nbar\nbaz\nbash\nbing',
+    });
+    expect(err.message).toBe(
+      'myfile:3:2\n    1| foo\n    2| bar\n  > 3| baz\n--------^\n    4| bash\n    5| bing\n\nMy message'
+    );
     expect(err.code).toBe('PUG:MY_CODE');
     expect(err.msg).toBe('My message');
     expect(err.line).toBe(3);
     expect(err.filename).toBe('myfile');
     expect(err.src).toBe('foo\nbar\nbaz\nbash\nbing');
   });
-  test('and with no filename', function () {
+  test('and with no filename', function() {
     var err = error('MY_CODE', 'My message', {line: 3, column: 1});
     expect(err.message).toBe('Pug:3:1\n\nMy message');
     expect(err.code).toBe('PUG:MY_CODE');
@@ -66,22 +84,31 @@ describe('with column', function () {
   });
 });
 
-describe('invalid information', function () {
-  test('negative column', function () {
-    var err = error('MY_CODE', 'My message', {line: 3, column: -1, src: 'foo\nbar\nbaz\nbash\nbing'});
-    expect(err.message).toBe('Pug:3:-1\n    1| foo\n    2| bar\n  > 3| baz\n    4| bash\n    5| bing\n\nMy message');
+describe('invalid information', function() {
+  test('negative column', function() {
+    var err = error('MY_CODE', 'My message', {
+      line: 3,
+      column: -1,
+      src: 'foo\nbar\nbaz\nbash\nbing',
+    });
+    expect(err.message).toBe(
+      'Pug:3:-1\n    1| foo\n    2| bar\n  > 3| baz\n    4| bash\n    5| bing\n\nMy message'
+    );
     expect(err.code).toBe('PUG:MY_CODE');
     expect(err.msg).toBe('My message');
     expect(err.line).toBe(3);
     expect(err.filename).toBe(undefined);
     expect(err.src).toBe('foo\nbar\nbaz\nbash\nbing');
-  })
-  test('out of range line', function () {
+  });
+  test('out of range line', function() {
     check(0);
     check(6);
 
     function check(line) {
-      var err = error('MY_CODE', 'My message', {line: line, src: 'foo\nbar\nbaz\nbash\nbing'});
+      var err = error('MY_CODE', 'My message', {
+        line: line,
+        src: 'foo\nbar\nbaz\nbash\nbing',
+      });
       expect(err.message).toBe('Pug:' + line + '\n\nMy message');
       expect(err.code).toBe('PUG:MY_CODE');
       expect(err.msg).toBe('My message');
diff --git a/packages/pug-filters/index.js b/packages/pug-filters/index.js
index 7a687956e..96cc17f4e 100644
--- a/packages/pug-filters/index.js
+++ b/packages/pug-filters/index.js
@@ -1,4 +1,4 @@
 'use strict';
 
 exports.runFilter = require('./lib/run-filter');
-exports.handleFilters = require('./lib/handle-filters');
\ No newline at end of file
+exports.handleFilters = require('./lib/handle-filters');
diff --git a/packages/pug-filters/lib/handle-filters.js b/packages/pug-filters/lib/handle-filters.js
index 91cac9539..6696290e8 100644
--- a/packages/pug-filters/lib/handle-filters.js
+++ b/packages/pug-filters/lib/handle-filters.js
@@ -9,56 +9,63 @@ var runFilter = require('./run-filter');
 module.exports = handleFilters;
 function handleFilters(ast, filters, options, filterAliases) {
   options = options || {};
-  walk(ast, function (node) {
-    var dir = node.filename ? dirname(node.filename) : null;
-    if (node.type === 'Filter') {
-      handleNestedFilters(node, filters, options, filterAliases);
-      var text = getBodyAsText(node);
-      var attrs = getAttributes(node, options);
-      attrs.filename = node.filename;
-      node.type = 'Text';
-      node.val = filterWithFallback(node, text, attrs);
-    } else if (node.type === 'RawInclude' && node.filters.length) {
-      var firstFilter = node.filters.pop();
-      var attrs = getAttributes(firstFilter, options);
-      var filename = attrs.filename = node.file.fullPath;
-      var str = node.file.str;
-      node.type = 'Text';
-      node.val = filterFileWithFallback(firstFilter, filename, str, attrs);
-      node.filters.slice().reverse().forEach(function (filter) {
-        var attrs = getAttributes(filter, options);
-        attrs.filename = filename;
-        node.val = filterWithFallback(filter, node.val, attrs);
-      });
-      node.filters = undefined;
-      node.file = undefined;
-    }
+  walk(
+    ast,
+    function(node) {
+      var dir = node.filename ? dirname(node.filename) : null;
+      if (node.type === 'Filter') {
+        handleNestedFilters(node, filters, options, filterAliases);
+        var text = getBodyAsText(node);
+        var attrs = getAttributes(node, options);
+        attrs.filename = node.filename;
+        node.type = 'Text';
+        node.val = filterWithFallback(node, text, attrs);
+      } else if (node.type === 'RawInclude' && node.filters.length) {
+        var firstFilter = node.filters.pop();
+        var attrs = getAttributes(firstFilter, options);
+        var filename = (attrs.filename = node.file.fullPath);
+        var str = node.file.str;
+        node.type = 'Text';
+        node.val = filterFileWithFallback(firstFilter, filename, str, attrs);
+        node.filters
+          .slice()
+          .reverse()
+          .forEach(function(filter) {
+            var attrs = getAttributes(filter, options);
+            attrs.filename = filename;
+            node.val = filterWithFallback(filter, node.val, attrs);
+          });
+        node.filters = undefined;
+        node.file = undefined;
+      }
 
-    function filterWithFallback(filter, text, attrs, funcName) {
-      try {
+      function filterWithFallback(filter, text, attrs, funcName) {
+        try {
+          var filterName = getFilterName(filter);
+          if (filters && filters[filterName]) {
+            return filters[filterName](text, attrs);
+          } else {
+            return runFilter(filterName, text, attrs, dir, funcName);
+          }
+        } catch (ex) {
+          if (ex.code === 'UNKNOWN_FILTER') {
+            throw error(ex.code, ex.message, filter);
+          }
+          throw ex;
+        }
+      }
+
+      function filterFileWithFallback(filter, filename, text, attrs) {
         var filterName = getFilterName(filter);
         if (filters && filters[filterName]) {
           return filters[filterName](text, attrs);
         } else {
-          return runFilter(filterName, text, attrs, dir, funcName);
-        }
-      } catch (ex) {
-        if (ex.code === 'UNKNOWN_FILTER') {
-          throw error(ex.code, ex.message, filter);
+          return filterWithFallback(filter, filename, attrs, 'renderFile');
         }
-        throw ex;
       }
-    }
-
-    function filterFileWithFallback(filter, filename, text, attrs) {
-      var filterName = getFilterName(filter);
-      if (filters && filters[filterName]) {
-        return filters[filterName](text, attrs);
-      } else {
-        return filterWithFallback(filter, filename, attrs, 'renderFile');
-      }
-    }
-  }, {includeDependencies: true});
+    },
+    {includeDependencies: true}
+  );
   function getFilterName(filter) {
     var filterName = filter.name;
     if (filterAliases && filterAliases[filterName]) {
@@ -66,9 +73,13 @@ function handleFilters(ast, filters, options, filterAliases) {
       if (filterAliases[filterName]) {
         throw error(
           'FILTER_ALISE_CHAIN',
-          'The filter "' + filter.name + '" is an alias for "' + filterName +
-          '", which is an alias for "' + filterAliases[filterName] +
-          '".  Pug does not support chains of filter aliases.',
+          'The filter "' +
+            filter.name +
+            '" is an alias for "' +
+            filterName +
+            '", which is an alias for "' +
+            filterAliases[filterName] +
+            '".  Pug does not support chains of filter aliases.',
           filter
         );
       }
@@ -76,34 +87,47 @@ function handleFilters(ast, filters, options, filterAliases) {
     return filterName;
   }
   return ast;
-};
+}
 
 function handleNestedFilters(node, filters, options, filterAliases) {
   if (node.block.nodes[0] && node.block.nodes[0].type === 'Filter') {
-    node.block.nodes[0] = handleFilters(node.block, filters, options, filterAliases).nodes[0];
+    node.block.nodes[0] = handleFilters(
+      node.block,
+      filters,
+      options,
+      filterAliases
+    ).nodes[0];
   }
 }
 
 function getBodyAsText(node) {
-  return node.block.nodes.map(
-    function(node){ return node.val; }
-  ).join('');
+  return node.block.nodes
+    .map(function(node) {
+      return node.val;
+    })
+    .join('');
 }
 
 function getAttributes(node, options) {
   var attrs = {};
-  node.attrs.forEach(function (attr) {
+  node.attrs.forEach(function(attr) {
     try {
-      attrs[attr.name] = attr.val === true ? true : constantinople.toConstant(attr.val);
+      attrs[attr.name] =
+        attr.val === true ? true : constantinople.toConstant(attr.val);
     } catch (ex) {
       if (/not constant/.test(ex.message)) {
-        throw error('FILTER_OPTION_NOT_CONSTANT', ex.message + ' All filters are rendered compile-time so filter options must be constants.', node);
+        throw error(
+          'FILTER_OPTION_NOT_CONSTANT',
+          ex.message +
+            ' All filters are rendered compile-time so filter options must be constants.',
+          node
+        );
       }
       throw ex;
     }
   });
   var opts = options[node.name] || {};
-  Object.keys(opts).forEach(function (opt) {
+  Object.keys(opts).forEach(function(opt) {
     if (!attrs.hasOwnProperty(opt)) {
       attrs[opt] = opts[opt];
     }
diff --git a/packages/pug-filters/lib/run-filter.js b/packages/pug-filters/lib/run-filter.js
index a0cec0457..5c58b484c 100644
--- a/packages/pug-filters/lib/run-filter.js
+++ b/packages/pug-filters/lib/run-filter.js
@@ -11,7 +11,9 @@ function filter(name, str, options, currentDirectory, funcName) {
   var trPath;
   try {
     try {
-      trPath = resolve.sync('jstransformer-' + name, {basedir: currentDirectory || process.cwd()});
+      trPath = resolve.sync('jstransformer-' + name, {
+        basedir: currentDirectory || process.cwd(),
+      });
     } catch (ex) {
       trPath = require.resolve('jstransformer-' + name);
     }
diff --git a/packages/pug-filters/test/custom-filters.js b/packages/pug-filters/test/custom-filters.js
index 80da75006..74755e510 100644
--- a/packages/pug-filters/test/custom-filters.js
+++ b/packages/pug-filters/test/custom-filters.js
@@ -1,9 +1,9 @@
 var assert = require('assert');
 
 module.exports = {
-  custom: function (str, options) {
+  custom: function(str, options) {
     expect(options.opt).toBe('val');
     expect(options.num).toBe(2);
     return 'BEGIN' + str + 'END';
-  }
+  },
 };
diff --git a/packages/pug-filters/test/filter-aliases.test.js b/packages/pug-filters/test/filter-aliases.test.js
index 14caa0035..3a4bf3bf9 100644
--- a/packages/pug-filters/test/filter-aliases.test.js
+++ b/packages/pug-filters/test/filter-aliases.test.js
@@ -12,14 +12,14 @@ script
     }
   `;
 
-  const ast = parse(
-    lex(source, {filename: __filename}),
-    {filename: __filename, src: source}
-  );
+  const ast = parse(lex(source, {filename: __filename}), {
+    filename: __filename,
+    src: source,
+  });
 
   const options = {};
   const aliases = {
-    'minify': 'uglify-js',
+    minify: 'uglify-js',
   };
 
   const output = handleFilters(ast, customFilters, options, aliases);
@@ -35,15 +35,15 @@ script
     }
   `;
 
-  const ast = parse(
-    lex(source, {filename: __filename}),
-    {filename: __filename, src: source}
-  );
+  const ast = parse(lex(source, {filename: __filename}), {
+    filename: __filename,
+    src: source,
+  });
 
   const options = {};
   const aliases = {
     'minify-js': 'minify',
-    'minify': 'uglify-js',
+    minify: 'uglify-js',
   };
 
   try {
@@ -71,17 +71,16 @@ script
     }
   `;
 
-  const ast = parse(
-    lex(source, {filename: __filename}),
-    {filename: __filename, src: source}
-  );
-
+  const ast = parse(lex(source, {filename: __filename}), {
+    filename: __filename,
+    src: source,
+  });
 
   const options = {
-    'minify': {output: {beautify: true}},
+    minify: {output: {beautify: true}},
   };
   const aliases = {
-    'minify': 'uglify-js',
+    minify: 'uglify-js',
   };
 
   const output = handleFilters(ast, customFilters, options, aliases);
diff --git a/packages/pug-filters/test/index.test.js b/packages/pug-filters/test/index.test.js
index 01115ab41..d1369b586 100644
--- a/packages/pug-filters/test/index.test.js
+++ b/packages/pug-filters/test/index.test.js
@@ -9,31 +9,35 @@ process.chdir(__dirname + '/../');
 
 var testCases;
 
-testCases = fs.readdirSync(__dirname + '/cases').filter(function (name) {
+testCases = fs.readdirSync(__dirname + '/cases').filter(function(name) {
   return /\.input\.json$/.test(name);
 });
 //
-testCases.forEach(function (filename) {
-  function read (path) {
+testCases.forEach(function(filename) {
+  function read(path) {
     return fs.readFileSync(__dirname + '/cases/' + path, 'utf8');
   }
 
-  test('cases/' + filename, function () {
-    var actualAst = JSON.stringify(handleFilters(JSON.parse(read(filename)), customFilters), null, '  ');
+  test('cases/' + filename, function() {
+    var actualAst = JSON.stringify(
+      handleFilters(JSON.parse(read(filename)), customFilters),
+      null,
+      '  '
+    );
     expect(actualAst).toMatchSnapshot();
-  })
+  });
 });
 
-testCases = fs.readdirSync(__dirname + '/errors').filter(function (name) {
+testCases = fs.readdirSync(__dirname + '/errors').filter(function(name) {
   return /\.input\.json$/.test(name);
 });
 
-testCases.forEach(function (filename) {
-  function read (path) {
+testCases.forEach(function(filename) {
+  function read(path) {
     return fs.readFileSync(__dirname + '/errors/' + path, 'utf8');
   }
 
-  test('errors/' + filename, function () {
+  test('errors/' + filename, function() {
     var actual;
     try {
       handleFilters(JSON.parse(read(filename)), customFilters);
@@ -43,9 +47,9 @@ testCases.forEach(function (filename) {
       actual = {
         msg: ex.msg,
         code: ex.code,
-        line: ex.line
+        line: ex.line,
       };
     }
     expect(actual).toMatchSnapshot();
-  })
+  });
 });
diff --git a/packages/pug-filters/test/per-filter-options-applied-to-nested-filters.test.js b/packages/pug-filters/test/per-filter-options-applied-to-nested-filters.test.js
index 8c615c08e..30593b574 100644
--- a/packages/pug-filters/test/per-filter-options-applied-to-nested-filters.test.js
+++ b/packages/pug-filters/test/per-filter-options-applied-to-nested-filters.test.js
@@ -12,10 +12,10 @@ script
     }
   `;
 
-  const ast = parse(
-    lex(source, {filename: __filename}),
-    {filename: __filename, src: source}
-  );
+  const ast = parse(lex(source, {filename: __filename}), {
+    filename: __filename,
+    src: source,
+  });
 
   const options = {
     'uglify-js': {output: {beautify: true}},
diff --git a/packages/pug-filters/test/update-test-cases.js b/packages/pug-filters/test/update-test-cases.js
index e97423f3e..6e90996fb 100644
--- a/packages/pug-filters/test/update-test-cases.js
+++ b/packages/pug-filters/test/update-test-cases.js
@@ -9,11 +9,11 @@ var parse = require('pug-parser');
 var handleFilters = require('../').handleFilters;
 var customFilters = require('./custom-filters.js');
 
-var existing = fs.readdirSync(__dirname + '/cases').filter(function (name) {
+var existing = fs.readdirSync(__dirname + '/cases').filter(function(name) {
   return /\.input\.json$/.test(name);
 });
 
-function getError (input, filename) {
+function getError(input, filename) {
   try {
     handleFilters(input, customFilters);
     throw new Error('Expected ' + filename + ' to throw an exception.');
@@ -22,110 +22,165 @@ function getError (input, filename) {
     return {
       msg: ex.msg,
       code: ex.code,
-      line: ex.line
+      line: ex.line,
     };
   }
 }
 
-getRepo('pugjs', 'pug-parser').on('data', function (entry) {
-  var match;
-  if (entry.type === 'File' && (match = /^\/test\/cases\/(filters.*)\.expected\.json$/.exec(entry.path))) {
-    var name = match[1];
-    var filename = name + '.input.json';
-    var alreadyExists = false;
-    existing = existing.filter(function (existingName) {
-      if (existingName === filename) {
-        alreadyExists = true;
-        return false;
-      }
-      return true;
-    });
-    if (alreadyExists) {
-      var actualInputAst = getLoadedAst(entry.body.toString('utf8'));
-      try {
-        var expectedInputAst = JSON.parse(fs.readFileSync(__dirname + '/cases/' + filename, 'utf8'));
-        assert.deepEqual(expectedInputAst, actualInputAst);
-      } catch (ex) {
-        console.log('update: ' + filename);
-        fs.writeFileSync(__dirname + '/cases/' + filename, JSON.stringify(actualInputAst, null, '  '));
-      }
+getRepo('pugjs', 'pug-parser')
+  .on('data', function(entry) {
+    var match;
+    if (
+      entry.type === 'File' &&
+      (match = /^\/test\/cases\/(filters.*)\.expected\.json$/.exec(entry.path))
+    ) {
+      var name = match[1];
+      var filename = name + '.input.json';
+      var alreadyExists = false;
+      existing = existing.filter(function(existingName) {
+        if (existingName === filename) {
+          alreadyExists = true;
+          return false;
+        }
+        return true;
+      });
+      if (alreadyExists) {
+        var actualInputAst = getLoadedAst(entry.body.toString('utf8'));
+        try {
+          var expectedInputAst = JSON.parse(
+            fs.readFileSync(__dirname + '/cases/' + filename, 'utf8')
+          );
+          assert.deepEqual(expectedInputAst, actualInputAst);
+        } catch (ex) {
+          console.log('update: ' + filename);
+          fs.writeFileSync(
+            __dirname + '/cases/' + filename,
+            JSON.stringify(actualInputAst, null, '  ')
+          );
+        }
 
-      var actualAstStr = JSON.stringify(handleFilters(actualInputAst, customFilters), null, '  ');
-      try {
-        var expectedAstStr = fs.readFileSync(__dirname + '/cases/' + name + '.expected.json', 'utf8');
-        assert.equal(actualAstStr, expectedAstStr);
-      } catch (ex) {
-        console.log('update: ' + name + '.expected.json');
-        fs.writeFileSync(__dirname + '/cases/' + name + '.expected.json', actualAstStr);
+        var actualAstStr = JSON.stringify(
+          handleFilters(actualInputAst, customFilters),
+          null,
+          '  '
+        );
+        try {
+          var expectedAstStr = fs.readFileSync(
+            __dirname + '/cases/' + name + '.expected.json',
+            'utf8'
+          );
+          assert.equal(actualAstStr, expectedAstStr);
+        } catch (ex) {
+          console.log('update: ' + name + '.expected.json');
+          fs.writeFileSync(
+            __dirname + '/cases/' + name + '.expected.json',
+            actualAstStr
+          );
+        }
+      } else {
+        console.log('create: ' + filename);
+        var inputAst = getLoadedAst(entry.body.toString('utf8'));
+        fs.writeFileSync(
+          __dirname + '/cases/' + filename,
+          JSON.stringify(inputAst, null, '  ')
+        );
+        console.log('create: ' + name + '.expected.json');
+        var ast = handleFilters(inputAst, customFilters);
+        fs.writeFileSync(
+          __dirname + '/cases/' + name + '.expected.json',
+          JSON.stringify(ast, null, '  ')
+        );
       }
-    } else {
-      console.log('create: ' + filename);
-      var inputAst = getLoadedAst(entry.body.toString('utf8'));
-      fs.writeFileSync(__dirname + '/cases/' + filename, JSON.stringify(inputAst, null, '  '));
-      console.log('create: ' + name + '.expected.json');
-      var ast = handleFilters(inputAst, customFilters);
-      fs.writeFileSync(__dirname + '/cases/' + name + '.expected.json', JSON.stringify(ast, null, '  '));
     }
-  }
-}).on('end', function () {
-  existing.forEach(function (file) {
-    fs.unlinkSync(__dirname + '/cases/' + file);
-  });
-  var existingErrors = fs.readdirSync(__dirname + '/errors').filter(function (name) {
-    return /\.input\.json$/.test(name);
-  });
-  var pugRe = /\.pug$/;
-  fs.readdirSync(__dirname + '/errors-src').forEach(function (name) {
-    if (!pugRe.test(name)) return;
-    name = name.replace(pugRe, '');
-    var filename = name + '.input.json';
-    var alreadyExists = false;
-    existingErrors = existingErrors.filter(function (existingName) {
-      if (existingName === filename) {
-        alreadyExists = true;
-        return false;
-      }
-      return true;
+  })
+  .on('end', function() {
+    existing.forEach(function(file) {
+      fs.unlinkSync(__dirname + '/cases/' + file);
     });
-    if (alreadyExists) {
-      var actualTokens = parse(lex(fs.readFileSync(__dirname + '/errors-src/' + name + '.pug', 'utf8')));
-      try {
-        var expectedTokens = JSON.parse(fs.readFileSync(__dirname + '/errors/' + filename, 'utf8'));
-        assert.deepEqual(actualTokens, expectedTokens);
-      } catch (ex) {
-        console.log('update: ' + filename);
-        fs.writeFileSync(__dirname + '/errors/' + filename, JSON.stringify(actualTokens, null, '  '));
+    var existingErrors = fs
+      .readdirSync(__dirname + '/errors')
+      .filter(function(name) {
+        return /\.input\.json$/.test(name);
+      });
+    var pugRe = /\.pug$/;
+    fs.readdirSync(__dirname + '/errors-src').forEach(function(name) {
+      if (!pugRe.test(name)) return;
+      name = name.replace(pugRe, '');
+      var filename = name + '.input.json';
+      var alreadyExists = false;
+      existingErrors = existingErrors.filter(function(existingName) {
+        if (existingName === filename) {
+          alreadyExists = true;
+          return false;
+        }
+        return true;
+      });
+      if (alreadyExists) {
+        var actualTokens = parse(
+          lex(
+            fs.readFileSync(__dirname + '/errors-src/' + name + '.pug', 'utf8')
+          )
+        );
+        try {
+          var expectedTokens = JSON.parse(
+            fs.readFileSync(__dirname + '/errors/' + filename, 'utf8')
+          );
+          assert.deepEqual(actualTokens, expectedTokens);
+        } catch (ex) {
+          console.log('update: ' + filename);
+          fs.writeFileSync(
+            __dirname + '/errors/' + filename,
+            JSON.stringify(actualTokens, null, '  ')
+          );
+        }
+        var actual = getError(actualTokens, filename);
+        try {
+          var expected = JSON.parse(
+            fs.readFileSync(
+              __dirname + '/errors/' + name + '.expected.json',
+              'utf8'
+            )
+          );
+          assert.deepEqual(actual, expected);
+        } catch (ex) {
+          console.log('update: ' + name + '.expected.json');
+          fs.writeFileSync(
+            __dirname + '/errors/' + name + '.expected.json',
+            JSON.stringify(actual, null, '  ')
+          );
+        }
+      } else {
+        console.log('create: ' + filename);
+        var ast = parse(
+          lex(
+            fs.readFileSync(__dirname + '/errors-src/' + name + '.pug', 'utf8')
+          )
+        );
+        fs.writeFileSync(
+          __dirname + '/errors/' + filename,
+          JSON.stringify(ast, null, 2)
+        );
+        console.log('create: ' + name + '.expected.json');
+        var actual = getError(ast, filename);
+        fs.writeFileSync(
+          __dirname + '/errors/' + name + '.expected.json',
+          JSON.stringify(actual, null, '  ')
+        );
       }
-      var actual = getError(actualTokens, filename);
-      try {
-        var expected = JSON.parse(fs.readFileSync(__dirname + '/errors/' + name + '.expected.json', 'utf8'));
-        assert.deepEqual(actual, expected);
-      } catch (ex) {
-        console.log('update: ' + name + '.expected.json');
-        fs.writeFileSync(__dirname + '/errors/' + name + '.expected.json', JSON.stringify(actual, null, '  '));
-      }
-    } else {
-      console.log('create: ' + filename);
-      var ast = parse(lex(fs.readFileSync(__dirname + '/errors-src/' + name + '.pug', 'utf8')));
-      fs.writeFileSync(__dirname + '/errors/' + filename, JSON.stringify(ast, null, 2));
-      console.log('create: ' + name + '.expected.json');
-      var actual = getError(ast, filename);
-      fs.writeFileSync(__dirname + '/errors/' + name + '.expected.json', JSON.stringify(actual, null, '  '));
-    }
+    });
+    console.log('test cases updated');
   });
-  console.log('test cases updated');
-});
 
 function getLoadedAst(str) {
   return load(JSON.parse(str), {
-    lex: function () {
+    lex: function() {
       throw new Error('The lexer should not be used');
     },
-    parse: function () {
+    parse: function() {
       throw new Error('The parser should not be used');
     },
-    resolve: function (filename, source, options) {
+    resolve: function(filename, source, options) {
       return 'test/cases/' + filename.trim();
-    }
+    },
   });
 }
diff --git a/packages/pug-lexer/index.js b/packages/pug-lexer/index.js
index 9f84f2d7c..671e96408 100644
--- a/packages/pug-lexer/index.js
+++ b/packages/pug-lexer/index.js
@@ -23,10 +23,14 @@ function lex(str, options) {
 function Lexer(str, options) {
   options = options || {};
   if (typeof str !== 'string') {
-    throw new Error('Expected source code to be a string but got "' + (typeof str) + '"')
+    throw new Error(
+      'Expected source code to be a string but got "' + typeof str + '"'
+    );
   }
   if (typeof options !== 'object') {
-    throw new Error('Expected "options" to be an object but got "' + (typeof options) + '"')
+    throw new Error(
+      'Expected "options" to be an object but got "' + typeof options + '"'
+    );
   }
   //Strip any UTF-8 BOM off of the start of `str`, if it exists.
   str = str.replace(/^\uFEFF/, '');
@@ -45,32 +49,36 @@ function Lexer(str, options) {
 
   this.tokens = [];
   this.ended = false;
-};
+}
 
 /**
  * Lexer prototype.
  */
 
 Lexer.prototype = {
-
   constructor: Lexer,
 
-  error: function (code, message) {
-    var err = error(code, message, {line: this.lineno, column: this.colno, filename: this.filename, src: this.originalInput});
+  error: function(code, message) {
+    var err = error(code, message, {
+      line: this.lineno,
+      column: this.colno,
+      filename: this.filename,
+      src: this.originalInput,
+    });
     throw err;
   },
 
-  assert: function (value, message) {
+  assert: function(value, message) {
     if (!value) this.error('ASSERT_FAILED', message);
   },
 
-  isExpression: function (exp) {
+  isExpression: function(exp) {
     return isExpression(exp, {
-      throw: true
+      throw: true,
     });
   },
 
-  assertExpression: function (exp, noThrow) {
+  assertExpression: function(exp, noThrow) {
     //this verifies that a JavaScript expression is valid
     try {
       this.callLexerFunction('isExpression', exp);
@@ -83,17 +91,21 @@ Lexer.prototype = {
 
       this.incrementLine(ex.loc.line - 1);
       this.incrementColumn(ex.loc.column);
-      var msg = 'Syntax Error: ' + ex.message.replace(/ \([0-9]+:[0-9]+\)$/, '');
+      var msg =
+        'Syntax Error: ' + ex.message.replace(/ \([0-9]+:[0-9]+\)$/, '');
       this.error('SYNTAX_ERROR', msg);
     }
   },
 
-  assertNestingCorrect: function (exp) {
+  assertNestingCorrect: function(exp) {
     //this verifies that code is properly nested, but allows
     //invalid JavaScript such as the contents of `attributes`
-    var res = characterParser(exp)
+    var res = characterParser(exp);
     if (res.isNesting()) {
-      this.error('INCORRECT_NESTING', 'Nesting must match on expression `' + exp + '`')
+      this.error(
+        'INCORRECT_NESTING',
+        'Nesting must match on expression `' + exp + '`'
+      );
     }
   },
 
@@ -106,35 +118,35 @@ Lexer.prototype = {
    * @api private
    */
 
-  tok: function(type, val){
+  tok: function(type, val) {
     var res = {
-      type: type, 
+      type: type,
       loc: {
         start: {
-          line: this.lineno, 
-          column: this.colno
+          line: this.lineno,
+          column: this.colno,
         },
-        filename: this.filename
-      }
+        filename: this.filename,
+      },
     };
 
     if (val !== undefined) res.val = val;
 
     return res;
   },
-  
+
   /**
    * Set the token's `loc.end` value.
-   * 
+   *
    * @param {Object} tok
    * @returns {Object}
    * @api private
    */
-  
-  tokEnd: function(tok){
+
+  tokEnd: function(tok) {
     tok.loc.end = {
       line: this.lineno,
-      column: this.colno
+      column: this.colno,
     };
     return tok;
   },
@@ -146,7 +158,7 @@ Lexer.prototype = {
    * @api private
    */
 
-  incrementLine: function(increment){
+  incrementLine: function(increment) {
     this.lineno += increment;
     if (increment) this.colno = 1;
   },
@@ -158,8 +170,8 @@ Lexer.prototype = {
    * @api private
    */
 
-  incrementColumn: function(increment){
-    this.colno += increment
+  incrementColumn: function(increment) {
+    this.colno += increment;
   },
 
   /**
@@ -169,7 +181,7 @@ Lexer.prototype = {
    * @api private
    */
 
-  consume: function(len){
+  consume: function(len) {
     this.input = this.input.substr(len);
   },
 
@@ -182,9 +194,9 @@ Lexer.prototype = {
    * @api private
    */
 
-  scan: function(regexp, type){
+  scan: function(regexp, type) {
     var captures;
-    if (captures = regexp.exec(this.input)) {
+    if ((captures = regexp.exec(this.input))) {
       var len = captures[0].length;
       var val = captures[1];
       var diff = len - (val ? val.length : 0);
@@ -194,13 +206,13 @@ Lexer.prototype = {
       return tok;
     }
   },
-  scanEndOfLine: function (regexp, type) {
+  scanEndOfLine: function(regexp, type) {
     var captures;
-    if (captures = regexp.exec(this.input)) {
+    if ((captures = regexp.exec(this.input))) {
       var whitespaceLength = 0;
       var whitespace;
       var tok;
-      if (whitespace = /^([ ]+)([^ ]*)/.exec(captures[0])) {
+      if ((whitespace = /^([ ]+)([^ ]*)/.exec(captures[0]))) {
         whitespaceLength = whitespace[1].length;
         this.incrementColumn(whitespaceLength);
       }
@@ -230,11 +242,13 @@ Lexer.prototype = {
    * @api private
    */
 
-  bracketExpression: function(skip){
+  bracketExpression: function(skip) {
     skip = skip || 0;
     var start = this.input[skip];
-    assert(start === '(' || start === '{' || start === '[',
-           'The start character should be "(", "{" or "["');
+    assert(
+      start === '(' || start === '{' || start === '[',
+      'The start character should be "(", "{" or "["'
+    );
     var end = characterParser.BRACKETS[start];
     var range;
     try {
@@ -252,12 +266,17 @@ Lexer.prototype = {
           idx -= nextNewline + 1;
           ptr += nextNewline + 1;
           tmp = nextNewline = this.input.substr(ptr).indexOf('\n');
-        };
+        }
 
         this.incrementColumn(idx);
       }
       if (ex.code === 'CHARACTER_PARSER:END_OF_STRING_REACHED') {
-        this.error('NO_END_BRACKET', 'The end of the string reached with no closing bracket ' + end + ' found.');
+        this.error(
+          'NO_END_BRACKET',
+          'The end of the string reached with no closing bracket ' +
+            end +
+            ' found.'
+        );
       } else if (ex.code === 'CHARACTER_PARSER:MISMATCHED_BRACKET') {
         this.error('BRACKET_MISMATCH', ex.message);
       }
@@ -272,7 +291,7 @@ Lexer.prototype = {
     // established regexp
     if (this.indentRe) {
       captures = this.indentRe.exec(this.input);
-    // determine regexp
+      // determine regexp
     } else {
       // tabs
       re = /^\n(\t*) */;
@@ -298,7 +317,10 @@ Lexer.prototype = {
   eos: function() {
     if (this.input.length) return;
     if (this.interpolated) {
-      this.error('NO_END_BRACKET', 'End of line was reached with no closing bracket for interpolation.');
+      this.error(
+        'NO_END_BRACKET',
+        'End of line was reached with no closing bracket for interpolation.'
+      );
     }
     for (var i = 0; this.indentStack[i]; i++) {
       this.tokens.push(this.tokEnd(this.tok('outdent')));
@@ -314,7 +336,7 @@ Lexer.prototype = {
 
   blank: function() {
     var captures;
-    if (captures = /^\n[ \t]*\n/.exec(this.input)) {
+    if ((captures = /^\n[ \t]*\n/.exec(this.input))) {
       this.consume(captures[0].length - 1);
       this.incrementLine(1);
       return true;
@@ -327,7 +349,7 @@ Lexer.prototype = {
 
   comment: function() {
     var captures;
-    if (captures = /^\/\/(-)?([^\n]*)/.exec(this.input)) {
+    if ((captures = /^\/\/(-)?([^\n]*)/.exec(this.input))) {
       this.consume(captures[0].length);
       var tok = this.tok('comment', captures[2]);
       tok.buffer = '-' != captures[1];
@@ -369,8 +391,10 @@ Lexer.prototype = {
   tag: function() {
     var captures;
 
-    if (captures = /^(\w(?:[-:\w]*\w)?)/.exec(this.input)) {
-      var tok, name = captures[1], len = captures[0].length;
+    if ((captures = /^(\w(?:[-:\w]*\w)?)/.exec(this.input))) {
+      var tok,
+        name = captures[1],
+        len = captures[0].length;
       this.consume(len);
       tok = this.tok('tag', name);
       this.tokens.push(tok);
@@ -425,7 +449,12 @@ Lexer.prototype = {
       return true;
     }
     if (/^#/.test(this.input)) {
-      this.error('INVALID_ID', '"' + /.[^ \t\(\#\.\:]*/.exec(this.input.substr(1))[0] + '" is not a valid ID.');
+      this.error(
+        'INVALID_ID',
+        '"' +
+          /.[^ \t\(\#\.\:]*/.exec(this.input.substr(1))[0] +
+          '" is not a valid ID.'
+      );
     }
   },
 
@@ -442,24 +471,32 @@ Lexer.prototype = {
       return true;
     }
     if (/^\.[_a-z0-9\-]+/i.test(this.input)) {
-      this.error('INVALID_CLASS_NAME', 'Class names must contain at least one letter or underscore.');
+      this.error(
+        'INVALID_CLASS_NAME',
+        'Class names must contain at least one letter or underscore.'
+      );
     }
     if (/^\./.test(this.input)) {
-      this.error('INVALID_CLASS_NAME', '"' + /.[^ \t\(\#\.\:]*/.exec(this.input.substr(1))[0] + '" is not a valid class name.  Class names can only contain "_", "-", a-z and 0-9, and must contain at least one of "_", or a-z');
+      this.error(
+        'INVALID_CLASS_NAME',
+        '"' +
+          /.[^ \t\(\#\.\:]*/.exec(this.input.substr(1))[0] +
+          '" is not a valid class name.  Class names can only contain "_", "-", a-z and 0-9, and must contain at least one of "_", or a-z'
+      );
     }
   },
 
   /**
    * Text.
    */
-  endInterpolation: function () {
+  endInterpolation: function() {
     if (this.interpolated && this.input[0] === ']') {
       this.input = this.input.substr(1);
       this.ended = true;
       return true;
     }
   },
-  addText: function (type, value, prefix, escaped) {
+  addText: function(type, value, prefix, escaped) {
     var tok;
     if (value + prefix === '') return;
     prefix = prefix || '';
@@ -468,17 +505,35 @@ Lexer.prototype = {
     var indexOfStart = this.interpolationAllowed ? value.indexOf('#[') : -1;
     var indexOfEscaped = this.interpolationAllowed ? value.indexOf('\\#[') : -1;
     var matchOfStringInterp = /(\\)?([#!]){((?:.|\n)*)$/.exec(value);
-    var indexOfStringInterp = this.interpolationAllowed && matchOfStringInterp ? matchOfStringInterp.index : Infinity;
+    var indexOfStringInterp =
+      this.interpolationAllowed && matchOfStringInterp
+        ? matchOfStringInterp.index
+        : Infinity;
 
     if (indexOfEnd === -1) indexOfEnd = Infinity;
     if (indexOfStart === -1) indexOfStart = Infinity;
     if (indexOfEscaped === -1) indexOfEscaped = Infinity;
 
-    if (indexOfEscaped !== Infinity && indexOfEscaped < indexOfEnd && indexOfEscaped < indexOfStart && indexOfEscaped < indexOfStringInterp) {
+    if (
+      indexOfEscaped !== Infinity &&
+      indexOfEscaped < indexOfEnd &&
+      indexOfEscaped < indexOfStart &&
+      indexOfEscaped < indexOfStringInterp
+    ) {
       prefix = prefix + value.substring(0, indexOfEscaped) + '#[';
-      return this.addText(type, value.substring(indexOfEscaped + 3), prefix, escaped + 1);
+      return this.addText(
+        type,
+        value.substring(indexOfEscaped + 3),
+        prefix,
+        escaped + 1
+      );
     }
-    if (indexOfStart !== Infinity && indexOfStart < indexOfEnd && indexOfStart < indexOfEscaped && indexOfStart < indexOfStringInterp) {
+    if (
+      indexOfStart !== Infinity &&
+      indexOfStart < indexOfEnd &&
+      indexOfStart < indexOfEscaped &&
+      indexOfStart < indexOfStringInterp
+    ) {
       tok = this.tok(type, prefix + value.substring(0, indexOfStart));
       this.incrementColumn(prefix.length + indexOfStart + escaped);
       this.tokens.push(this.tokEnd(tok));
@@ -489,7 +544,7 @@ Lexer.prototype = {
         filename: this.filename,
         interpolated: true,
         startingLine: this.lineno,
-        startingColumn: this.colno
+        startingColumn: this.colno,
       });
       var interpolated;
       try {
@@ -509,7 +564,12 @@ Lexer.prototype = {
       this.addText(type, child.input);
       return;
     }
-    if (indexOfEnd !== Infinity && indexOfEnd < indexOfStart && indexOfEnd < indexOfEscaped && indexOfEnd < indexOfStringInterp) {
+    if (
+      indexOfEnd !== Infinity &&
+      indexOfEnd < indexOfStart &&
+      indexOfEnd < indexOfEscaped &&
+      indexOfEnd < indexOfStringInterp
+    ) {
       if (prefix + value.substring(0, indexOfEnd)) {
         this.addText(type, value.substring(0, indexOfEnd), prefix);
       }
@@ -520,7 +580,12 @@ Lexer.prototype = {
     if (indexOfStringInterp !== Infinity) {
       if (matchOfStringInterp[1]) {
         prefix = prefix + value.substring(0, indexOfStringInterp) + '#{';
-        return this.addText(type, value.substring(indexOfStringInterp + 3), prefix, escaped + 1);
+        return this.addText(
+          type,
+          value.substring(indexOfStringInterp + 3),
+          prefix,
+          escaped + 1
+        );
       }
       var before = value.substr(0, indexOfStringInterp);
       if (prefix || before) {
@@ -541,7 +606,10 @@ Lexer.prototype = {
           this.incrementColumn(ex.index);
         }
         if (ex.code === 'CHARACTER_PARSER:END_OF_STRING_REACHED') {
-          this.error('NO_END_BRACKET', 'End of line was reached with no closing bracket for interpolation.');
+          this.error(
+            'NO_END_BRACKET',
+            'End of line was reached with no closing bracket for interpolation.'
+          );
         } else if (ex.code === 'CHARACTER_PARSER:MISMATCHED_BRACKET') {
           this.error('BRACKET_MISMATCH', ex.message);
         } else {
@@ -572,7 +640,8 @@ Lexer.prototype = {
   },
 
   text: function() {
-    var tok = this.scan(/^(?:\| ?| )([^\n]+)/, 'text') ||
+    var tok =
+      this.scan(/^(?:\| ?| )([^\n]+)/, 'text') ||
       this.scan(/^( )/, 'text') ||
       this.scan(/^\|( ?)/, 'text');
     if (tok) {
@@ -581,7 +650,7 @@ Lexer.prototype = {
     }
   },
 
-  textHtml: function () {
+  textHtml: function() {
     var tok = this.scan(/^(<[^\n]*)/, 'text-html');
     if (tok) {
       this.addText('text-html', tok.val);
@@ -595,7 +664,7 @@ Lexer.prototype = {
 
   dot: function() {
     var tok;
-    if (tok = this.scanEndOfLine(/^\./, 'dot')) {
+    if ((tok = this.scanEndOfLine(/^\./, 'dot'))) {
       this.tokens.push(this.tokEnd(tok));
       this.callLexerFunction('pipelessText');
       return true;
@@ -606,7 +675,7 @@ Lexer.prototype = {
    * Extends.
    */
 
-  "extends": function() {
+  extends: function() {
     var tok = this.scan(/^extends?(?= |$|\n)/, 'extends');
     if (tok) {
       this.tokens.push(this.tokEnd(tok));
@@ -626,17 +695,22 @@ Lexer.prototype = {
 
   prepend: function() {
     var captures;
-    if (captures = /^(?:block +)?prepend +([^\n]+)/.exec(this.input)) {
+    if ((captures = /^(?:block +)?prepend +([^\n]+)/.exec(this.input))) {
       var name = captures[1].trim();
       var comment = '';
       if (name.indexOf('//') !== -1) {
-        comment = '//' + name.split('//').slice(1).join('//');
+        comment =
+          '//' +
+          name
+            .split('//')
+            .slice(1)
+            .join('//');
         name = name.split('//')[0].trim();
       }
       if (!name) return;
       var tok = this.tok('block', name);
       var len = captures[0].length - comment.length;
-      while(this.whitespaceRe.test(this.input.charAt(len - 1))) len--;
+      while (this.whitespaceRe.test(this.input.charAt(len - 1))) len--;
       this.incrementColumn(len);
       tok.mode = 'prepend';
       this.tokens.push(this.tokEnd(tok));
@@ -652,17 +726,22 @@ Lexer.prototype = {
 
   append: function() {
     var captures;
-    if (captures = /^(?:block +)?append +([^\n]+)/.exec(this.input)) {
+    if ((captures = /^(?:block +)?append +([^\n]+)/.exec(this.input))) {
       var name = captures[1].trim();
       var comment = '';
       if (name.indexOf('//') !== -1) {
-        comment = '//' + name.split('//').slice(1).join('//');
+        comment =
+          '//' +
+          name
+            .split('//')
+            .slice(1)
+            .join('//');
         name = name.split('//')[0].trim();
       }
       if (!name) return;
       var tok = this.tok('block', name);
       var len = captures[0].length - comment.length;
-      while(this.whitespaceRe.test(this.input.charAt(len - 1))) len--;
+      while (this.whitespaceRe.test(this.input.charAt(len - 1))) len--;
       this.incrementColumn(len);
       tok.mode = 'append';
       this.tokens.push(this.tokEnd(tok));
@@ -678,17 +757,22 @@ Lexer.prototype = {
 
   block: function() {
     var captures;
-    if (captures = /^block +([^\n]+)/.exec(this.input)) {
+    if ((captures = /^block +([^\n]+)/.exec(this.input))) {
       var name = captures[1].trim();
       var comment = '';
       if (name.indexOf('//') !== -1) {
-        comment = '//' + name.split('//').slice(1).join('//');
+        comment =
+          '//' +
+          name
+            .split('//')
+            .slice(1)
+            .join('//');
         name = name.split('//')[0].trim();
       }
       if (!name) return;
       var tok = this.tok('block', name);
       var len = captures[0].length - comment.length;
-      while(this.whitespaceRe.test(this.input.charAt(len - 1))) len--;
+      while (this.whitespaceRe.test(this.input.charAt(len - 1))) len--;
       this.incrementColumn(len);
       tok.mode = 'replace';
       this.tokens.push(this.tokEnd(tok));
@@ -704,7 +788,7 @@ Lexer.prototype = {
 
   mixinBlock: function() {
     var tok;
-    if (tok = this.scanEndOfLine(/^block/, 'mixin-block')) {
+    if ((tok = this.scanEndOfLine(/^block/, 'mixin-block'))) {
       this.tokens.push(this.tokEnd(tok));
       return true;
     }
@@ -714,7 +798,7 @@ Lexer.prototype = {
    * Yield.
    */
 
-  'yield': function() {
+  yield: function() {
     var tok = this.scanEndOfLine(/^yield/, 'yield');
     if (tok) {
       this.tokens.push(this.tokEnd(tok));
@@ -730,7 +814,7 @@ Lexer.prototype = {
     var tok = this.scan(/^include(?=:| |$|\n)/, 'include');
     if (tok) {
       this.tokens.push(this.tokEnd(tok));
-      while (this.callLexerFunction('filter', { inInclude: true }));
+      while (this.callLexerFunction('filter', {inInclude: true}));
       if (!this.callLexerFunction('path')) {
         if (/^[^ \n]+/.test(this.input)) {
           // if there is more text
@@ -763,7 +847,7 @@ Lexer.prototype = {
    * Case.
    */
 
-  "case": function() {
+  case: function() {
     var tok = this.scanEndOfLine(/^case +([^\n]+)/, 'case');
     if (tok) {
       this.incrementColumn(-tok.val.length);
@@ -810,14 +894,17 @@ Lexer.prototype = {
    * Default.
    */
 
-  "default": function() {
+  default: function() {
     var tok = this.scanEndOfLine(/^default/, 'default');
     if (tok) {
       this.tokens.push(this.tokEnd(tok));
       return true;
     }
     if (this.scan(/^default\b/)) {
-      this.error('DEFAULT_WITH_EXPRESSION', 'default should not have an expression');
+      this.error(
+        'DEFAULT_WITH_EXPRESSION',
+        'default should not have an expression'
+      );
     }
   },
 
@@ -825,10 +912,9 @@ Lexer.prototype = {
    * Call mixin.
    */
 
-  call: function(){
-
+  call: function() {
     var tok, captures, increment;
-    if (captures = /^\+(\s*)(([-\w]+)|(#\{))/.exec(this.input)) {
+    if ((captures = /^\+(\s*)(([-\w]+)|(#\{))/.exec(this.input))) {
       // try to consume simple or interpolated call
       if (captures[3]) {
         // simple call
@@ -841,16 +927,17 @@ Lexer.prototype = {
         increment = match.end + 1;
         this.consume(increment);
         this.assertExpression(match.src);
-        tok = this.tok('call', '#{'+match.src+'}');
+        tok = this.tok('call', '#{' + match.src + '}');
       }
 
       this.incrementColumn(increment);
 
       tok.args = null;
       // Check for args (not attributes)
-      if (captures = /^ *\(/.exec(this.input)) {
+      if ((captures = /^ *\(/.exec(this.input))) {
         var range = this.bracketExpression(captures[0].length - 1);
-        if (!/^\s*[-\w]+ *=/.test(range.src)) { // not attributes
+        if (!/^\s*[-\w]+ *=/.test(range.src)) {
+          // not attributes
           this.incrementColumn(1);
           this.consume(range.end + 1);
           tok.args = range.src;
@@ -873,9 +960,9 @@ Lexer.prototype = {
    * Mixin.
    */
 
-  mixin: function(){
+  mixin: function() {
     var captures;
-    if (captures = /^mixin +([-\w]+)(?: *\((.*)\))? */.exec(this.input)) {
+    if ((captures = /^mixin +([-\w]+)(?: *\((.*)\))? */.exec(this.input))) {
       this.consume(captures[0].length);
       var tok = this.tok('mixin', captures[1]);
       tok.args = captures[2] || null;
@@ -891,7 +978,7 @@ Lexer.prototype = {
 
   conditional: function() {
     var captures;
-    if (captures = /^(if|unless|else if|else)\b([^\n]*)/.exec(this.input)) {
+    if ((captures = /^(if|unless|else if|else)\b([^\n]*)/.exec(this.input))) {
       this.consume(captures[0].length);
       var type = captures[1].replace(/ /g, '-');
       var js = captures[2] && captures[2].trim();
@@ -928,9 +1015,9 @@ Lexer.prototype = {
    * While.
    */
 
-  "while": function() {
+  while: function() {
     var captures, tok;
-    if (captures = /^while +([^\n]+)/.exec(this.input)) {
+    if ((captures = /^while +([^\n]+)/.exec(this.input))) {
       this.consume(captures[0].length);
       this.assertExpression(captures[1]);
       tok = this.tok('while', captures[1]);
@@ -949,12 +1036,16 @@ Lexer.prototype = {
 
   each: function() {
     var captures;
-    if (captures = /^(?:each|for) +([a-zA-Z_$][\w$]*)(?: *, *([a-zA-Z_$][\w$]*))? * in *([^\n]+)/.exec(this.input)) {
+    if (
+      (captures = /^(?:each|for) +([a-zA-Z_$][\w$]*)(?: *, *([a-zA-Z_$][\w$]*))? * in *([^\n]+)/.exec(
+        this.input
+      ))
+    ) {
       this.consume(captures[0].length);
       var tok = this.tok('each', captures[1]);
       tok.key = captures[2] || null;
       this.incrementColumn(captures[0].length - captures[3].length);
-      this.assertExpression(captures[3])
+      this.assertExpression(captures[3]);
       tok.code = captures[3];
       this.incrementColumn(captures[3].length);
       this.tokens.push(this.tokEnd(tok));
@@ -963,7 +1054,11 @@ Lexer.prototype = {
     if (this.scan(/^(?:each|for)\b/)) {
       this.error('MALFORMED_EACH', 'malformed each');
     }
-    if (captures = /^- *(?:each|for) +([a-zA-Z_$][\w$]*)(?: *, *([a-zA-Z_$][\w$]*))? +in +([^\n]+)/.exec(this.input)) {
+    if (
+      (captures = /^- *(?:each|for) +([a-zA-Z_$][\w$]*)(?: *, *([a-zA-Z_$][\w$]*))? +in +([^\n]+)/.exec(
+        this.input
+      ))
+    ) {
       this.error(
         'MALFORMED_EACH',
         'Pug each and for should no longer be prefixed with a dash ("-"). They are pug keywords and not part of JavaScript.'
@@ -977,26 +1072,37 @@ Lexer.prototype = {
 
   eachOf: function() {
     var captures;
-    if (captures = /^(?:each|for) (.*) of *([^\n]+)/.exec(this.input)) {
+    if ((captures = /^(?:each|for) (.*) of *([^\n]+)/.exec(this.input))) {
       this.consume(captures[0].length);
       var tok = this.tok('eachOf', captures[1]);
       tok.value = captures[1];
       this.incrementColumn(captures[0].length - captures[2].length);
-      this.assertExpression(captures[2])
+      this.assertExpression(captures[2]);
       tok.code = captures[2];
       this.incrementColumn(captures[2].length);
       this.tokens.push(this.tokEnd(tok));
 
-      if (!(/^[a-zA-Z_$][\w$]*$/.test(tok.value.trim()) || /^\[ *[a-zA-Z_$][\w$]* *\, *[a-zA-Z_$][\w$]* *\]$/.test(tok.value.trim()))) {
+      if (
+        !(
+          /^[a-zA-Z_$][\w$]*$/.test(tok.value.trim()) ||
+          /^\[ *[a-zA-Z_$][\w$]* *\, *[a-zA-Z_$][\w$]* *\]$/.test(
+            tok.value.trim()
+          )
+        )
+      ) {
         this.error(
           'MALFORMED_EACH_OF_LVAL',
           'The value variable for each must either be a valid identifier (e.g. `item`) or a pair of identifiers in square brackets (e.g. `[key, value]`).'
         );
       }
-      
+
       return true;
     }
-    if (captures = /^- *(?:each|for) +([a-zA-Z_$][\w$]*)(?: *, *([a-zA-Z_$][\w$]*))? +of +([^\n]+)/.exec(this.input)) {
+    if (
+      (captures = /^- *(?:each|for) +([a-zA-Z_$][\w$]*)(?: *, *([a-zA-Z_$][\w$]*))? +of +([^\n]+)/.exec(
+        this.input
+      ))
+    ) {
       this.error(
         'MALFORMED_EACH',
         'Pug each and for should not be prefixed with a dash ("-"). They are pug keywords and not part of JavaScript.'
@@ -1010,7 +1116,7 @@ Lexer.prototype = {
 
   code: function() {
     var captures;
-    if (captures = /^(!?=|-)[ \t]*([^\n]+)/.exec(this.input)) {
+    if ((captures = /^(!?=|-)[ \t]*([^\n]+)/.exec(this.input))) {
       var flags = captures[1];
       var code = captures[2];
       var shortened = 0;
@@ -1023,7 +1129,10 @@ Lexer.prototype = {
             this.incrementColumn(captures[0].length - code.length + err.index);
           }
           if (err.code === 'CHARACTER_PARSER:END_OF_STRING_REACHED') {
-            this.error('NO_END_BRACKET', 'End of line was reached with no closing bracket for interpolation.');
+            this.error(
+              'NO_END_BRACKET',
+              'End of line was reached with no closing bracket for interpolation.'
+            );
           } else if (err.code === 'CHARACTER_PARSER:MISMATCHED_BRACKET') {
             this.error('BRACKET_MISMATCH', err.message);
           } else {
@@ -1077,75 +1186,79 @@ Lexer.prototype = {
    * Block code.
    */
   blockCode: function() {
-    var tok
-    if (tok = this.scanEndOfLine(/^-/, 'blockcode')) {
+    var tok;
+    if ((tok = this.scanEndOfLine(/^-/, 'blockcode'))) {
       this.tokens.push(this.tokEnd(tok));
       this.interpolationAllowed = false;
       this.callLexerFunction('pipelessText');
       return true;
     }
   },
-  
+
   /**
    * Attribute Name.
    */
-  attribute: function(str){
+  attribute: function(str) {
     var quote = '';
     var quoteRe = /['"]/;
     var key = '';
     var i;
-    
+
     // consume all whitespace before the key
-    for(i = 0; i < str.length; i++){
-      if(!this.whitespaceRe.test(str[i])) break;
-      if(str[i] === '\n'){
+    for (i = 0; i < str.length; i++) {
+      if (!this.whitespaceRe.test(str[i])) break;
+      if (str[i] === '\n') {
         this.incrementLine(1);
       } else {
         this.incrementColumn(1);
       }
     }
-    
-    if(i === str.length){
+
+    if (i === str.length) {
       return '';
     }
-    
+
     var tok = this.tok('attribute');
-    
+
     // quote?
-    if(quoteRe.test(str[i])){
+    if (quoteRe.test(str[i])) {
       quote = str[i];
       this.incrementColumn(1);
       i++;
     }
-    
+
     // start looping through the key
     for (; i < str.length; i++) {
-      
-      if(quote){
+      if (quote) {
         if (str[i] === quote) {
           this.incrementColumn(1);
           i++;
           break;
         }
       } else {
-        if(this.whitespaceRe.test(str[i]) || str[i] === '!' || str[i] === '=' || str[i] === ',') {
+        if (
+          this.whitespaceRe.test(str[i]) ||
+          str[i] === '!' ||
+          str[i] === '=' ||
+          str[i] === ','
+        ) {
           break;
         }
       }
-      
+
       key += str[i];
-        
+
       if (str[i] === '\n') {
         this.incrementLine(1);
       } else {
         this.incrementColumn(1);
       }
     }
-    
+
     tok.name = key;
-    
+
     var valueResponse = this.attributeValue(str.substr(i));
-    
+
     if (valueResponse.val) {
       tok.val = valueResponse.val;
       tok.mustEscape = valueResponse.mustEscape;
@@ -1154,34 +1267,34 @@ Lexer.prototype = {
       tok.val = true;
       tok.mustEscape = true;
     }
-    
+
     str = valueResponse.remainingSource;
-    
+
     this.tokens.push(this.tokEnd(tok));
-    
-    for(i = 0; i < str.length; i++){
-      if(!this.whitespaceRe.test(str[i])) {
+
+    for (i = 0; i < str.length; i++) {
+      if (!this.whitespaceRe.test(str[i])) {
         break;
       }
-      if(str[i] === '\n'){
+      if (str[i] === '\n') {
         this.incrementLine(1);
       } else {
         this.incrementColumn(1);
       }
     }
-    
-    if(str[i] === ','){
+
+    if (str[i] === ',') {
       this.incrementColumn(1);
       i++;
     }
-    
+
     return str.substr(i);
   },
-  
+
   /**
    * Attribute Value.
    */
-  attributeValue: function(str){
+  attributeValue: function(str) {
     var quoteRe = /['"]/;
     var val = '';
     var done, i, x;
@@ -1189,96 +1302,106 @@ Lexer.prototype = {
     var state = characterParser.defaultState();
     var col = this.colno;
     var line = this.lineno;
-    
+
     // consume all whitespace before the equals sign
-    for(i = 0; i < str.length; i++){
-      if(!this.whitespaceRe.test(str[i])) break;
-      if(str[i] === '\n'){
+    for (i = 0; i < str.length; i++) {
+      if (!this.whitespaceRe.test(str[i])) break;
+      if (str[i] === '\n') {
         line++;
         col = 1;
       } else {
         col++;
       }
     }
-    
-    if(i === str.length){
-      return { remainingSource: str };
+
+    if (i === str.length) {
+      return {remainingSource: str};
     }
-    
-    if(str[i] === '!'){
+
+    if (str[i] === '!') {
       escapeAttr = false;
       col++;
       i++;
-      if (str[i] !== '=') this.error('INVALID_KEY_CHARACTER', 'Unexpected character ' + str[i] + ' expected `=`');
+      if (str[i] !== '=')
+        this.error(
+          'INVALID_KEY_CHARACTER',
+          'Unexpected character ' + str[i] + ' expected `=`'
+        );
     }
-    
-    if(str[i] !== '='){
+
+    if (str[i] !== '=') {
       // check for anti-pattern `div("foo"bar)`
-      if (i === 0 && str && !this.whitespaceRe.test(str[0]) && str[0] !== ','){
-        this.error('INVALID_KEY_CHARACTER', 'Unexpected character ' + str[0] + ' expected `=`');
+      if (i === 0 && str && !this.whitespaceRe.test(str[0]) && str[0] !== ',') {
+        this.error(
+          'INVALID_KEY_CHARACTER',
+          'Unexpected character ' + str[0] + ' expected `=`'
+        );
       } else {
-        return { remainingSource: str };
+        return {remainingSource: str};
       }
     }
-    
+
     this.lineno = line;
     this.colno = col + 1;
     i++;
-    
+
     // consume all whitespace before the value
-    for(; i < str.length; i++){
-      if(!this.whitespaceRe.test(str[i])) break;
-      if(str[i] === '\n'){
+    for (; i < str.length; i++) {
+      if (!this.whitespaceRe.test(str[i])) break;
+      if (str[i] === '\n') {
         this.incrementLine(1);
       } else {
         this.incrementColumn(1);
       }
     }
-    
+
     line = this.lineno;
     col = this.colno;
-    
+
     // start looping through the value
     for (; i < str.length; i++) {
       // if the character is in a string or in parentheses/brackets/braces
-      if (!(state.isNesting() || state.isString())){
-        
+      if (!(state.isNesting() || state.isString())) {
         if (this.whitespaceRe.test(str[i])) {
           done = false;
-          
+
           // find the first non-whitespace character
           for (x = i; x < str.length; x++) {
             if (!this.whitespaceRe.test(str[x])) {
               // if it is a JavaScript punctuator, then assume that it is
               // a part of the value
-              const isNotPunctuator = !characterParser.isPunctuator(str[x])
-              const isQuote = quoteRe.test(str[x])
-              const isColon = str[x] === ':'
-              const isSpreadOperator = str[x] + str[x + 1] + str[x + 2] === '...'
-              if ((isNotPunctuator || isQuote || isColon || isSpreadOperator) && this.assertExpression(val, true)) {
+              const isNotPunctuator = !characterParser.isPunctuator(str[x]);
+              const isQuote = quoteRe.test(str[x]);
+              const isColon = str[x] === ':';
+              const isSpreadOperator =
+                str[x] + str[x + 1] + str[x + 2] === '...';
+              if (
+                (isNotPunctuator || isQuote || isColon || isSpreadOperator) &&
+                this.assertExpression(val, true)
+              ) {
                 done = true;
               }
               break;
             }
           }
-          
+
           // if everything else is whitespace, return now so last attribute
           // does not include trailing whitespace
-          if(done || x === str.length){
+          if (done || x === str.length) {
             break;
           }
         }
-        
+
         // if there's no whitespace and the character is not ',', the
         // attribute did not end.
-        if(str[i] === ',' && this.assertExpression(val, true)){
+        if (str[i] === ',' && this.assertExpression(val, true)) {
           break;
         }
       }
-      
+
       state = characterParser.parseChar(str[i], state);
       val += str[i];
-      
+
       if (str[i] === '\n') {
         line++;
         col = 1;
@@ -1286,33 +1409,33 @@ Lexer.prototype = {
         col++;
       }
     }
-    
+
     this.assertExpression(val);
-    
+
     this.lineno = line;
     this.colno = col;
-    
-    return { val: val, mustEscape: escapeAttr, remainingSource: str.substr(i) };
+
+    return {val: val, mustEscape: escapeAttr, remainingSource: str.substr(i)};
   },
 
   /**
    * Attributes.
    */
-  
+
   attrs: function() {
     var tok;
-    
+
     if ('(' == this.input.charAt(0)) {
       tok = this.tok('start-attributes');
       var index = this.bracketExpression().end;
-      var str = this.input.substr(1, index-1);
+      var str = this.input.substr(1, index - 1);
 
       this.incrementColumn(1);
       this.tokens.push(this.tokEnd(tok));
       this.assertNestingCorrect(str);
       this.consume(index + 1);
 
-      while(str){
+      while (str) {
         str = this.attribute(str);
       }
 
@@ -1326,7 +1449,7 @@ Lexer.prototype = {
   /**
    * &attributes block
    */
-  attributesBlock: function () {
+  attributesBlock: function() {
     if (/^&attributes\b/.test(this.input)) {
       var consumed = 11;
       this.consume(consumed);
@@ -1357,7 +1480,10 @@ Lexer.prototype = {
       this.consume(indents + 1);
 
       if (' ' == this.input[0] || '\t' == this.input[0]) {
-        this.error('INVALID_INDENTATION', 'Invalid indentation, you can use tabs or spaces but not both');
+        this.error(
+          'INVALID_INDENTATION',
+          'Invalid indentation, you can use tabs or spaces but not both'
+        );
       }
 
       // blank line
@@ -1371,24 +1497,31 @@ Lexer.prototype = {
         var outdent_count = 0;
         while (this.indentStack[0] > indents) {
           if (this.indentStack[1] < indents) {
-            this.error('INCONSISTENT_INDENTATION', 'Inconsistent indentation. Expecting either ' + this.indentStack[1] + ' or ' + this.indentStack[0] + ' spaces/tabs.');
+            this.error(
+              'INCONSISTENT_INDENTATION',
+              'Inconsistent indentation. Expecting either ' +
+                this.indentStack[1] +
+                ' or ' +
+                this.indentStack[0] +
+                ' spaces/tabs.'
+            );
           }
           outdent_count++;
           this.indentStack.shift();
         }
-        while(outdent_count--){
+        while (outdent_count--) {
           this.colno = 1;
           tok = this.tok('outdent');
           this.colno = this.indentStack[0] + 1;
           this.tokens.push(this.tokEnd(tok));
         }
-      // indent
+        // indent
       } else if (indents && indents != this.indentStack[0]) {
         tok = this.tok('indent', indents);
         this.colno = 1 + indents;
         this.tokens.push(this.tokEnd(tok));
         this.indentStack.unshift(indents);
-      // newline
+        // newline
       } else {
         tok = this.tok('newline');
         this.colno = 1 + Math.min(this.indentStack[0] || 0, indents);
@@ -1405,7 +1538,7 @@ Lexer.prototype = {
 
     var captures = this.scanIndentation();
 
-    indents = indents || captures && captures[1].length;
+    indents = indents || (captures && captures[1].length);
     if (indents > this.indentStack[0]) {
       this.tokens.push(this.tokEnd(this.tok('start-pipeless-text')));
       var tokens = [];
@@ -1434,17 +1567,20 @@ Lexer.prototype = {
           this.tokens.pop();
           return pipelessText.call(this, lineCaptures[1].length);
         }
-      } while((this.input.length - stringPtr) && isMatch);
+      } while (this.input.length - stringPtr && isMatch);
       this.consume(stringPtr);
-      while (this.input.length === 0 && tokens[tokens.length - 1] === '') tokens.pop();
-      tokens.forEach(function (token, i) {
-        var tok;
-        this.incrementLine(1);
-        if (i !== 0) tok = this.tok('newline');
-        if (token_indent[i]) this.incrementColumn(indents);
-        if (tok) this.tokens.push(this.tokEnd(tok));
-        this.addText('text', token);
-      }.bind(this));
+      while (this.input.length === 0 && tokens[tokens.length - 1] === '')
+        tokens.pop();
+      tokens.forEach(
+        function(token, i) {
+          var tok;
+          this.incrementLine(1);
+          if (i !== 0) tok = this.tok('newline');
+          if (token_indent[i]) this.incrementColumn(indents);
+          if (tok) this.tokens.push(this.tokEnd(tok));
+          this.addText('text', token);
+        }.bind(this)
+      );
       this.tokens.push(this.tokEnd(this.tok('end-pipeless-text')));
       return true;
     }
@@ -1474,11 +1610,14 @@ Lexer.prototype = {
     }
   },
 
-  fail: function () {
-    this.error('UNEXPECTED_TEXT', 'unexpected text "' + this.input.substr(0, 5) + '"');
+  fail: function() {
+    this.error(
+      'UNEXPECTED_TEXT',
+      'unexpected text "' + this.input.substr(0, 5) + '"'
+    );
   },
 
-  callLexerFunction: function (func) {
+  callLexerFunction: function(func) {
     var rest = [];
     for (var i = 1; i < arguments.length; i++) {
       rest.push(arguments[i]);
@@ -1500,43 +1639,45 @@ Lexer.prototype = {
    */
 
   advance: function() {
-    return this.callLexerFunction('blank')
-      || this.callLexerFunction('eos')
-      || this.callLexerFunction('endInterpolation')
-      || this.callLexerFunction('yield')
-      || this.callLexerFunction('doctype')
-      || this.callLexerFunction('interpolation')
-      || this.callLexerFunction('case')
-      || this.callLexerFunction('when')
-      || this.callLexerFunction('default')
-      || this.callLexerFunction('extends')
-      || this.callLexerFunction('append')
-      || this.callLexerFunction('prepend')
-      || this.callLexerFunction('block')
-      || this.callLexerFunction('mixinBlock')
-      || this.callLexerFunction('include')
-      || this.callLexerFunction('mixin')
-      || this.callLexerFunction('call')
-      || this.callLexerFunction('conditional')
-      || this.callLexerFunction('eachOf')
-      || this.callLexerFunction('each')
-      || this.callLexerFunction('while')
-      || this.callLexerFunction('tag')
-      || this.callLexerFunction('filter')
-      || this.callLexerFunction('blockCode')
-      || this.callLexerFunction('code')
-      || this.callLexerFunction('id')
-      || this.callLexerFunction('dot')
-      || this.callLexerFunction('className')
-      || this.callLexerFunction('attrs')
-      || this.callLexerFunction('attributesBlock')
-      || this.callLexerFunction('indent')
-      || this.callLexerFunction('text')
-      || this.callLexerFunction('textHtml')
-      || this.callLexerFunction('comment')
-      || this.callLexerFunction('slash')
-      || this.callLexerFunction('colon')
-      || this.fail();
+    return (
+      this.callLexerFunction('blank') ||
+      this.callLexerFunction('eos') ||
+      this.callLexerFunction('endInterpolation') ||
+      this.callLexerFunction('yield') ||
+      this.callLexerFunction('doctype') ||
+      this.callLexerFunction('interpolation') ||
+      this.callLexerFunction('case') ||
+      this.callLexerFunction('when') ||
+      this.callLexerFunction('default') ||
+      this.callLexerFunction('extends') ||
+      this.callLexerFunction('append') ||
+      this.callLexerFunction('prepend') ||
+      this.callLexerFunction('block') ||
+      this.callLexerFunction('mixinBlock') ||
+      this.callLexerFunction('include') ||
+      this.callLexerFunction('mixin') ||
+      this.callLexerFunction('call') ||
+      this.callLexerFunction('conditional') ||
+      this.callLexerFunction('eachOf') ||
+      this.callLexerFunction('each') ||
+      this.callLexerFunction('while') ||
+      this.callLexerFunction('tag') ||
+      this.callLexerFunction('filter') ||
+      this.callLexerFunction('blockCode') ||
+      this.callLexerFunction('code') ||
+      this.callLexerFunction('id') ||
+      this.callLexerFunction('dot') ||
+      this.callLexerFunction('className') ||
+      this.callLexerFunction('attrs') ||
+      this.callLexerFunction('attributesBlock') ||
+      this.callLexerFunction('indent') ||
+      this.callLexerFunction('text') ||
+      this.callLexerFunction('textHtml') ||
+      this.callLexerFunction('comment') ||
+      this.callLexerFunction('slash') ||
+      this.callLexerFunction('colon') ||
+      this.fail()
+    );
   },
 
   /**
@@ -1545,10 +1686,10 @@ Lexer.prototype = {
    * @returns {Array.<Token>}
    * @api public
    */
-  getTokens: function () {
+  getTokens: function() {
     while (!this.ended) {
       this.callLexerFunction('advance');
     }
     return this.tokens;
-  }
+  },
 };
diff --git a/packages/pug-lexer/test/cases/javascript-new-lines.js b/packages/pug-lexer/test/cases/javascript-new-lines.js
index 6893341c5..bb0c26f05 100644
--- a/packages/pug-lexer/test/cases/javascript-new-lines.js
+++ b/packages/pug-lexer/test/cases/javascript-new-lines.js
@@ -1 +1 @@
-var x = "\n here is some \n new lined text";
+var x = '\n here is some \n new lined text';
diff --git a/packages/pug-lexer/test/check-lexer-functions.test.js b/packages/pug-lexer/test/check-lexer-functions.test.js
index 49ec401e1..361212884 100644
--- a/packages/pug-lexer/test/check-lexer-functions.test.js
+++ b/packages/pug-lexer/test/check-lexer-functions.test.js
@@ -47,7 +47,7 @@ var lexerFunctions = {
   yield: true,
 };
 
-function checkDirectCalls (node) {
+function checkDirectCalls(node) {
   var callee = node.callee;
   if (callee.type !== 'MemberExpression') return;
   if (callee.object.type !== 'ThisExpression') return;
@@ -60,11 +60,19 @@ function checkDirectCalls (node) {
     func = property.name;
   }
   if (!lexerFunctions[func]) return;
-  console.log('index.js:' + node.loc.start.line + ':' + node.loc.start.column + ': Lexer function ' + func + ' called directly');
+  console.log(
+    'index.js:' +
+      node.loc.start.line +
+      ':' +
+      node.loc.start.column +
+      ': Lexer function ' +
+      func +
+      ' called directly'
+  );
   hadErrors = true;
 }
 
-function checkMissingLexerFunction (node) {
+function checkMissingLexerFunction(node) {
   var callee = node.callee;
   if (callee.type !== 'MemberExpression') return;
   if (callee.object.type !== 'ThisExpression') return;
@@ -81,17 +89,25 @@ function checkMissingLexerFunction (node) {
   if (node.arguments[0].type !== 'Literal') return;
   func = node.arguments[0].value;
   if (lexerFunctions[func]) return;
-  console.log('index.js:' + node.loc.start.line + ':' + node.loc.start.column + ': Lexer function ' + func + ' not in lexerFunctions list');
+  console.log(
+    'index.js:' +
+      node.loc.start.line +
+      ':' +
+      node.loc.start.column +
+      ': Lexer function ' +
+      func +
+      ' not in lexerFunctions list'
+  );
   hadErrors = true;
 }
 test('lexer functions', () => {
   var str = fs.readFileSync(__dirname + '/../index.js', 'utf8');
   var ast = acorn.parse(str, {locations: true});
   walk.simple(ast, {
-    CallExpression: function (node) {
+    CallExpression: function(node) {
       checkDirectCalls(node);
       checkMissingLexerFunction(node);
-    }
+    },
   });
   if (hadErrors) {
     throw new Error('Problem with lexer functions detected');
diff --git a/packages/pug-lexer/test/index.test.js b/packages/pug-lexer/test/index.test.js
index 19412c19f..385a32b11 100644
--- a/packages/pug-lexer/test/index.test.js
+++ b/packages/pug-lexer/test/index.test.js
@@ -5,23 +5,26 @@ var assert = require('assert');
 var lex = require('../');
 
 var dir = __dirname + '/cases/';
-fs.readdirSync(dir).forEach(function (testCase) {
+fs.readdirSync(dir).forEach(function(testCase) {
   if (/\.pug$/.test(testCase)) {
     test(testCase, () => {
-      var result = lex(fs.readFileSync(dir + testCase, 'utf8'), {filename: dir + testCase});
+      var result = lex(fs.readFileSync(dir + testCase, 'utf8'), {
+        filename: dir + testCase,
+      });
       expect(result).toMatchSnapshot();
     });
   }
 });
 
-
 var edir = __dirname + '/errors/';
-fs.readdirSync(edir).forEach(function (testCase) {
+fs.readdirSync(edir).forEach(function(testCase) {
   if (/\.pug$/.test(testCase)) {
     test(testCase, () => {
       var actual;
       try {
-        lex(fs.readFileSync(edir + testCase, 'utf8'), {filename: edir + testCase});
+        lex(fs.readFileSync(edir + testCase, 'utf8'), {
+          filename: edir + testCase,
+        });
         throw new Error('Expected ' + testCase + ' to throw an exception.');
       } catch (ex) {
         if (!ex || !ex.code || ex.code.indexOf('PUG:') !== 0) throw ex;
@@ -29,7 +32,7 @@ fs.readdirSync(edir).forEach(function (testCase) {
           msg: ex.msg,
           code: ex.code,
           line: ex.line,
-          column: ex.column
+          column: ex.column,
         };
       }
       expect(actual).toMatchSnapshot();
diff --git a/packages/pug-linker/index.js b/packages/pug-linker/index.js
index e7993e8f2..256d74bb0 100644
--- a/packages/pug-linker/index.js
+++ b/packages/pug-linker/index.js
@@ -9,7 +9,10 @@ function error() {
 
 module.exports = link;
 function link(ast) {
-  assert(ast.type === 'Block', 'The top level element should always be a block');
+  assert(
+    ast.type === 'Block',
+    'The top level element should always be a block'
+  );
   var extendsNode = null;
   if (ast.nodes.length) {
     var hasExtends = ast.nodes[0].type === 'Extends';
@@ -31,18 +34,22 @@ function link(ast) {
       } else if (node.type === 'Mixin' && node.call === false) {
         mixins.push(node);
       } else {
-        error('UNEXPECTED_NODES_IN_EXTENDING_ROOT', 'Only named blocks and mixins can appear at the top level of an extending template', node);
+        error(
+          'UNEXPECTED_NODES_IN_EXTENDING_ROOT',
+          'Only named blocks and mixins can appear at the top level of an extending template',
+          node
+        );
       }
     });
     var parent = link(extendsNode.file.ast);
     extend(parent.declaredBlocks, ast);
     var foundBlockNames = [];
-    walk(parent, function (node) {
+    walk(parent, function(node) {
       if (node.type === 'NamedBlock') {
         foundBlockNames.push(node.name);
       }
     });
-    expectedBlocks.forEach(function (expectedBlock) {
+    expectedBlocks.forEach(function(expectedBlock) {
       if (foundBlockNames.indexOf(expectedBlock.name) === -1) {
         error(
           'UNEXPECTED_BLOCK',
@@ -51,7 +58,7 @@ function link(ast) {
         );
       }
     });
-    Object.keys(ast.declaredBlocks).forEach(function (name) {
+    Object.keys(ast.declaredBlocks).forEach(function(name) {
       parent.declaredBlocks[name] = ast.declaredBlocks[name];
     });
     parent.nodes = mixins.concat(parent.nodes);
@@ -74,7 +81,7 @@ function findDeclaredBlocks(ast) /*: {[name: string]: Array<BlockNode>}*/ {
 
 function flattenParentBlocks(parentBlocks, accumulator) {
   accumulator = accumulator || [];
-  parentBlocks.forEach(function (parentBlock) {
+  parentBlocks.forEach(function(parentBlock) {
     if (parentBlock.parents) {
       flattenParentBlocks(parentBlock.parents, accumulator);
     }
@@ -85,58 +92,68 @@ function flattenParentBlocks(parentBlocks, accumulator) {
 
 function extend(parentBlocks, ast) {
   var stack = {};
-  walk(ast, function before(node) {
-    if (node.type === 'NamedBlock') {
-      if (stack[node.name] === node.name) {
-        return node.ignore = true;
+  walk(
+    ast,
+    function before(node) {
+      if (node.type === 'NamedBlock') {
+        if (stack[node.name] === node.name) {
+          return (node.ignore = true);
+        }
+        stack[node.name] = node.name;
+        var parentBlockList = parentBlocks[node.name]
+          ? flattenParentBlocks(parentBlocks[node.name])
+          : [];
+        if (parentBlockList.length) {
+          node.parents = parentBlockList;
+          parentBlockList.forEach(function(parentBlock) {
+            switch (node.mode) {
+              case 'append':
+                parentBlock.nodes = parentBlock.nodes.concat(node.nodes);
+                break;
+              case 'prepend':
+                parentBlock.nodes = node.nodes.concat(parentBlock.nodes);
+                break;
+              case 'replace':
+                parentBlock.nodes = node.nodes;
+                break;
+            }
+          });
+        }
       }
-      stack[node.name] = node.name;
-      var parentBlockList = parentBlocks[node.name] ? flattenParentBlocks(parentBlocks[node.name]) : [];
-      if (parentBlockList.length) {
-        node.parents = parentBlockList;
-        parentBlockList.forEach(function (parentBlock) {
-          switch (node.mode) {
-            case 'append':
-              parentBlock.nodes = parentBlock.nodes.concat(node.nodes);
-              break;
-            case 'prepend':
-              parentBlock.nodes = node.nodes.concat(parentBlock.nodes);
-              break;
-            case 'replace':
-              parentBlock.nodes = node.nodes;
-              break;
-          }
-        });
+    },
+    function after(node) {
+      if (node.type === 'NamedBlock' && !node.ignore) {
+        delete stack[node.name];
       }
     }
-  }, function after(node) {
-    if (node.type === 'NamedBlock' && !node.ignore) {
-      delete stack[node.name];
-    }
-  });
+  );
 }
 
 function applyIncludes(ast, child) {
-  return walk(ast, function before(node, replace) {
-    if (node.type === 'RawInclude') {
-      replace({type: 'Text', val: node.file.str.replace(/\r/g, '')});
-    }
-  }, function after(node, replace) {
-    if (node.type === 'Include') {
-      var childAST = link(node.file.ast);
-      if (childAST.hasExtends) {
-        childAST = removeBlocks(childAST);
+  return walk(
+    ast,
+    function before(node, replace) {
+      if (node.type === 'RawInclude') {
+        replace({type: 'Text', val: node.file.str.replace(/\r/g, '')});
+      }
+    },
+    function after(node, replace) {
+      if (node.type === 'Include') {
+        var childAST = link(node.file.ast);
+        if (childAST.hasExtends) {
+          childAST = removeBlocks(childAST);
+        }
+        replace(applyYield(childAST, node.block));
       }
-      replace(applyYield(childAST, node.block));
     }
-  });
+  );
 }
 function removeBlocks(ast) {
-  return walk(ast, function (node, replace) {
+  return walk(ast, function(node, replace) {
     if (node.type === 'NamedBlock') {
       replace({
         type: 'Block',
-        nodes: node.nodes
+        nodes: node.nodes,
       });
     }
   });
@@ -145,7 +162,7 @@ function removeBlocks(ast) {
 function applyYield(ast, block) {
   if (!block || !block.nodes.length) return ast;
   var replaced = false;
-  ast = walk(ast, null, function (node, replace) {
+  ast = walk(ast, null, function(node, replace) {
     if (node.type === 'YieldBlock') {
       replaced = true;
       node.type = 'Block';
@@ -173,12 +190,16 @@ function applyYield(ast, block) {
 
 function checkExtendPosition(ast, hasExtends) {
   var legitExtendsReached = false;
-  walk(ast, function (node) {
+  walk(ast, function(node) {
     if (node.type === 'Extends') {
       if (hasExtends && !legitExtendsReached) {
         legitExtendsReached = true;
       } else {
-        error('EXTENDS_NOT_FIRST', 'Declaration of template inheritance ("extends") should be the first thing in the file. There can only be one extends statement per file.', node);
+        error(
+          'EXTENDS_NOT_FIRST',
+          'Declaration of template inheritance ("extends") should be the first thing in the file. There can only be one extends statement per file.',
+          node
+        );
       }
     }
   });
diff --git a/packages/pug-linker/test/cases-src/auxiliary/includable.js b/packages/pug-linker/test/cases-src/auxiliary/includable.js
index f3efe1e66..38c071e0c 100644
--- a/packages/pug-linker/test/cases-src/auxiliary/includable.js
+++ b/packages/pug-linker/test/cases-src/auxiliary/includable.js
@@ -1,7 +1,8 @@
-var STRING_SUBSTITUTIONS = {    // table of character substitutions
+var STRING_SUBSTITUTIONS = {
+  // table of character substitutions
   '\t': '\\t',
   '\r': '\\r',
   '\n': '\\n',
-  '"' : '\\"',
-  '\\': '\\\\'
-};
\ No newline at end of file
+  '"': '\\"',
+  '\\': '\\\\',
+};
diff --git a/packages/pug-linker/test/cases-src/javascript-new-lines.js b/packages/pug-linker/test/cases-src/javascript-new-lines.js
index 6893341c5..bb0c26f05 100644
--- a/packages/pug-linker/test/cases-src/javascript-new-lines.js
+++ b/packages/pug-linker/test/cases-src/javascript-new-lines.js
@@ -1 +1 @@
-var x = "\n here is some \n new lined text";
+var x = '\n here is some \n new lined text';
diff --git a/packages/pug-linker/test/index.test.js b/packages/pug-linker/test/index.test.js
index 193d8c79f..862629d3c 100644
--- a/packages/pug-linker/test/index.test.js
+++ b/packages/pug-linker/test/index.test.js
@@ -2,45 +2,45 @@ var assert = require('assert');
 var fs = require('fs');
 var link = require('../');
 
-function testDir (dir) {
-  fs.readdirSync(dir).forEach(function (name) {
+function testDir(dir) {
+  fs.readdirSync(dir).forEach(function(name) {
     if (!/\.input\.json$/.test(name)) return;
-    test(name, function () {
+    test(name, function() {
       var actual = link(JSON.parse(fs.readFileSync(dir + '/' + name, 'utf8')));
       expect(actual).toMatchSnapshot();
     });
   });
 }
 
-function testDirError (dir) {
-  fs.readdirSync(dir).forEach(function (name) {
+function testDirError(dir) {
+  fs.readdirSync(dir).forEach(function(name) {
     if (!/\.input\.json$/.test(name)) return;
-    test(name, function () {
+    test(name, function() {
       var input = JSON.parse(fs.readFileSync(dir + '/' + name, 'utf8'));
       var err;
       try {
         link(input);
       } catch (ex) {
         err = {
-          msg:  ex.msg,
+          msg: ex.msg,
           code: ex.code,
-          line: ex.line
+          line: ex.line,
         };
       }
-      if (!err) throw new Error('Expected error')
+      if (!err) throw new Error('Expected error');
       expect(err).toMatchSnapshot();
     });
   });
 }
 
-describe('cases from pug', function () {
+describe('cases from pug', function() {
   testDir(__dirname + '/cases');
 });
 
-describe('special cases', function () {
+describe('special cases', function() {
   testDir(__dirname + '/special-cases');
 });
 
-describe('error handling', function () {
+describe('error handling', function() {
   testDirError(__dirname + '/errors');
 });
diff --git a/packages/pug-load/index.js b/packages/pug-load/index.js
index 9b12d3472..1eb1ffcb1 100644
--- a/packages/pug-load/index.js
+++ b/packages/pug-load/index.js
@@ -10,9 +10,13 @@ function load(ast, options) {
   options = getOptions(options);
   // clone the ast
   ast = JSON.parse(JSON.stringify(ast));
-  return walk(ast, function (node) {
+  return walk(ast, function(node) {
     if (node.str === undefined) {
-      if (node.type === 'Include' || node.type === 'RawInclude' || node.type === 'Extends') {
+      if (
+        node.type === 'Include' ||
+        node.type === 'RawInclude' ||
+        node.type === 'Extends'
+      ) {
         var file = node.file;
         if (file.type !== 'FileReference') {
           throw new Error('Expected file.type to be "FileReference"');
@@ -28,9 +32,12 @@ function load(ast, options) {
         }
         file.str = str;
         if (node.type === 'Extends' || node.type === 'Include') {
-          file.ast = load.string(str, assign({}, options, {
-            filename: path
-          }));
+          file.ast = load.string(
+            str,
+            assign({}, options, {
+              filename: path,
+            })
+          );
         }
       }
     }
@@ -39,7 +46,7 @@ function load(ast, options) {
 
 load.string = function loadString(src, options) {
   options = assign(getOptions(options), {
-    src: src
+    src: src,
   });
   var tokens = options.lex(src, options);
   var ast = options.parse(tokens, options);
@@ -47,7 +54,7 @@ load.string = function loadString(src, options) {
 };
 load.file = function loadFile(filename, options) {
   options = assign(getOptions(options), {
-    filename: filename
+    filename: filename,
   });
   var str = options.read(filename);
   return load.string(str, options);
@@ -56,12 +63,19 @@ load.file = function loadFile(filename, options) {
 load.resolve = function resolve(filename, source, options) {
   filename = filename.trim();
   if (filename[0] !== '/' && !source)
-    throw new Error('the "filename" option is required to use includes and extends with "relative" paths');
+    throw new Error(
+      'the "filename" option is required to use includes and extends with "relative" paths'
+    );
 
   if (filename[0] === '/' && !options.basedir)
-    throw new Error('the "basedir" option is required to use includes and extends with "absolute" paths');
+    throw new Error(
+      'the "basedir" option is required to use includes and extends with "absolute" paths'
+    );
 
-  filename = path.join(filename[0] === '/' ? options.basedir : path.dirname(source.trim()), filename);
+  filename = path.join(
+    filename[0] === '/' ? options.basedir : path.dirname(source.trim()),
+    filename
+  );
 
   return filename;
 };
@@ -94,8 +108,11 @@ load.validateOptions = function validateOptions(options) {
 
 function getOptions(options) {
   load.validateOptions(options);
-  return assign({
-    resolve: load.resolve,
-    read: load.read
-  }, options);
+  return assign(
+    {
+      resolve: load.resolve,
+      read: load.read,
+    },
+    options
+  );
 }
diff --git a/packages/pug-load/test/index.test.js b/packages/pug-load/test/index.test.js
index 1ad7f607f..f8b21fb2e 100644
--- a/packages/pug-load/test/index.test.js
+++ b/packages/pug-load/test/index.test.js
@@ -12,13 +12,19 @@ test('pug-load', () => {
   var filename = __dirname + '/foo.pug';
   var ast = load.file(filename, {
     lex: lex,
-    parse: parse
+    parse: parse,
   });
 
-  ast = walk(ast, function (node) {
-    if (node.filename) node.filename = '<dirname>/' + path.basename(node.filename);
-    if (node.fullPath) node.fullPath = '<dirname>/' + path.basename(node.fullPath);
-  }, {includeDependencies: true});
+  ast = walk(
+    ast,
+    function(node) {
+      if (node.filename)
+        node.filename = '<dirname>/' + path.basename(node.filename);
+      if (node.fullPath)
+        node.fullPath = '<dirname>/' + path.basename(node.fullPath);
+    },
+    {includeDependencies: true}
+  );
 
   expect(ast).toMatchSnapshot();
 });
diff --git a/packages/pug-parser/index.js b/packages/pug-parser/index.js
index 54606315e..abd531ed5 100644
--- a/packages/pug-parser/index.js
+++ b/packages/pug-parser/index.js
@@ -11,7 +11,7 @@ function parse(tokens, options) {
   var parser = new Parser(tokens, options);
   var ast = parser.parse();
   return JSON.parse(JSON.stringify(ast));
-};
+}
 
 /**
  * Initialize `Parser` with the given input `str` and `filename`.
@@ -25,36 +25,39 @@ function parse(tokens, options) {
 function Parser(tokens, options) {
   options = options || {};
   if (!Array.isArray(tokens)) {
-    throw new Error('Expected tokens to be an Array but got "' + (typeof tokens) + '"');
+    throw new Error(
+      'Expected tokens to be an Array but got "' + typeof tokens + '"'
+    );
   }
   if (typeof options !== 'object') {
-    throw new Error('Expected "options" to be an object but got "' + (typeof options) + '"');
+    throw new Error(
+      'Expected "options" to be an object but got "' + typeof options + '"'
+    );
   }
   this.tokens = new TokenStream(tokens);
   this.filename = options.filename;
   this.src = options.src;
   this.inMixin = 0;
   this.plugins = options.plugins || [];
-};
+}
 
 /**
  * Parser prototype.
  */
 
 Parser.prototype = {
-
   /**
    * Save original constructor
    */
 
   constructor: Parser,
 
-  error: function (code, message, token) {
+  error: function(code, message, token) {
     var err = error(code, message, {
       line: token.loc.start.line,
       column: token.loc.start.column,
       filename: this.filename,
-      src: this.src
+      src: this.src,
     });
     throw err;
   },
@@ -66,7 +69,7 @@ Parser.prototype = {
    * @api private
    */
 
-  advance: function(){
+  advance: function() {
     return this.tokens.advance();
   },
 
@@ -89,7 +92,7 @@ Parser.prototype = {
    * @api private
    */
 
-  lookahead: function(n){
+  lookahead: function(n) {
     return this.tokens.lookahead(n);
   },
 
@@ -100,7 +103,7 @@ Parser.prototype = {
    * @api public
    */
 
-  parse: function(){
+  parse: function() {
     var block = this.emptyBlock(0);
 
     while ('eos' != this.peek().type) {
@@ -130,11 +133,15 @@ Parser.prototype = {
    * @api private
    */
 
-  expect: function(type){
+  expect: function(type) {
     if (this.peek().type === type) {
       return this.advance();
     } else {
-      this.error('INVALID_TOKEN', 'expected "' + type + '", but got "' + this.peek().type + '"', this.peek());
+      this.error(
+        'INVALID_TOKEN',
+        'expected "' + type + '", but got "' + this.peek().type + '"',
+        this.peek()
+      );
     }
   },
 
@@ -145,7 +152,7 @@ Parser.prototype = {
    * @api private
    */
 
-  accept: function(type){
+  accept: function(type) {
     if (this.peek().type === type) {
       return this.advance();
     }
@@ -160,7 +167,7 @@ Parser.prototype = {
       type: 'Block',
       nodes: nodes,
       line: line,
-      filename: this.filename
+      filename: this.filename,
     };
   },
 
@@ -177,11 +184,18 @@ Parser.prototype = {
     for (var i = 0; i < this.plugins.length; i++) {
       var plugin = this.plugins[i];
       if (plugin[context] && plugin[context][tok.type]) {
-        if (pluginContext) throw new Error('Multiple plugin handlers found for context ' + JSON.stringify(context) + ', token type ' + JSON.stringify(tok.type));
+        if (pluginContext)
+          throw new Error(
+            'Multiple plugin handlers found for context ' +
+              JSON.stringify(context) +
+              ', token type ' +
+              JSON.stringify(tok.type)
+          );
         pluginContext = plugin[context];
       }
     }
-    if (pluginContext) return pluginContext[tok.type].apply(pluginContext, rest);
+    if (pluginContext)
+      return pluginContext[tok.type].apply(pluginContext, rest);
   },
 
   /**
@@ -202,7 +216,7 @@ Parser.prototype = {
    * | interpolation
    */
 
-  parseExpr: function(){
+  parseExpr: function() {
     switch (this.peek().type) {
       case 'tag':
         return this.parseTag();
@@ -257,13 +271,17 @@ Parser.prototype = {
           type: 'tag',
           val: 'div',
           loc: this.peek().loc,
-          filename: this.filename
+          filename: this.filename,
         });
         return this.parseExpr();
       default:
         var pluginResult = this.runPlugin('expressionTokens', this.peek());
         if (pluginResult) return pluginResult;
-        this.error('INVALID_TOKEN', 'unexpected token "' + this.peek().type + '"', this.peek());
+        this.error(
+          'INVALID_TOKEN',
+          'unexpected token "' + this.peek().type + '"',
+          this.peek()
+        );
     }
   },
 
@@ -276,71 +294,69 @@ Parser.prototype = {
    * Text
    */
 
-  parseText: function(options){
+  parseText: function(options) {
     var tags = [];
     var lineno = this.peek().loc.start.line;
     var nextTok = this.peek();
-    loop:
-      while (true) {
-        switch (nextTok.type) {
-          case 'text':
-            var tok = this.advance();
+    loop: while (true) {
+      switch (nextTok.type) {
+        case 'text':
+          var tok = this.advance();
+          tags.push({
+            type: 'Text',
+            val: tok.val,
+            line: tok.loc.start.line,
+            column: tok.loc.start.column,
+            filename: this.filename,
+          });
+          break;
+        case 'interpolated-code':
+          var tok = this.advance();
+          tags.push({
+            type: 'Code',
+            val: tok.val,
+            buffer: tok.buffer,
+            mustEscape: tok.mustEscape !== false,
+            isInline: true,
+            line: tok.loc.start.line,
+            column: tok.loc.start.column,
+            filename: this.filename,
+          });
+          break;
+        case 'newline':
+          if (!options || !options.block) break loop;
+          var tok = this.advance();
+          var nextType = this.peek().type;
+          if (nextType === 'text' || nextType === 'interpolated-code') {
             tags.push({
               type: 'Text',
-              val: tok.val,
-              line: tok.loc.start.line,
-              column: tok.loc.start.column,
-              filename: this.filename
-            });
-            break;
-          case 'interpolated-code':
-            var tok = this.advance();
-            tags.push({
-              type: 'Code',
-              val: tok.val,
-              buffer: tok.buffer,
-              mustEscape: tok.mustEscape !== false,
-              isInline: true,
+              val: '\n',
               line: tok.loc.start.line,
               column: tok.loc.start.column,
-              filename: this.filename
+              filename: this.filename,
             });
-            break;
-          case 'newline':
-            if (!options || !options.block) break loop;
-            var tok = this.advance();
-            var nextType = this.peek().type;
-            if (nextType === 'text' || nextType === 'interpolated-code') {
-              tags.push({
-                type: 'Text',
-                val: '\n',
-                line: tok.loc.start.line,
-                column: tok.loc.start.column,
-                filename: this.filename
-              });
-            }
-            break;
-          case 'start-pug-interpolation':
-            this.advance();
-            tags.push(this.parseExpr());
-            this.expect('end-pug-interpolation');
-            break;
-          default:
-            var pluginResult = this.runPlugin('textTokens', nextTok, tags);
-            if (pluginResult) break;
-            break loop;
-        }
-        nextTok = this.peek();
+          }
+          break;
+        case 'start-pug-interpolation':
+          this.advance();
+          tags.push(this.parseExpr());
+          this.expect('end-pug-interpolation');
+          break;
+        default:
+          var pluginResult = this.runPlugin('textTokens', nextTok, tags);
+          if (pluginResult) break;
+          break loop;
       }
+      nextTok = this.peek();
+    }
     if (tags.length === 1) return tags[0];
     else return this.initBlock(lineno, tags);
   },
 
-  parseTextHtml: function () {
+  parseTextHtml: function() {
     var nodes = [];
     var currentNode = null;
-loop:
-    while (true) {
+    loop: while (true) {
       switch (this.peek().type) {
         case 'text-html':
           var text = this.advance();
@@ -351,7 +367,7 @@ loop:
               filename: this.filename,
               line: text.loc.start.line,
               column: text.loc.start.column,
-              isHtml: true
+              isHtml: true,
             };
             nodes.push(currentNode);
           } else {
@@ -360,7 +376,7 @@ loop:
           break;
         case 'indent':
           var block = this.block();
-          block.nodes.forEach(function (node) {
+          block.nodes.forEach(function(node) {
             if (node.isHtml) {
               if (!currentNode) {
                 currentNode = node;
@@ -393,11 +409,13 @@ loop:
    * | block
    */
 
-  parseBlockExpansion: function(){
+  parseBlockExpansion: function() {
     var tok = this.accept(':');
     if (tok) {
       var expr = this.parseExpr();
-      return expr.type === 'Block' ? expr : this.initBlock(tok.loc.start.line, [expr]);
+      return expr.type === 'Block'
+        ? expr
+        : this.initBlock(tok.loc.start.line, [expr]);
     } else {
       return this.block();
     }
@@ -407,14 +425,14 @@ loop:
    * case
    */
 
-  parseCase: function(){
+  parseCase: function() {
     var tok = this.expect('case');
     var node = {
       type: 'Case',
       expr: tok.val,
       line: tok.loc.start.line,
       column: tok.loc.start.column,
-      filename: this.filename
+      filename: this.filename,
     };
 
     var block = this.emptyBlock(tok.loc.start.line + 1);
@@ -434,8 +452,13 @@ loop:
         default:
           var pluginResult = this.runPlugin('caseTokens', this.peek(), block);
           if (pluginResult) break;
-          this.error('INVALID_TOKEN', 'Unexpected token "' + this.peek().type
-                          + '", expected "when", "default" or "newline"', this.peek());
+          this.error(
+            'INVALID_TOKEN',
+            'Unexpected token "' +
+              this.peek().type +
+              '", expected "when", "default" or "newline"',
+            this.peek()
+          );
       }
     }
     this.expect('outdent');
@@ -449,7 +472,7 @@ loop:
    * when
    */
 
-  parseWhen: function(){
+  parseWhen: function() {
     var tok = this.expect('when');
     if (this.peek().type !== 'newline') {
       return {
@@ -459,7 +482,7 @@ loop:
         debug: false,
         line: tok.loc.start.line,
         column: tok.loc.start.column,
-        filename: this.filename
+        filename: this.filename,
       };
     } else {
       return {
@@ -468,7 +491,7 @@ loop:
         debug: false,
         line: tok.loc.start.line,
         column: tok.loc.start.column,
-        filename: this.filename
+        filename: this.filename,
       };
     }
   },
@@ -477,7 +500,7 @@ loop:
    * default
    */
 
-  parseDefault: function(){
+  parseDefault: function() {
     var tok = this.expect('default');
     return {
       type: 'When',
@@ -486,7 +509,7 @@ loop:
       debug: false,
       line: tok.loc.start.line,
       column: tok.loc.start.column,
-      filename: this.filename
+      filename: this.filename,
     };
   },
 
@@ -494,9 +517,12 @@ loop:
    * code
    */
 
-  parseCode: function(noBlock){
+  parseCode: function(noBlock) {
     var tok = this.expect('code');
-    assert(typeof tok.mustEscape === 'boolean', 'Please update to the newest version of pug-lexer.');
+    assert(
+      typeof tok.mustEscape === 'boolean',
+      'Please update to the newest version of pug-lexer.'
+    );
     var node = {
       type: 'Code',
       val: tok.val,
@@ -505,7 +531,7 @@ loop:
       isInline: !!noBlock,
       line: tok.loc.start.line,
       column: tok.loc.start.column,
-      filename: this.filename
+      filename: this.filename,
     };
     // todo: why is this here?  It seems like a hacky workaround
     if (node.val.match(/^ *else/)) node.debug = false;
@@ -518,14 +544,18 @@ loop:
     block = 'indent' == this.peek().type;
     if (block) {
       if (tok.buffer) {
-        this.error('BLOCK_IN_BUFFERED_CODE', 'Buffered code cannot have a block attached to it', this.peek());
+        this.error(
+          'BLOCK_IN_BUFFERED_CODE',
+          'Buffered code cannot have a block attached to it',
+          this.peek()
+        );
       }
       node.block = this.block();
     }
 
     return node;
   },
-  parseConditional: function(){
+  parseConditional: function() {
     var tok = this.expect('if');
     var node = {
       type: 'Conditional',
@@ -534,7 +564,7 @@ loop:
       alternate: null,
       line: tok.loc.start.line,
       column: tok.loc.start.column,
-      filename: this.filename
+      filename: this.filename,
     };
 
     // handle block
@@ -548,17 +578,15 @@ loop:
         this.expect('newline');
       } else if (this.peek().type === 'else-if') {
         tok = this.expect('else-if');
-        currentNode = (
-          currentNode.alternate = {
-            type: 'Conditional',
-            test: tok.val,
-            consequent: this.emptyBlock(tok.loc.start.line),
-            alternate: null,
-            line: tok.loc.start.line,
-            column: tok.loc.start.column,
-            filename: this.filename
-          }
-        );
+        currentNode = currentNode.alternate = {
+          type: 'Conditional',
+          test: tok.val,
+          consequent: this.emptyBlock(tok.loc.start.line),
+          alternate: null,
+          line: tok.loc.start.line,
+          column: tok.loc.start.column,
+          filename: this.filename,
+        };
         if ('indent' == this.peek().type) {
           currentNode.consequent = this.block();
         }
@@ -575,14 +603,14 @@ loop:
 
     return node;
   },
-  parseWhile: function(){
+  parseWhile: function() {
     var tok = this.expect('while');
     var node = {
       type: 'While',
       test: tok.val,
       line: tok.loc.start.line,
       column: tok.loc.start.column,
-      filename: this.filename
+      filename: this.filename,
     };
 
     // handle block
@@ -599,7 +627,7 @@ loop:
    * block code
    */
 
-  parseBlockCode: function(){
+  parseBlockCode: function() {
     var tok = this.expect('blockcode');
     var line = tok.loc.start.line;
     var column = tok.loc.start.column;
@@ -622,7 +650,11 @@ loop:
               text += pluginResult;
               break;
             }
-            this.error('INVALID_TOKEN', 'Unexpected token type: ' + tok.type, tok);
+            this.error(
+              'INVALID_TOKEN',
+              'Unexpected token type: ' + tok.type,
+              tok
+            );
         }
       }
       this.advance();
@@ -635,17 +667,17 @@ loop:
       isInline: false,
       line: line,
       column: column,
-      filename: this.filename
+      filename: this.filename,
     };
   },
   /**
    * comment
    */
 
-  parseComment: function(){
+  parseComment: function() {
     var tok = this.expect('comment');
     var block;
-    if (block = this.parseTextBlock()) {
+    if ((block = this.parseTextBlock())) {
       return {
         type: 'BlockComment',
         val: tok.val,
@@ -653,7 +685,7 @@ loop:
         buffer: tok.buffer,
         line: tok.loc.start.line,
         column: tok.loc.start.column,
-        filename: this.filename
+        filename: this.filename,
       };
     } else {
       return {
@@ -662,7 +694,7 @@ loop:
         buffer: tok.buffer,
         line: tok.loc.start.line,
         column: tok.loc.start.column,
-        filename: this.filename
+        filename: this.filename,
       };
     }
   },
@@ -671,14 +703,14 @@ loop:
    * doctype
    */
 
-  parseDoctype: function(){
+  parseDoctype: function() {
     var tok = this.expect('doctype');
     return {
       type: 'Doctype',
       val: tok.val,
       line: tok.loc.start.line,
       column: tok.loc.start.column,
-      filename: this.filename
+      filename: this.filename,
     };
   },
 
@@ -696,7 +728,7 @@ loop:
       attrs: attrs,
       line: tok.loc.start.line,
       column: tok.loc.start.column,
-      filename: this.filename
+      filename: this.filename,
     };
   },
 
@@ -704,9 +736,10 @@ loop:
    * filter attrs? text-block
    */
 
-  parseFilter: function(){
+  parseFilter: function() {
     var tok = this.expect('filter');
-    var block, attrs = [];
+    var block,
+      attrs = [];
 
     if (this.peek().type === 'start-attributes') {
       attrs = this.attrs();
@@ -720,8 +753,8 @@ loop:
           val: textToken.val,
           line: textToken.loc.start.line,
           column: textToken.loc.start.column,
-          filename: this.filename
-        }
+          filename: this.filename,
+        },
       ]);
     } else if (this.peek().type === 'filter') {
       block = this.initBlock(tok.loc.start.line, [this.parseFilter()]);
@@ -736,7 +769,7 @@ loop:
       attrs: attrs,
       line: tok.loc.start.line,
       column: tok.loc.start.column,
-      filename: this.filename
+      filename: this.filename,
     };
   },
 
@@ -744,7 +777,7 @@ loop:
    * each block
    */
 
-  parseEach: function(){
+  parseEach: function() {
     var tok = this.expect('each');
     var node = {
       type: 'Each',
@@ -754,7 +787,7 @@ loop:
       block: this.block(),
       line: tok.loc.start.line,
       column: tok.loc.start.column,
-      filename: this.filename
+      filename: this.filename,
     };
     if (this.peek().type == 'else') {
       this.advance();
@@ -763,7 +796,7 @@ loop:
     return node;
   },
 
-  parseEachOf: function(){
+  parseEachOf: function() {
     var tok = this.expect('eachOf');
     var node = {
       type: 'EachOf',
@@ -772,7 +805,7 @@ loop:
       block: this.block(),
       line: tok.loc.start.line,
       column: tok.loc.start.column,
-      filename: this.filename
+      filename: this.filename,
     };
     return node;
   },
@@ -780,7 +813,7 @@ loop:
    * 'extends' name
    */
 
-  parseExtends: function(){
+  parseExtends: function() {
     var tok = this.expect('extends');
     var path = this.expect('path');
     return {
@@ -790,11 +823,11 @@ loop:
         path: path.val.trim(),
         line: path.loc.start.line,
         column: path.loc.start.column,
-        filename: this.filename
+        filename: this.filename,
       },
       line: tok.loc.start.line,
       column: tok.loc.start.column,
-      filename: this.filename
+      filename: this.filename,
     };
   },
 
@@ -802,10 +835,13 @@ loop:
    * 'block' name block
    */
 
-  parseBlock: function(){
+  parseBlock: function() {
     var tok = this.expect('block');
 
-    var node = 'indent' == this.peek().type ? this.block() : this.emptyBlock(tok.loc.start.line);
+    var node =
+      'indent' == this.peek().type
+        ? this.block()
+        : this.emptyBlock(tok.loc.start.line);
     node.type = 'NamedBlock';
     node.name = tok.val.trim();
     node.mode = tok.mode;
@@ -815,16 +851,20 @@ loop:
     return node;
   },
 
-  parseMixinBlock: function () {
+  parseMixinBlock: function() {
     var tok = this.expect('mixin-block');
     if (!this.inMixin) {
-      this.error('BLOCK_OUTISDE_MIXIN', 'Anonymous blocks are not allowed unless they are part of a mixin.', tok);
+      this.error(
+        'BLOCK_OUTISDE_MIXIN',
+        'Anonymous blocks are not allowed unless they are part of a mixin.',
+        tok
+      );
     }
     return {
       type: 'MixinBlock',
       line: tok.loc.start.line,
       column: tok.loc.start.column,
-      filename: this.filename
+      filename: this.filename,
     };
   },
 
@@ -834,7 +874,7 @@ loop:
       type: 'YieldBlock',
       line: tok.loc.start.line,
       column: tok.loc.start.column,
-      filename: this.filename
+      filename: this.filename,
     };
   },
 
@@ -842,17 +882,17 @@ loop:
    * include block?
    */
 
-  parseInclude: function(){
+  parseInclude: function() {
     var tok = this.expect('include');
     var node = {
       type: 'Include',
       file: {
         type: 'FileReference',
-        filename: this.filename
+        filename: this.filename,
       },
       line: tok.loc.start.line,
       column: tok.loc.start.column,
-      filename: this.filename
+      filename: this.filename,
     };
     var filters = [];
     while (this.peek().type === 'filter') {
@@ -864,19 +904,33 @@ loop:
     node.file.line = path.loc.start.line;
     node.file.column = path.loc.start.column;
 
-    if ((/\.jade$/.test(node.file.path) || /\.pug$/.test(node.file.path)) && !filters.length) {
-      node.block = 'indent' == this.peek().type ? this.block() : this.emptyBlock(tok.loc.start.line);
+    if (
+      (/\.jade$/.test(node.file.path) || /\.pug$/.test(node.file.path)) &&
+      !filters.length
+    ) {
+      node.block =
+        'indent' == this.peek().type
+          ? this.block()
+          : this.emptyBlock(tok.loc.start.line);
       if (/\.jade$/.test(node.file.path)) {
         console.warn(
-          this.filename + ', line ' + tok.loc.start.line +
-          ':\nThe .jade extension is deprecated, use .pug for "' + node.file.path +'".'
+          this.filename +
+            ', line ' +
+            tok.loc.start.line +
+            ':\nThe .jade extension is deprecated, use .pug for "' +
+            node.file.path +
+            '".'
         );
       }
     } else {
       node.type = 'RawInclude';
       node.filters = filters;
       if (this.peek().type === 'indent') {
-        this.error('RAW_INCLUDE_BLOCK', 'Raw inclusion cannot contain a block', this.peek());
+        this.error(
+          'RAW_INCLUDE_BLOCK',
+          'Raw inclusion cannot contain a block',
+          this.peek()
+        );
       }
     }
     return node;
@@ -886,7 +940,7 @@ loop:
    * call ident block
    */
 
-  parseCall: function(){
+  parseCall: function() {
     var tok = this.expect('call');
     var name = tok.val;
     var args = tok.args;
@@ -900,7 +954,7 @@ loop:
       attributeBlocks: [],
       line: tok.loc.start.line,
       column: tok.loc.start.column,
-      filename: this.filename
+      filename: this.filename,
     };
 
     this.tag(mixin);
@@ -916,7 +970,7 @@ loop:
    * mixin block
    */
 
-  parseMixin: function(){
+  parseMixin: function() {
     var tok = this.expect('mixin');
     var name = tok.val;
     var args = tok.args;
@@ -931,12 +985,16 @@ loop:
         call: false,
         line: tok.loc.start.line,
         column: tok.loc.start.column,
-        filename: this.filename
+        filename: this.filename,
       };
       this.inMixin--;
       return mixin;
     } else {
-      this.error('MIXIN_WITHOUT_BODY', 'Mixin ' + name + ' declared without body', tok);
+      this.error(
+        'MIXIN_WITHOUT_BODY',
+        'Mixin ' + name + ' declared without body',
+        tok
+      );
     }
   },
 
@@ -944,7 +1002,7 @@ loop:
    * indent (text | newline)* outdent
    */
 
-  parseTextBlock: function(){
+  parseTextBlock: function() {
     var tok = this.accept('start-pipeless-text');
     if (!tok) return;
     var block = this.emptyBlock(tok.loc.start.line);
@@ -957,7 +1015,7 @@ loop:
             val: tok.val,
             line: tok.loc.start.line,
             column: tok.loc.start.column,
-            filename: this.filename
+            filename: this.filename,
           });
           break;
         case 'newline':
@@ -966,7 +1024,7 @@ loop:
             val: '\n',
             line: tok.loc.start.line,
             column: tok.loc.start.column,
-            filename: this.filename
+            filename: this.filename,
           });
           break;
         case 'start-pug-interpolation':
@@ -982,13 +1040,17 @@ loop:
             isInline: true,
             line: tok.loc.start.line,
             column: tok.loc.start.column,
-            filename: this.filename
+            filename: this.filename,
           });
           break;
         default:
           var pluginResult = this.runPlugin('textBlockTokens', tok, block, tok);
           if (pluginResult) break;
-          this.error('INVALID_TOKEN', 'Unexpected token type: ' + tok.type, tok);
+          this.error(
+            'INVALID_TOKEN',
+            'Unexpected token type: ' + tok.type,
+            tok
+          );
       }
     }
     this.advance();
@@ -999,7 +1061,7 @@ loop:
    * indent expr* outdent
    */
 
-  block: function(){
+  block: function() {
     var tok = this.expect('indent');
     var block = this.emptyBlock(tok.loc.start.line);
     while ('outdent' != this.peek().type) {
@@ -1024,7 +1086,7 @@ loop:
    * interpolation (attrs | class | id)* (text | code | ':')? newline* block?
    */
 
-  parseInterpolation: function(){
+  parseInterpolation: function() {
     var tok = this.advance();
     var tag = {
       type: 'InterpolatedTag',
@@ -1036,7 +1098,7 @@ loop:
       isInline: false,
       line: tok.loc.start.line,
       column: tok.loc.start.column,
-      filename: this.filename
+      filename: this.filename,
     };
 
     return this.tag(tag, {selfClosingAllowed: true});
@@ -1046,7 +1108,7 @@ loop:
    * tag (attrs | class | id)* (text | code | ':')? newline* block?
    */
 
-  parseTag: function(){
+  parseTag: function() {
     var tok = this.advance();
     var tag = {
       type: 'Tag',
@@ -1058,7 +1120,7 @@ loop:
       isInline: inlineTags.indexOf(tok.val) !== -1,
       line: tok.loc.start.line,
       column: tok.loc.start.column,
-      filename: this.filename
+      filename: this.filename,
     };
 
     return this.tag(tag, {selfClosingAllowed: true});
@@ -1073,50 +1135,63 @@ loop:
     var attributeNames = [];
     var selfClosingAllowed = options && options.selfClosingAllowed;
     // (attrs | class | id)*
-    out:
-      while (true) {
-        switch (this.peek().type) {
-          case 'id':
-          case 'class':
-            var tok = this.advance();
-            if (tok.type === 'id') {
-              if (attributeNames.indexOf('id') !== -1) {
-                this.error('DUPLICATE_ID', 'Duplicate attribute "id" is not allowed.', tok);
-              }
-              attributeNames.push('id');
-            }
-            tag.attrs.push({
-              name: tok.type,
-              val: "'" + tok.val + "'",
-              line: tok.loc.start.line,
-              column: tok.loc.start.column,
-              filename: this.filename,
-              mustEscape: false
-            });
-            continue;
-          case 'start-attributes':
-            if (seenAttrs) {
-              console.warn(this.filename + ', line ' + this.peek().loc.start.line + ':\nYou should not have pug tags with multiple attributes.');
+    out: while (true) {
+      switch (this.peek().type) {
+        case 'id':
+        case 'class':
+          var tok = this.advance();
+          if (tok.type === 'id') {
+            if (attributeNames.indexOf('id') !== -1) {
+              this.error(
+                'DUPLICATE_ID',
+                'Duplicate attribute "id" is not allowed.',
+                tok
+              );
             }
-            seenAttrs = true;
-            tag.attrs = tag.attrs.concat(this.attrs(attributeNames));
-            continue;
-          case '&attributes':
-            var tok = this.advance();
-            tag.attributeBlocks.push({
-              type: 'AttributeBlock',
-              val: tok.val,
-              line: tok.loc.start.line,
-              column: tok.loc.start.column,
-              filename: this.filename
-            });
-            break;
-          default:
-            var pluginResult = this.runPlugin('tagAttributeTokens', this.peek(), tag, attributeNames);
-            if (pluginResult) break;
-            break out;
-        }
+            attributeNames.push('id');
+          }
+          tag.attrs.push({
+            name: tok.type,
+            val: "'" + tok.val + "'",
+            line: tok.loc.start.line,
+            column: tok.loc.start.column,
+            filename: this.filename,
+            mustEscape: false,
+          });
+          continue;
+        case 'start-attributes':
+          if (seenAttrs) {
+            console.warn(
+              this.filename +
+                ', line ' +
+                this.peek().loc.start.line +
+                ':\nYou should not have pug tags with multiple attributes.'
+            );
+          }
+          seenAttrs = true;
+          tag.attrs = tag.attrs.concat(this.attrs(attributeNames));
+          continue;
+        case '&attributes':
+          var tok = this.advance();
+          tag.attributeBlocks.push({
+            type: 'AttributeBlock',
+            val: tok.val,
+            line: tok.loc.start.line,
+            column: tok.loc.start.column,
+            filename: this.filename,
+          });
+          break;
+        default:
+          var pluginResult = this.runPlugin(
+            'tagAttributeTokens',
+            this.peek(),
+            tag,
+            attributeNames
+          );
+          if (pluginResult) break;
+          break out;
       }
+    }
 
     // check immediate '.'
     if ('dot' == this.peek().type) {
@@ -1141,7 +1216,8 @@ loop:
       case ':':
         this.advance();
         var expr = this.parseExpr();
-        tag.block = expr.type === 'Block' ? expr : this.initBlock(tag.line, [expr]);
+        tag.block =
+          expr.type === 'Block' ? expr : this.initBlock(tag.line, [expr]);
         break;
       case 'newline':
       case 'indent':
@@ -1157,9 +1233,22 @@ loop:
           break;
         }
       default:
-        var pluginResult = this.runPlugin('tagTokens', this.peek(), tag, options);
+        var pluginResult = this.runPlugin(
+          'tagTokens',
+          this.peek(),
+          tag,
+          options
+        );
         if (pluginResult) break;
-        this.error('INVALID_TOKEN', 'Unexpected token `' + this.peek().type + '` expected `text`, `interpolated-code`, `code`, `:`' + (selfClosingAllowed ? ', `slash`' : '') + ', `newline` or `eos`', this.peek())
+        this.error(
+          'INVALID_TOKEN',
+          'Unexpected token `' +
+            this.peek().type +
+            '` expected `text`, `interpolated-code`, `code`, `:`' +
+            (selfClosingAllowed ? ', `slash`' : '') +
+            ', `newline` or `eos`',
+          this.peek()
+        );
     }
 
     // newline*
@@ -1186,7 +1275,11 @@ loop:
     while (tok.type === 'attribute') {
       if (tok.name !== 'class' && attributeNames) {
         if (attributeNames.indexOf(tok.name) !== -1) {
-          this.error('DUPLICATE_ATTRIBUTE', 'Duplicate attribute "' + tok.name + '" is not allowed.', tok);
+          this.error(
+            'DUPLICATE_ATTRIBUTE',
+            'Duplicate attribute "' + tok.name + '" is not allowed.',
+            tok
+          );
         }
         attributeNames.push(tok.name);
       }
@@ -1196,12 +1289,12 @@ loop:
         line: tok.loc.start.line,
         column: tok.loc.start.column,
         filename: this.filename,
-        mustEscape: tok.mustEscape !== false
+        mustEscape: tok.mustEscape !== false,
       });
       tok = this.advance();
     }
     this.tokens.defer(tok);
     this.expect('end-attributes');
     return attrs;
-  }
-};
\ No newline at end of file
+  },
+};
diff --git a/packages/pug-parser/lib/inline-tags.js b/packages/pug-parser/lib/inline-tags.js
index a2345b1fd..92cda828c 100644
--- a/packages/pug-parser/lib/inline-tags.js
+++ b/packages/pug-parser/lib/inline-tags.js
@@ -1,23 +1,23 @@
 'use strict';
 
 module.exports = [
-    'a'
-  , 'abbr'
-  , 'acronym'
-  , 'b'
-  , 'br'
-  , 'code'
-  , 'em'
-  , 'font'
-  , 'i'
-  , 'img'
-  , 'ins'
-  , 'kbd'
-  , 'map'
-  , 'samp'
-  , 'small'
-  , 'span'
-  , 'strong'
-  , 'sub'
-  , 'sup'
-];
\ No newline at end of file
+  'a',
+  'abbr',
+  'acronym',
+  'b',
+  'br',
+  'code',
+  'em',
+  'font',
+  'i',
+  'img',
+  'ins',
+  'kbd',
+  'map',
+  'samp',
+  'small',
+  'span',
+  'strong',
+  'sub',
+  'sup',
+];
diff --git a/packages/pug-parser/test/index.test.js b/packages/pug-parser/test/index.test.js
index 961ecbacd..c0b9721d1 100644
--- a/packages/pug-parser/test/index.test.js
+++ b/packages/pug-parser/test/index.test.js
@@ -4,21 +4,26 @@ var fs = require('fs');
 var getRepo = require('get-repo');
 var parse = require('../');
 
-var testCases = fs.readdirSync(__dirname + '/cases').filter(function (name) {
+var testCases = fs.readdirSync(__dirname + '/cases').filter(function(name) {
   return /\.tokens\.json$/.test(name);
 });
 
 function parseNewlineJson(str) {
-  return str.split('\n').filter(Boolean).map(JSON.parse)
+  return str
+    .split('\n')
+    .filter(Boolean)
+    .map(JSON.parse);
 }
 
 function read(path) {
   return fs.readFileSync(__dirname + '/cases/' + path, 'utf8');
 }
 
-testCases.forEach(function (filename) {
+testCases.forEach(function(filename) {
   test(filename, () => {
-    var actualAst = parse(parseNewlineJson(read(filename)), {filename: filename});
+    var actualAst = parse(parseNewlineJson(read(filename)), {
+      filename: filename,
+    });
     expect(actualAst).toMatchSnapshot();
   });
 });
diff --git a/packages/pug-parser/test/no-unnecessary-blocks.test.js b/packages/pug-parser/test/no-unnecessary-blocks.test.js
index 30b5c7df4..b6e208a51 100644
--- a/packages/pug-parser/test/no-unnecessary-blocks.test.js
+++ b/packages/pug-parser/test/no-unnecessary-blocks.test.js
@@ -7,7 +7,7 @@ const input = `
 div
   | Hello
   | World
-`
+`;
 
 test('no uncessessary blocks should be added', () => {
   expect(parse(lex(input))).toMatchSnapshot();
diff --git a/packages/pug-runtime/build.js b/packages/pug-runtime/build.js
index 04c247f40..b6c6c135a 100644
--- a/packages/pug-runtime/build.js
+++ b/packages/pug-runtime/build.js
@@ -9,7 +9,7 @@ module.exports = build;
 
 function build(functions) {
   var fns = [];
-  functions = functions.filter(function (fn) {
+  functions = functions.filter(function(fn) {
     return !internals[fn];
   });
   for (var i = 0; i < functions.length; i++) {
@@ -18,7 +18,10 @@ function build(functions) {
       functions.push.apply(functions, dependencies[functions[i]]);
     }
   }
-  return fns.sort().map(function (name) {
-    return sources[name];
-  }).join('\n');
+  return fns
+    .sort()
+    .map(function(name) {
+      return sources[name];
+    })
+    .join('\n');
 }
diff --git a/packages/pug-runtime/index.js b/packages/pug-runtime/index.js
index 4bd21803d..84c615eaa 100644
--- a/packages/pug-runtime/index.js
+++ b/packages/pug-runtime/index.js
@@ -40,7 +40,7 @@ function pug_merge(a, b) {
   }
 
   return a;
-};
+}
 
 /**
  * Process array, object, or string as a string of classes delimited by a space.
@@ -61,7 +61,10 @@ function pug_merge(a, b) {
  */
 exports.classes = pug_classes;
 function pug_classes_array(val, escaping) {
-  var classString = '', className, padding = '', escapeEnabled = Array.isArray(escaping);
+  var classString = '',
+    className,
+    padding = '',
+    escapeEnabled = Array.isArray(escaping);
   for (var i = 0; i < val.length; i++) {
     className = pug_classes(val[i]);
     if (!className) continue;
@@ -72,7 +75,8 @@ function pug_classes_array(val, escaping) {
   return classString;
 }
 function pug_classes_object(val) {
-  var classString = '', padding = '';
+  var classString = '',
+    padding = '';
   for (var key in val) {
     if (key && val[key] && pug_has_own_property.call(val, key)) {
       classString = classString + padding + key;
@@ -113,7 +117,7 @@ function pug_style(val) {
   } else {
     return val + '';
   }
-};
+}
 
 /**
  * Render the given attribute.
@@ -126,25 +130,32 @@ function pug_style(val) {
  */
 exports.attr = pug_attr;
 function pug_attr(key, val, escaped, terse) {
-  if (val === false || val == null || !val && (key === 'class' || key === 'style')) {
+  if (
+    val === false ||
+    val == null ||
+    (!val && (key === 'class' || key === 'style'))
+  ) {
     return '';
   }
   if (val === true) {
     return ' ' + (terse ? key : key + '="' + key + '"');
   }
   var type = typeof val;
-  if ((type === 'object' || type === 'function') && typeof val.toJSON === 'function') {
+  if (
+    (type === 'object' || type === 'function') &&
+    typeof val.toJSON === 'function'
+  ) {
     val = val.toJSON();
   }
   if (typeof val !== 'string') {
     val = JSON.stringify(val);
     if (!escaped && val.indexOf('"') !== -1) {
-      return ' ' + key + '=\'' + val.replace(/'/g, '&#39;') + '\'';
+      return ' ' + key + "='" + val.replace(/'/g, '&#39;') + "'";
     }
   }
   if (escaped) val = pug_escape(val);
   return ' ' + key + '="' + val + '"';
-};
+}
 
 /**
  * Render the given attributes object.
@@ -154,7 +165,7 @@ function pug_attr(key, val, escaped, terse) {
  * @return {String}
  */
 exports.attrs = pug_attrs;
-function pug_attrs(obj, terse){
+function pug_attrs(obj, terse) {
   var attrs = '';
 
   for (var key in obj) {
@@ -174,7 +185,7 @@ function pug_attrs(obj, terse){
   }
 
   return attrs;
-};
+}
 
 /**
  * Escape the given string of `html`.
@@ -186,7 +197,7 @@ function pug_attrs(obj, terse){
 
 var pug_match_html = /["&<>]/;
 exports.escape = pug_escape;
-function pug_escape(_html){
+function pug_escape(_html) {
   var html = '' + _html;
   var regexResult = pug_match_html.exec(html);
   if (!regexResult) return _html;
@@ -195,11 +206,20 @@ function pug_escape(_html){
   var i, lastIndex, escape;
   for (i = regexResult.index, lastIndex = 0; i < html.length; i++) {
     switch (html.charCodeAt(i)) {
-      case 34: escape = '&quot;'; break;
-      case 38: escape = '&amp;'; break;
-      case 60: escape = '&lt;'; break;
-      case 62: escape = '&gt;'; break;
-      default: continue;
+      case 34:
+        escape = '&quot;';
+        break;
+      case 38:
+        escape = '&amp;';
+        break;
+      case 60:
+        escape = '&lt;';
+        break;
+      case 62:
+        escape = '&gt;';
+        break;
+      default:
+        continue;
     }
     if (lastIndex !== i) result += html.substring(lastIndex, i);
     lastIndex = i + 1;
@@ -207,7 +227,7 @@ function pug_escape(_html){
   }
   if (lastIndex !== i) return result + html.substring(lastIndex, i);
   else return result;
-};
+}
 
 /**
  * Re-throw the given `err` in context to the
@@ -221,36 +241,42 @@ function pug_escape(_html){
  */
 
 exports.rethrow = pug_rethrow;
-function pug_rethrow(err, filename, lineno, str){
+function pug_rethrow(err, filename, lineno, str) {
   if (!(err instanceof Error)) throw err;
   if ((typeof window != 'undefined' || !filename) && !str) {
     err.message += ' on line ' + lineno;
     throw err;
   }
   try {
-    str = str || require('fs').readFileSync(filename, 'utf8')
+    str = str || require('fs').readFileSync(filename, 'utf8');
   } catch (ex) {
-    pug_rethrow(err, null, lineno)
+    pug_rethrow(err, null, lineno);
   }
-  var context = 3
-    , lines = str.split('\n')
-    , start = Math.max(lineno - context, 0)
-    , end = Math.min(lines.length, lineno + context);
+  var context = 3,
+    lines = str.split('\n'),
+    start = Math.max(lineno - context, 0),
+    end = Math.min(lines.length, lineno + context);
 
   // Error context
-  var context = lines.slice(start, end).map(function(line, i){
-    var curr = i + start + 1;
-    return (curr == lineno ? '  > ' : '    ')
-      + curr
-      + '| '
-      + line;
-  }).join('\n');
+  var context = lines
+    .slice(start, end)
+    .map(function(line, i) {
+      var curr = i + start + 1;
+      return (curr == lineno ? '  > ' : '    ') + curr + '| ' + line;
+    })
+    .join('\n');
 
   // Alter exception message
   err.path = filename;
   try {
-    err.message = (filename || 'Pug') + ':' + lineno
-      + '\n' + context + '\n\n' + err.message;
+    err.message =
+      (filename || 'Pug') +
+      ':' +
+      lineno +
+      '\n' +
+      context +
+      '\n\n' +
+      err.message;
   } catch (e) {}
   throw err;
-};
+}
diff --git a/packages/pug-runtime/package.json b/packages/pug-runtime/package.json
index c13a435ce..e2e569c4d 100644
--- a/packages/pug-runtime/package.json
+++ b/packages/pug-runtime/package.json
@@ -18,7 +18,8 @@
   ],
   "scripts": {
     "prepublish": "node prepublish",
-    "pretest": "npm run prepublish"
+    "pretest": "npm run prepublish",
+    "build": "node prepublish"
   },
   "repository": {
     "type": "git",
diff --git a/packages/pug-runtime/prepublish.js b/packages/pug-runtime/prepublish.js
index 2544f0d56..a9f6abca3 100644
--- a/packages/pug-runtime/prepublish.js
+++ b/packages/pug-runtime/prepublish.js
@@ -13,38 +13,58 @@ var source = fs.readFileSync(__dirname + '/index.js', 'utf8');
 var ast = uglify.parse(source);
 
 var dependencies = {};
-var internals = {'dependencies': true, 'internals': true};
+var internals = {dependencies: true, internals: true};
 var sources = {};
-ast.body.forEach(function (node) {
+ast.body.forEach(function(node) {
   var name;
   switch (node.TYPE) {
-    case 'Defun': name = node.name.name;                break;
-    case 'Var':   name = node.definitions[0].name.name; break;
+    case 'Defun':
+      name = node.name.name;
+      break;
+    case 'Var':
+      name = node.definitions[0].name.name;
+      break;
   }
   if (!name || !/^pug\_/.test(name)) return;
   name = name.replace(/^pug\_/, '');
 
-  var src = uglify.minify(source.substring(node.start.pos, node.end.endpos), {fromString: true}).code;
+  var src = uglify.minify(source.substring(node.start.pos, node.end.endpos), {
+    fromString: true,
+  }).code;
   sources[name] = src;
 
   dependencies[name] = [];
   if (node.TYPE === 'Defun') {
     var ast = uglify.parse(src);
     ast.figure_out_scope();
-    var globals = ast.globals.map(function (val, key) {
+    var globals = ast.globals.map(function(val, key) {
       return key;
     });
-    dependencies[name] = globals.filter(function (key) { return /^pug\_/.test(key); })
-                                .map(function (key) { return key.replace(/^pug\_/, ''); });
+    dependencies[name] = globals
+      .filter(function(key) {
+        return /^pug\_/.test(key);
+      })
+      .map(function(key) {
+        return key.replace(/^pug\_/, '');
+      });
   }
 
   if (!runtime[name]) internals[name] = true;
 });
 
-Object.keys(dependencies).forEach(function (fn) {
+Object.keys(dependencies).forEach(function(fn) {
   dependencies[fn] = dependencies[fn].sort();
 });
 
-fs.writeFileSync(__dirname + '/lib/dependencies.js', 'module.exports = ' + JSON.stringify(dependencies, null, 2) + '\n');
-fs.writeFileSync(__dirname + '/lib/internals.js', 'module.exports = ' + JSON.stringify(internals, null, 2) + '\n');
-fs.writeFileSync(__dirname + '/lib/sources.js', 'module.exports = ' + JSON.stringify(sources, null, 2) + '\n');
+fs.writeFileSync(
+  __dirname + '/lib/dependencies.js',
+  'module.exports = ' + JSON.stringify(dependencies, null, 2) + '\n'
+);
+fs.writeFileSync(
+  __dirname + '/lib/internals.js',
+  'module.exports = ' + JSON.stringify(internals, null, 2) + '\n'
+);
+fs.writeFileSync(
+  __dirname + '/lib/sources.js',
+  'module.exports = ' + JSON.stringify(sources, null, 2) + '\n'
+);
diff --git a/packages/pug-runtime/test/index.test.js b/packages/pug-runtime/test/index.test.js
index 416489f01..1bf0f6e1f 100644
--- a/packages/pug-runtime/test/index.test.js
+++ b/packages/pug-runtime/test/index.test.js
@@ -5,15 +5,15 @@ var build = require('../build');
 var wrap = require('../wrap');
 
 function addTest(name, fn) {
-  test(name, function () {
-
+  test(name, function() {
     fn(runtime[name]);
     fn(Function('', build([name]) + ';return pug_' + name + ';')());
-    fn(wrap('function t() {return pug.' + name + ';}', 't')())
+    fn(wrap('function t() {return pug.' + name + ';}', 't')());
   });
 }
 
-addTest('attr', function (attr) { // (key, val, escaped, terse)
+addTest('attr', function(attr) {
+  // (key, val, escaped, terse)
   var stringToJSON = String.prototype.toJSON;
 
   String.prototype.toJSON = function() {
@@ -39,20 +39,56 @@ addTest('attr', function (attr) { // (key, val, escaped, terse)
   expect(attr('key', undefined, false, false)).toBe('');
 
   // Date Attributes
-  expect(attr('key', new Date('2014-12-28T16:46:06.962Z'), true, true)).toBe(' key="2014-12-28T16:46:06.962Z"');
-  expect(attr('key', new Date('2014-12-28T16:46:06.962Z'), false, true)).toBe(' key="2014-12-28T16:46:06.962Z"');
-  expect(attr('key', new Date('2014-12-28T16:46:06.962Z'), true, false)).toBe(' key="2014-12-28T16:46:06.962Z"');
-  expect(attr('key', new Date('2014-12-28T16:46:06.962Z'), false, false)).toBe(' key="2014-12-28T16:46:06.962Z"');
+  expect(attr('key', new Date('2014-12-28T16:46:06.962Z'), true, true)).toBe(
+    ' key="2014-12-28T16:46:06.962Z"'
+  );
+  expect(attr('key', new Date('2014-12-28T16:46:06.962Z'), false, true)).toBe(
+    ' key="2014-12-28T16:46:06.962Z"'
+  );
+  expect(attr('key', new Date('2014-12-28T16:46:06.962Z'), true, false)).toBe(
+    ' key="2014-12-28T16:46:06.962Z"'
+  );
+  expect(attr('key', new Date('2014-12-28T16:46:06.962Z'), false, false)).toBe(
+    ' key="2014-12-28T16:46:06.962Z"'
+  );
 
   // Custom JSON Attributes
-  expect(attr('key', {toJSON: function () { return 'bar'; }}, true, false)).toBe(' key="bar"');
-  expect(attr('key', {toJSON: function () { return {foo: 'bar'}; }}, true, false)).toBe(' key="{&quot;foo&quot;:&quot;bar&quot;}"');
+  expect(
+    attr(
+      'key',
+      {
+        toJSON: function() {
+          return 'bar';
+        },
+      },
+      true,
+      false
+    )
+  ).toBe(' key="bar"');
+  expect(
+    attr(
+      'key',
+      {
+        toJSON: function() {
+          return {foo: 'bar'};
+        },
+      },
+      true,
+      false
+    )
+  ).toBe(' key="{&quot;foo&quot;:&quot;bar&quot;}"');
 
   // JSON Attributes
-  expect(attr('key', {foo: 'bar'}, true, true)).toBe(' key="{&quot;foo&quot;:&quot;bar&quot;}"');
+  expect(attr('key', {foo: 'bar'}, true, true)).toBe(
+    ' key="{&quot;foo&quot;:&quot;bar&quot;}"'
+  );
   expect(attr('key', {foo: 'bar'}, false, true)).toBe(' key=\'{"foo":"bar"}\'');
-  expect(attr('key', {foo: 'don\'t'}, true, true)).toBe(' key="{&quot;foo&quot;:&quot;don\'t&quot;}"');
-  expect(attr('key', {foo: 'don\'t'}, false, true)).toBe(' key=\'{"foo":"don&#39;t"}\'');
+  expect(attr('key', {foo: "don't"}, true, true)).toBe(
+    ' key="{&quot;foo&quot;:&quot;don\'t&quot;}"'
+  );
+  expect(attr('key', {foo: "don't"}, false, true)).toBe(
+    ' key=\'{"foo":"don&#39;t"}\''
+  );
 
   // Number attributes
   expect(attr('key', 500, true, true)).toBe(' key="500"');
@@ -73,7 +109,8 @@ addTest('attr', function (attr) { // (key, val, escaped, terse)
   String.prototype.toJSON = stringToJSON;
 });
 
-addTest('attrs', function (attrs) { // (obj, terse)
+addTest('attrs', function(attrs) {
+  // (obj, terse)
   expect(attrs({foo: 'bar'}, true)).toBe(' foo="bar"');
   expect(attrs({foo: 'bar'}, false)).toBe(' foo="bar"');
   expect(attrs({foo: 'bar', hoo: 'boo'}, true)).toBe(' foo="bar" hoo="boo"');
@@ -84,24 +121,35 @@ addTest('attrs', function (attrs) { // (obj, terse)
   expect(attrs({class: ''}, false)).toBe('');
   expect(attrs({class: ['foo', {bar: true}]}, true)).toBe(' class="foo bar"');
   expect(attrs({class: ['foo', {bar: true}]}, false)).toBe(' class="foo bar"');
-  expect(attrs({class: ['foo', {bar: true}], foo: 'bar'}, true)).toBe(' class="foo bar" foo="bar"');
-  expect(attrs({foo: 'bar', class: ['foo', {bar: true}]}, false)).toBe(' class="foo bar" foo="bar"');
+  expect(attrs({class: ['foo', {bar: true}], foo: 'bar'}, true)).toBe(
+    ' class="foo bar" foo="bar"'
+  );
+  expect(attrs({foo: 'bar', class: ['foo', {bar: true}]}, false)).toBe(
+    ' class="foo bar" foo="bar"'
+  );
   expect(attrs({style: 'foo: bar;'}, true)).toBe(' style="foo: bar;"');
   expect(attrs({style: 'foo: bar;'}, false)).toBe(' style="foo: bar;"');
   expect(attrs({style: {foo: 'bar'}}, true)).toBe(' style="foo:bar;"');
   expect(attrs({style: {foo: 'bar'}}, false)).toBe(' style="foo:bar;"');
 });
 
-addTest('classes', function (classes) {
+addTest('classes', function(classes) {
   expect(classes(['foo', 'bar'])).toBe('foo bar');
-  expect(classes([['foo', 'bar'], ['baz', 'bash']])).toBe('foo bar baz bash');
-  expect(classes([['foo', 'bar'], {baz: true, bash: false}])).toBe('foo bar baz');
-  expect(classes([['fo<o', 'bar'], {'ba>z': true, bash: false}], [true, false])).toBe(
-    'fo&lt;o bar ba>z'
+  expect(
+    classes([
+      ['foo', 'bar'],
+      ['baz', 'bash'],
+    ])
+  ).toBe('foo bar baz bash');
+  expect(classes([['foo', 'bar'], {baz: true, bash: false}])).toBe(
+    'foo bar baz'
   );
+  expect(
+    classes([['fo<o', 'bar'], {'ba>z': true, bash: false}], [true, false])
+  ).toBe('fo&lt;o bar ba>z');
 });
 
-addTest('escape', function (escape) {
+addTest('escape', function(escape) {
   expect(escape('foo')).toBe('foo');
   expect(escape(10)).toBe(10);
   expect(escape('foo<bar')).toBe('foo&lt;bar');
@@ -111,33 +159,61 @@ addTest('escape', function (escape) {
   expect(escape('foo&<>"bar"')).toBe('foo&amp;&lt;&gt;&quot;bar&quot;');
 });
 
-addTest('merge', function (merge) {
+addTest('merge', function(merge) {
   expect(merge({foo: 'bar'}, {baz: 'bash'})).toEqual({foo: 'bar', baz: 'bash'});
-  expect(merge([{foo: 'bar'}, {baz: 'bash'}, {bing: 'bong'}])).toEqual({foo: 'bar', baz: 'bash', bing: 'bong'});
-  expect(merge({class: 'bar'}, {class: 'bash'})).toEqual({class: ['bar', 'bash']});
-  expect(merge({class: ['bar']}, {class: 'bash'})).toEqual({class: ['bar', 'bash']});
-  expect(merge({class: 'bar'}, {class: ['bash']})).toEqual({class: ['bar', 'bash']});
+  expect(merge([{foo: 'bar'}, {baz: 'bash'}, {bing: 'bong'}])).toEqual({
+    foo: 'bar',
+    baz: 'bash',
+    bing: 'bong',
+  });
+  expect(merge({class: 'bar'}, {class: 'bash'})).toEqual({
+    class: ['bar', 'bash'],
+  });
+  expect(merge({class: ['bar']}, {class: 'bash'})).toEqual({
+    class: ['bar', 'bash'],
+  });
+  expect(merge({class: 'bar'}, {class: ['bash']})).toEqual({
+    class: ['bar', 'bash'],
+  });
   expect(merge({class: 'bar'}, {class: null})).toEqual({class: ['bar']});
   expect(merge({class: null}, {class: ['bar']})).toEqual({class: ['bar']});
   expect(merge({}, {class: ['bar']})).toEqual({class: ['bar']});
   expect(merge({class: ['bar']}, {})).toEqual({class: ['bar']});
 
-  expect(merge({style: 'foo:bar'}, {style: 'baz:bash'})).toEqual({style: 'foo:bar;baz:bash;'});
-  expect(merge({style: 'foo:bar;'}, {style: 'baz:bash'})).toEqual({style: 'foo:bar;baz:bash;'});
-  expect(merge({style: {foo: 'bar'}}, {style: 'baz:bash'})).toEqual({style: 'foo:bar;baz:bash;'});
-  expect(merge({style: {foo: 'bar'}}, {style: {baz: 'bash'}})).toEqual({style: 'foo:bar;baz:bash;'});
+  expect(merge({style: 'foo:bar'}, {style: 'baz:bash'})).toEqual({
+    style: 'foo:bar;baz:bash;',
+  });
+  expect(merge({style: 'foo:bar;'}, {style: 'baz:bash'})).toEqual({
+    style: 'foo:bar;baz:bash;',
+  });
+  expect(merge({style: {foo: 'bar'}}, {style: 'baz:bash'})).toEqual({
+    style: 'foo:bar;baz:bash;',
+  });
+  expect(merge({style: {foo: 'bar'}}, {style: {baz: 'bash'}})).toEqual({
+    style: 'foo:bar;baz:bash;',
+  });
   expect(merge({style: 'foo:bar'}, {style: null})).toEqual({style: 'foo:bar;'});
-  expect(merge({style: 'foo:bar;'}, {style: null})).toEqual({style: 'foo:bar;'});
-  expect(merge({style: {foo: 'bar'}}, {style: null})).toEqual({style: 'foo:bar;'});
-  expect(merge({style: null}, {style: 'baz:bash'})).toEqual({style: 'baz:bash;'});
-  expect(merge({style: null}, {style: 'baz:bash'})).toEqual({style: 'baz:bash;'});
-  expect(merge({style: null}, {style: 'baz:bash'})).toEqual({style: 'baz:bash;'});
+  expect(merge({style: 'foo:bar;'}, {style: null})).toEqual({
+    style: 'foo:bar;',
+  });
+  expect(merge({style: {foo: 'bar'}}, {style: null})).toEqual({
+    style: 'foo:bar;',
+  });
+  expect(merge({style: null}, {style: 'baz:bash'})).toEqual({
+    style: 'baz:bash;',
+  });
+  expect(merge({style: null}, {style: 'baz:bash'})).toEqual({
+    style: 'baz:bash;',
+  });
+  expect(merge({style: null}, {style: 'baz:bash'})).toEqual({
+    style: 'baz:bash;',
+  });
   expect(merge({}, {style: 'baz:bash'})).toEqual({style: 'baz:bash;'});
   expect(merge({}, {style: 'baz:bash'})).toEqual({style: 'baz:bash;'});
   expect(merge({}, {style: 'baz:bash'})).toEqual({style: 'baz:bash;'});
 });
 
-addTest('style', function (style) {
+addTest('style', function(style) {
   expect(style(null)).toBe('');
   expect(style('')).toBe('');
   expect(style('foo: bar')).toBe('foo: bar');
diff --git a/packages/pug-runtime/wrap.js b/packages/pug-runtime/wrap.js
index 0a3250087..5acc2052a 100644
--- a/packages/pug-runtime/wrap.js
+++ b/packages/pug-runtime/wrap.js
@@ -3,8 +3,8 @@ var runtime = require('./');
 module.exports = wrap;
 function wrap(template, templateName) {
   templateName = templateName || 'template';
-  return Function('pug',
-    template + '\n' +
-    'return ' + templateName + ';'
+  return Function(
+    'pug',
+    template + '\n' + 'return ' + templateName + ';'
   )(runtime);
 }
diff --git a/packages/pug-strip-comments/index.js b/packages/pug-strip-comments/index.js
index 7d8bddea8..6da4f2ba0 100644
--- a/packages/pug-strip-comments/index.js
+++ b/packages/pug-strip-comments/index.js
@@ -4,18 +4,18 @@ var error = require('pug-error');
 
 module.exports = stripComments;
 
-function unexpectedToken (type, occasion, filename, line) {
+function unexpectedToken(type, occasion, filename, line) {
   var msg = '`' + type + '` encountered when ' + occasion;
-  throw error('UNEXPECTED_TOKEN', msg, { filename: filename, line: line });
+  throw error('UNEXPECTED_TOKEN', msg, {filename: filename, line: line});
 }
 
-function stripComments (input, options) {
+function stripComments(input, options) {
   options = options || {};
 
   // Default: strip unbuffered comments and leave buffered ones alone
   var stripUnbuffered = options.stripUnbuffered !== false;
-  var stripBuffered   = options.stripBuffered   === true;
-  var filename        = options.filename;
+  var stripBuffered = options.stripBuffered === true;
+  var filename = options.filename;
 
   var out = [];
   // If we have encountered a comment token and are not sure if we have gotten
@@ -25,12 +25,15 @@ function stripComments (input, options) {
   // `end-pipeless-text` should be ignored
   var inPipelessText = false;
 
-  return input.filter(function (tok) {
+  return input.filter(function(tok) {
     switch (tok.type) {
       case 'comment':
         if (inComment) {
           unexpectedToken(
-            'comment', 'already in a comment', filename, tok.line
+            'comment',
+            'already in a comment',
+            filename,
+            tok.line
           );
         } else {
           inComment = tok.buffer ? stripBuffered : stripUnbuffered;
@@ -40,8 +43,10 @@ function stripComments (input, options) {
         if (!inComment) return true;
         if (inPipelessText) {
           unexpectedToken(
-            'start-pipeless-text', 'already in pipeless text mode',
-            filename, tok.line
+            'start-pipeless-text',
+            'already in pipeless text mode',
+            filename,
+            tok.line
           );
         }
         inPipelessText = true;
@@ -50,8 +55,10 @@ function stripComments (input, options) {
         if (!inComment) return true;
         if (!inPipelessText) {
           unexpectedToken(
-            'end-pipeless-text', 'not in pipeless text mode',
-            filename, tok.line
+            'end-pipeless-text',
+            'not in pipeless text mode',
+            filename,
+            tok.line
           );
         }
         inPipelessText = false;
diff --git a/packages/pug-strip-comments/test/index.test.js b/packages/pug-strip-comments/test/index.test.js
index 7f3b51c18..f0e3ffc90 100644
--- a/packages/pug-strip-comments/test/index.test.js
+++ b/packages/pug-strip-comments/test/index.test.js
@@ -6,12 +6,12 @@ var lineJSON = require('line-json');
 var strip = require('../');
 
 var dir = __dirname + '/cases/';
-fs.readdirSync(dir).forEach(function (testCase) {
+fs.readdirSync(dir).forEach(function(testCase) {
   if (/\.input\.json$/.test(testCase)) {
-    test(testCase, function () {
+    test(testCase, function() {
       var stem = testCase.replace(/\.input\.json$/, '.');
 
-      function test (name, options) {
+      function test(name, options) {
         var input = fs.readFileSync(dir + testCase, 'utf8');
         input = lineJSON.parse(input);
 
@@ -20,16 +20,16 @@ fs.readdirSync(dir).forEach(function (testCase) {
       }
 
       test('unbuffered');
-      test('buffered',   { stripBuffered: true, stripUnbuffered: false });
-      test('both',       { stripBuffered: true });
+      test('buffered', {stripBuffered: true, stripUnbuffered: false});
+      test('both', {stripBuffered: true});
     });
   }
 });
 
 var edir = __dirname + '/errors/';
-fs.readdirSync(edir).forEach(function (testCase) {
+fs.readdirSync(edir).forEach(function(testCase) {
   if (/\.input\.json$/.test(testCase)) {
-    test(testCase, function () {
+    test(testCase, function() {
       var stem = testCase.replace(/\.input\.json$/, '.');
 
       var input = fs.readFileSync(edir + testCase, 'utf8');
@@ -43,7 +43,7 @@ fs.readdirSync(edir).forEach(function (testCase) {
         expect({
           msg: ex.msg,
           code: ex.code,
-          line: ex.line
+          line: ex.line,
         }).toMatchSnapshot();
       }
     });
diff --git a/packages/pug-walk/index.js b/packages/pug-walk/index.js
index 138aef0b3..9972e4b2f 100644
--- a/packages/pug-walk/index.js
+++ b/packages/pug-walk/index.js
@@ -7,17 +7,20 @@ function walkAST(ast, before, after, options) {
     after = null;
   }
   options = options || {includeDependencies: false};
-  var parents = options.parents = options.parents || [];
+  var parents = (options.parents = options.parents || []);
 
   var replace = function replace(replacement) {
     if (Array.isArray(replacement) && !replace.arrayAllowed) {
-      throw new Error('replace() can only be called with an array if the last parent is a Block or NamedBlock');
+      throw new Error(
+        'replace() can only be called with an array if the last parent is a Block or NamedBlock'
+      );
     }
     ast = replacement;
   };
-  replace.arrayAllowed = parents[0] && (
-    /^(Named)?Block$/.test(parents[0].type) ||
-    parents[0].type === 'RawInclude' && ast.type === 'IncludeFilter');
+  replace.arrayAllowed =
+    parents[0] &&
+    (/^(Named)?Block$/.test(parents[0].type) ||
+      (parents[0].type === 'RawInclude' && ast.type === 'IncludeFilter'));
 
   if (before) {
     var result = before(ast, replace);
@@ -105,7 +108,7 @@ function walkAST(ast, before, after, options) {
   return ast;
 
   function walkAndMergeNodes(nodes) {
-    return nodes.reduce(function (nodes, node) {
+    return nodes.reduce(function(nodes, node) {
       var result = walkAST(node, before, after, options);
       if (Array.isArray(result)) {
         return nodes.concat(result);
diff --git a/packages/pug-walk/test/index.test.js b/packages/pug-walk/test/index.test.js
index 7881da99e..70c4698f9 100644
--- a/packages/pug-walk/test/index.test.js
+++ b/packages/pug-walk/test/index.test.js
@@ -5,83 +5,91 @@ var lex = require('pug-lexer');
 var parse = require('pug-parser');
 var walk = require('../');
 
-test('simple', function () {
-  var ast = walk(parse(lex('.my-class foo')), function before(node, replace) {
-    // called before walking the children of `node`
-    // to replace the node, call `replace(newNode)`
-    // return `false` to skip descending
-    if (node.type === 'Text') {
-      replace({
-        type: 'Text',
-        val: 'bar',
-        line: node.line,
-        column: node.column
-      });
+test('simple', function() {
+  var ast = walk(
+    parse(lex('.my-class foo')),
+    function before(node, replace) {
+      // called before walking the children of `node`
+      // to replace the node, call `replace(newNode)`
+      // return `false` to skip descending
+      if (node.type === 'Text') {
+        replace({
+          type: 'Text',
+          val: 'bar',
+          line: node.line,
+          column: node.column,
+        });
+      }
+    },
+    function after(node, replace) {
+      // called before walking the children of `node`
+      // to replace the node, call `replace(newNode)`
     }
-  }, function after(node, replace) {
-    // called before walking the children of `node`
-    // to replace the node, call `replace(newNode)`
-  });
+  );
   expect(ast).toEqual(parse(lex('.my-class bar')));
 });
 
-describe('replace([])', function () {
-  test('block flattening', function () {
+describe('replace([])', function() {
+  test('block flattening', function() {
     var called = [];
-    var ast = walk({
-      type: 'Block',
-      nodes: [
-        {
-          type: 'Block',
-          nodes: [
-            {
-              type: 'Block',
-              nodes: [
-                {
-                  type: 'Text',
-                  val: 'a'
-                },
-                {
-                  type: 'Text',
-                  val: 'b'
-                }
-              ]
-            },
-            {
-              type: 'Text',
-              val: 'c'
-            }
-          ]
-        },
-        {
-          type: 'Text',
-          val: 'd'
+    var ast = walk(
+      {
+        type: 'Block',
+        nodes: [
+          {
+            type: 'Block',
+            nodes: [
+              {
+                type: 'Block',
+                nodes: [
+                  {
+                    type: 'Text',
+                    val: 'a',
+                  },
+                  {
+                    type: 'Text',
+                    val: 'b',
+                  },
+                ],
+              },
+              {
+                type: 'Text',
+                val: 'c',
+              },
+            ],
+          },
+          {
+            type: 'Text',
+            val: 'd',
+          },
+        ],
+      },
+      function(node, replace) {
+        if (node.type === 'Text') {
+          called.push('before ' + node.val);
+          if (node.val === 'a') {
+            assert(replace.arrayAllowed, 'replace.arrayAllowed set wrongly');
+            replace([
+              {
+                type: 'Text',
+                val: 'e',
+              },
+              {
+                type: 'Text',
+                val: 'f',
+              },
+            ]);
+          }
         }
-      ]
-    }, function (node, replace) {
-      if (node.type === 'Text') {
-        called.push('before ' + node.val);
-        if (node.val === 'a') {
-          assert(replace.arrayAllowed, 'replace.arrayAllowed set wrongly');
-          replace([
-            {
-              type: 'Text',
-              val: 'e'
-            },
-            {
-              type: 'Text',
-              val: 'f'
-            }
-          ]);
+      },
+      function(node, replace) {
+        if (node.type === 'Block' && replace.arrayAllowed) {
+          replace(node.nodes);
+        } else if (node.type === 'Text') {
+          called.push('after ' + node.val);
         }
       }
-    }, function (node, replace) {
-      if (node.type === 'Block' && replace.arrayAllowed) {
-        replace(node.nodes);
-      } else if (node.type === 'Text') {
-        called.push('after ' + node.val);
-      }
-    });
+    );
 
     expect(ast).toEqual({
       type: 'Block',
@@ -90,32 +98,39 @@ describe('replace([])', function () {
         {type: 'Text', val: 'f'},
         {type: 'Text', val: 'b'},
         {type: 'Text', val: 'c'},
-        {type: 'Text', val: 'd'}
-      ]
+        {type: 'Text', val: 'd'},
+      ],
     });
 
-    assert.deepEqual(called, [
-      'before a',
+    assert.deepEqual(
+      called,
+      [
+        'before a',
 
-      'before e',
-      'after e',
+        'before e',
+        'after e',
 
-      'before f',
-      'after f',
+        'before f',
+        'after f',
 
-      'before b',
-      'after b',
+        'before b',
+        'after b',
 
-      'before c',
-      'after c',
+        'before c',
+        'after c',
 
-      'before d',
-      'after d'
-    ], 'before() and after() called incorrectly: ' + JSON.stringify(called));
+        'before d',
+        'after d',
+      ],
+      'before() and after() called incorrectly: ' + JSON.stringify(called)
+    );
   });
 
-  test('adding include filters', function () {
-    var ast = walk(parse(lex('include:filter1:filter2 file')), function (node, replace) {
+  test('adding include filters', function() {
+    var ast = walk(parse(lex('include:filter1:filter2 file')), function(
+      node,
+      replace
+    ) {
       if (node.type === 'IncludeFilter') {
         assert(replace.arrayAllowed);
         if (node.name === 'filter1') {
@@ -127,15 +142,15 @@ describe('replace([])', function () {
               name: firstFilter,
               attrs: [],
               line: node.line,
-              column: node.column
+              column: node.column,
             },
             {
               type: 'IncludeFilter',
               name: 'filter4',
               attrs: [],
               line: node.line,
-              column: node.column + firstFilter.length + 1
-            }
+              column: node.column + firstFilter.length + 1,
+            },
           ]);
         } else if (node.name === 'filter2') {
           replace([]);
@@ -146,11 +161,15 @@ describe('replace([])', function () {
     expect(ast).toEqual(parse(lex('include:filter3:filter4 file')));
   });
 
-  test('fails when parent is not Block', function () {
-    walk(parse(lex('p content')), function (node, replace) {
-      if (node.type === 'Block' && node.nodes[0] && node.nodes[0].type === 'Text') {
+  test('fails when parent is not Block', function() {
+    walk(parse(lex('p content')), function(node, replace) {
+      if (
+        node.type === 'Block' &&
+        node.nodes[0] &&
+        node.nodes[0].type === 'Text'
+      ) {
         assert(!replace.arrayAllowed, 'replace.arrayAllowed set wrongly');
-        assert.throws(function () {
+        assert.throws(function() {
           replace([]);
         });
       }
diff --git a/packages/pug/examples/attributes.js b/packages/pug/examples/attributes.js
index ba5cc9931..7744e1ae2 100644
--- a/packages/pug/examples/attributes.js
+++ b/packages/pug/examples/attributes.js
@@ -1,11 +1,10 @@
-
 /**
  * Module dependencies.
  */
 
-var pug = require('../')
-  , path = __dirname + '/attributes.pug'
-  , str = require('fs').readFileSync(path, 'utf8')
-  , fn = pug.compile(str, { filename: path, pretty: true });
+var pug = require('../'),
+  path = __dirname + '/attributes.pug',
+  str = require('fs').readFileSync(path, 'utf8'),
+  fn = pug.compile(str, {filename: path, pretty: true});
 
-console.log(fn({ name: 'tj' }));
\ No newline at end of file
+console.log(fn({name: 'tj'}));
diff --git a/packages/pug/examples/code.js b/packages/pug/examples/code.js
index d797ce537..6d16bc788 100644
--- a/packages/pug/examples/code.js
+++ b/packages/pug/examples/code.js
@@ -1,16 +1,15 @@
-
 /**
  * Module dependencies.
  */
 
-var pug = require('../')
-  , path = __dirname + '/code.pug'
-  , str = require('fs').readFileSync(path, 'utf8')
-  , fn = pug.compile(str, { filename: path, pretty: true });
+var pug = require('../'),
+  path = __dirname + '/code.pug',
+  str = require('fs').readFileSync(path, 'utf8'),
+  fn = pug.compile(str, {filename: path, pretty: true});
 
 var users = {
-  tj: { age: 23, email: 'tj@vision-media.ca', isA: 'human' },
-  tobi: { age: 1, email: 'tobi@is-amazing.com', isA: 'ferret' }
+  tj: {age: 23, email: 'tj@vision-media.ca', isA: 'human'},
+  tobi: {age: 1, email: 'tobi@is-amazing.com', isA: 'ferret'},
 };
 
-console.log(fn({ users: users }));
\ No newline at end of file
+console.log(fn({users: users}));
diff --git a/packages/pug/examples/dynamicscript.js b/packages/pug/examples/dynamicscript.js
index 21958a85e..a0d2739d8 100644
--- a/packages/pug/examples/dynamicscript.js
+++ b/packages/pug/examples/dynamicscript.js
@@ -1,4 +1,3 @@
-
 /**
  * Module dependencies.
  */
@@ -7,9 +6,9 @@ var pug = require('../');
 
 var locals = {
   users: {
-    tj: { age: 23, email: 'tj@vision-media.ca', isA: 'human' },
-    tobi: { age: 1, email: 'tobi@is-amazing.com', isA: 'ferret' }
-  }
+    tj: {age: 23, email: 'tj@vision-media.ca', isA: 'human'},
+    tobi: {age: 1, email: 'tobi@is-amazing.com', isA: 'ferret'},
+  },
 };
 
 var fn = pug.compileFile(__dirname + '/dynamicscript.pug');
diff --git a/packages/pug/examples/each.js b/packages/pug/examples/each.js
index 53bac827a..d5a864ca3 100644
--- a/packages/pug/examples/each.js
+++ b/packages/pug/examples/each.js
@@ -1,16 +1,15 @@
-
 /**
  * Module dependencies.
  */
 
-var pug = require('../')
-  , path = __dirname + '/each.pug'
-  , str = require('fs').readFileSync(path, 'utf8')
-  , fn = pug.compile(str, { filename: path, pretty: true });
+var pug = require('../'),
+  path = __dirname + '/each.pug',
+  str = require('fs').readFileSync(path, 'utf8'),
+  fn = pug.compile(str, {filename: path, pretty: true});
 
 var users = {
-  tj: { age: 23, email: 'tj@vision-media.ca', isA: 'human' },
-  tobi: { age: 1, email: 'tobi@is-amazing.com', isA: 'ferret' }
+  tj: {age: 23, email: 'tj@vision-media.ca', isA: 'human'},
+  tobi: {age: 1, email: 'tobi@is-amazing.com', isA: 'ferret'},
 };
 
-console.log(fn({ users: users }));
\ No newline at end of file
+console.log(fn({users: users}));
diff --git a/packages/pug/examples/extend.js b/packages/pug/examples/extend.js
index 6adc86f1e..5aed4147d 100644
--- a/packages/pug/examples/extend.js
+++ b/packages/pug/examples/extend.js
@@ -1,18 +1,19 @@
-
 /**
  * Module dependencies.
  */
 
-var pug = require('../')
-  , path = __dirname + '/extend.pug'
-  , str = require('fs').readFileSync(path, 'utf8')
-  , fn = pug.compile(str, { filename: path, pretty: true });
+var pug = require('../'),
+  path = __dirname + '/extend.pug',
+  str = require('fs').readFileSync(path, 'utf8'),
+  fn = pug.compile(str, {filename: path, pretty: true});
 
-var tobi = { name: 'tobi', age: 2 };
-var loki = { name: 'loki', age: 1 };
-var jane = { name: 'jane', age: 5 };
+var tobi = {name: 'tobi', age: 2};
+var loki = {name: 'loki', age: 1};
+var jane = {name: 'jane', age: 5};
 
-console.log(fn({
-    title: 'pets'
-  , pets: [tobi, loki, jane]
-}));
\ No newline at end of file
+console.log(
+  fn({
+    title: 'pets',
+    pets: [tobi, loki, jane],
+  })
+);
diff --git a/packages/pug/examples/form.js b/packages/pug/examples/form.js
index e706c47b1..3d888534e 100644
--- a/packages/pug/examples/form.js
+++ b/packages/pug/examples/form.js
@@ -1,18 +1,17 @@
-
 /**
  * Module dependencies.
  */
 
-var pug = require('../')
-  , path = __dirname + '/form.pug'
-  , str = require('fs').readFileSync(path, 'utf8')
-  , fn = pug.compile(str, { filename: path, pretty: true });
+var pug = require('../'),
+  path = __dirname + '/form.pug',
+  str = require('fs').readFileSync(path, 'utf8'),
+  fn = pug.compile(str, {filename: path, pretty: true});
 
 var user = {
   name: 'TJ',
   email: 'tj@vision-media.ca',
   city: 'Victoria',
-  province: 'BC'
+  province: 'BC',
 };
 
-console.log(fn({ user: user }));
\ No newline at end of file
+console.log(fn({user: user}));
diff --git a/packages/pug/examples/includes.js b/packages/pug/examples/includes.js
index e2dfe0e23..5ea1a5945 100644
--- a/packages/pug/examples/includes.js
+++ b/packages/pug/examples/includes.js
@@ -1,11 +1,10 @@
-
 /**
  * Module dependencies.
  */
 
-var pug = require('../')
-  , path = __dirname + '/includes.pug'
-  , str = require('fs').readFileSync(path, 'utf8')
-  , fn = pug.compile(str, { filename: path, pretty: true });
+var pug = require('../'),
+  path = __dirname + '/includes.pug',
+  str = require('fs').readFileSync(path, 'utf8'),
+  fn = pug.compile(str, {filename: path, pretty: true});
 
-console.log(fn());
\ No newline at end of file
+console.log(fn());
diff --git a/packages/pug/examples/layout-debug.js b/packages/pug/examples/layout-debug.js
index 1a3d6199a..3e4dd9387 100644
--- a/packages/pug/examples/layout-debug.js
+++ b/packages/pug/examples/layout-debug.js
@@ -1,11 +1,10 @@
-
 /**
  * Module dependencies.
  */
 
 var pug = require('../');
 
-pug.renderFile(__dirname + '/layout.pug', { debug: true }, function(err, html){
-    if (err) throw err;
-    console.log(html);
+pug.renderFile(__dirname + '/layout.pug', {debug: true}, function(err, html) {
+  if (err) throw err;
+  console.log(html);
 });
diff --git a/packages/pug/examples/layout.js b/packages/pug/examples/layout.js
index 347b4c80c..fc56d2ecc 100644
--- a/packages/pug/examples/layout.js
+++ b/packages/pug/examples/layout.js
@@ -1,11 +1,10 @@
-
 /**
  * Module dependencies.
  */
 
-var pug = require('../')
-  , path = __dirname + '/layout.pug'
-  , str = require('fs').readFileSync(path, 'utf8')
-  , fn = pug.compile(str, { filename: path, pretty: true });
+var pug = require('../'),
+  path = __dirname + '/layout.pug',
+  str = require('fs').readFileSync(path, 'utf8'),
+  fn = pug.compile(str, {filename: path, pretty: true});
 
-console.log(fn());
\ No newline at end of file
+console.log(fn());
diff --git a/packages/pug/examples/mixins.js b/packages/pug/examples/mixins.js
index e6f29048a..349c600df 100644
--- a/packages/pug/examples/mixins.js
+++ b/packages/pug/examples/mixins.js
@@ -1,16 +1,15 @@
-
 /**
  * Module dependencies.
  */
 
-var pug = require('../')
-  , path = __dirname + '/mixins.pug'
-  , str = require('fs').readFileSync(path, 'utf8')
-  , fn = pug.compile(str, { filename: path, pretty: true });
+var pug = require('../'),
+  path = __dirname + '/mixins.pug',
+  str = require('fs').readFileSync(path, 'utf8'),
+  fn = pug.compile(str, {filename: path, pretty: true});
 
 var user = {
-    name: 'tj'
-  , pets: ['tobi', 'loki', 'jane', 'manny']
+  name: 'tj',
+  pets: ['tobi', 'loki', 'jane', 'manny'],
 };
 
-console.log(fn({ user: user }));
\ No newline at end of file
+console.log(fn({user: user}));
diff --git a/packages/pug/examples/rss.js b/packages/pug/examples/rss.js
index 6b34fc8e1..4c6447129 100644
--- a/packages/pug/examples/rss.js
+++ b/packages/pug/examples/rss.js
@@ -1,17 +1,28 @@
-
 /**
  * Module dependencies.
  */
 
-var pug = require('../')
-  , path = __dirname + '/rss.pug'
-  , str = require('fs').readFileSync(path, 'utf8')
-  , fn = pug.compile(str, { filename: path, pretty: true });
+var pug = require('../'),
+  path = __dirname + '/rss.pug',
+  str = require('fs').readFileSync(path, 'utf8'),
+  fn = pug.compile(str, {filename: path, pretty: true});
 
 var items = [];
 
-items.push({ title: 'Example', description: 'Something', link: 'http://google.com' });
-items.push({ title: 'LearnBoost', description: 'Cool', link: 'http://learnboost.com' });
-items.push({ title: 'Express', description: 'Cool', link: 'http://expressjs.com' });
+items.push({
+  title: 'Example',
+  description: 'Something',
+  link: 'http://google.com',
+});
+items.push({
+  title: 'LearnBoost',
+  description: 'Cool',
+  link: 'http://learnboost.com',
+});
+items.push({
+  title: 'Express',
+  description: 'Cool',
+  link: 'http://expressjs.com',
+});
 
-console.log(fn({ items: items }));
\ No newline at end of file
+console.log(fn({items: items}));
diff --git a/packages/pug/examples/text.js b/packages/pug/examples/text.js
index 563486127..7fe4f696d 100644
--- a/packages/pug/examples/text.js
+++ b/packages/pug/examples/text.js
@@ -1,11 +1,10 @@
-
 /**
  * Module dependencies.
  */
 
-var pug = require('../')
-  , path = __dirname + '/text.pug'
-  , str = require('fs').readFileSync(path, 'utf8')
-  , fn = pug.compile(str, { filename: path, pretty: true });
+var pug = require('../'),
+  path = __dirname + '/text.pug',
+  str = require('fs').readFileSync(path, 'utf8'),
+  fn = pug.compile(str, {filename: path, pretty: true});
 
-console.log(fn({ name: 'tj', email: 'tj@vision-media.ca' }));
\ No newline at end of file
+console.log(fn({name: 'tj', email: 'tj@vision-media.ca'}));
diff --git a/packages/pug/examples/whitespace.js b/packages/pug/examples/whitespace.js
index 54a2ea265..badd77ec7 100644
--- a/packages/pug/examples/whitespace.js
+++ b/packages/pug/examples/whitespace.js
@@ -1,11 +1,10 @@
-
 /**
  * Module dependencies.
  */
 
-var pug = require('../')
-  , path = __dirname + '/whitespace.pug'
-  , str = require('fs').readFileSync(path, 'utf8')
-  , fn = pug.compile(str, { filename: path, pretty: true });
+var pug = require('../'),
+  path = __dirname + '/whitespace.pug',
+  str = require('fs').readFileSync(path, 'utf8'),
+  fn = pug.compile(str, {filename: path, pretty: true});
 
-console.log(fn());
\ No newline at end of file
+console.log(fn());
diff --git a/packages/pug/lib/index.js b/packages/pug/lib/index.js
index 2d9b16c9c..ec734f7bb 100644
--- a/packages/pug/lib/index.js
+++ b/packages/pug/lib/index.js
@@ -41,17 +41,13 @@ exports.runtime = runtime;
 exports.cache = {};
 
 function applyPlugins(value, options, plugins, name) {
-  return plugins.reduce(function (value, plugin) {
-    return (
-      plugin[name]
-      ? plugin[name](value, options)
-      : value
-    );
+  return plugins.reduce(function(value, plugin) {
+    return plugin[name] ? plugin[name](value, options) : value;
   }, value);
 }
 
 function findReplacementFunc(plugins, name) {
-  var eligiblePlugins = plugins.filter(function (plugin) {
+  var eligiblePlugins = plugins.filter(function(plugin) {
     return plugin[name];
   });
 
@@ -78,7 +74,7 @@ exports.filters = {};
  * @api private
  */
 
-function compileBody(str, options){
+function compileBody(str, options) {
   var debug_sources = {};
   debug_sources[options.filename] = str;
   var dependencies = [];
@@ -86,26 +82,38 @@ function compileBody(str, options){
   var ast = load.string(str, {
     filename: options.filename,
     basedir: options.basedir,
-    lex: function (str, options) {
+    lex: function(str, options) {
       var lexOptions = {};
-      Object.keys(options).forEach(function (key) {
+      Object.keys(options).forEach(function(key) {
         lexOptions[key] = options[key];
       });
-      lexOptions.plugins = plugins.filter(function (plugin) {
-        return !!plugin.lex;
-      }).map(function (plugin) {
-        return plugin.lex;
-      });
-      var contents = applyPlugins(str, {filename: options.filename}, plugins, 'preLex');
-      return applyPlugins(lex(contents, lexOptions), options, plugins, 'postLex');
+      lexOptions.plugins = plugins
+        .filter(function(plugin) {
+          return !!plugin.lex;
+        })
+        .map(function(plugin) {
+          return plugin.lex;
+        });
+      var contents = applyPlugins(
+        str,
+        {filename: options.filename},
+        plugins,
+        'preLex'
+      );
+      return applyPlugins(
+        lex(contents, lexOptions),
+        options,
+        plugins,
+        'postLex'
+      );
     },
-    parse: function (tokens, options) {
-      tokens = tokens.map(function (token) {
+    parse: function(tokens, options) {
+      tokens = tokens.map(function(token) {
         if (token.type === 'path' && path.extname(token.val) === '') {
           return {
             type: 'path',
             loc: token.loc,
-            val: token.val + '.pug'
+            val: token.val + '.pug',
           };
         }
         return token;
@@ -113,21 +121,30 @@ function compileBody(str, options){
       tokens = stripComments(tokens, options);
       tokens = applyPlugins(tokens, options, plugins, 'preParse');
       var parseOptions = {};
-      Object.keys(options).forEach(function (key) {
+      Object.keys(options).forEach(function(key) {
         parseOptions[key] = options[key];
       });
-      parseOptions.plugins = plugins.filter(function (plugin) {
-        return !!plugin.parse;
-      }).map(function (plugin) {
-        return plugin.parse;
-      });
+      parseOptions.plugins = plugins
+        .filter(function(plugin) {
+          return !!plugin.parse;
+        })
+        .map(function(plugin) {
+          return plugin.parse;
+        });
 
       return applyPlugins(
-        applyPlugins(parse(tokens, parseOptions), options, plugins, 'postParse'),
-        options, plugins, 'preLoad'
+        applyPlugins(
+          parse(tokens, parseOptions),
+          options,
+          plugins,
+          'postParse'
+        ),
+        options,
+        plugins,
+        'preLoad'
       );
     },
-    resolve: function (filename, source, loadOptions) {
+    resolve: function(filename, source, loadOptions) {
       var replacementFunc = findReplacementFunc(plugins, 'resolve');
       if (replacementFunc) {
         return replacementFunc(filename, source, options);
@@ -135,7 +152,7 @@ function compileBody(str, options){
 
       return load.resolve(filename, source, loadOptions);
     },
-    read: function (filename, loadOptions) {
+    read: function(filename, loadOptions) {
       dependencies.push(filename);
 
       var contents;
@@ -149,21 +166,26 @@ function compileBody(str, options){
 
       debug_sources[filename] = contents;
       return contents;
-    }
+    },
   });
   ast = applyPlugins(ast, options, plugins, 'postLoad');
   ast = applyPlugins(ast, options, plugins, 'preFilters');
 
   var filtersSet = {};
-  Object.keys(exports.filters).forEach(function (key) {
+  Object.keys(exports.filters).forEach(function(key) {
     filtersSet[key] = exports.filters[key];
   });
   if (options.filters) {
-    Object.keys(options.filters).forEach(function (key) {
+    Object.keys(options.filters).forEach(function(key) {
       filtersSet[key] = options.filters[key];
     });
   }
-  ast = filters.handleFilters(ast, filtersSet, options.filterOptions, options.filterAliases);
+  ast = filters.handleFilters(
+    ast,
+    filtersSet,
+    options.filterOptions,
+    options.filterAliases
+  );
 
   ast = applyPlugins(ast, options, plugins, 'postFilters');
   ast = applyPlugins(ast, options, plugins, 'preLink');
@@ -180,13 +202,16 @@ function compileBody(str, options){
     globals: options.globals,
     self: options.self,
     includeSources: options.includeSources ? debug_sources : false,
-    templateName: options.templateName
+    templateName: options.templateName,
   });
   js = applyPlugins(js, options, plugins, 'postCodeGen');
 
   // Debug compiler
   if (options.debug) {
-    console.error('\nCompiled Function:\n\n\u001b[90m%s\u001b[0m', js.replace(/^/gm, '  '));
+    console.error(
+      '\nCompiled Function:\n\n\u001b[90m%s\u001b[0m',
+      js.replace(/^/gm, '  ')
+    );
   }
 
   return {body: js, dependencies: dependencies};
@@ -206,7 +231,7 @@ function compileBody(str, options){
  * @return {Function}
  * @api private
  */
-function handleTemplateCache (options, str) {
+function handleTemplateCache(options, str) {
   var key = options.filename;
   if (options.cache && exports.cache[key]) {
     return exports.cache[key];
@@ -234,8 +259,8 @@ function handleTemplateCache (options, str) {
  * @api public
  */
 
-exports.compile = function(str, options){
-  var options = options || {}
+exports.compile = function(str, options) {
+  var options = options || {};
 
   str = String(str);
 
@@ -283,7 +308,7 @@ exports.compile = function(str, options){
  * @api public
  */
 
-exports.compileClientWithDependenciesTracked = function(str, options){
+exports.compileClientWithDependenciesTracked = function(str, options) {
   var options = options || {};
 
   str = String(str);
@@ -302,13 +327,13 @@ exports.compileClientWithDependenciesTracked = function(str, options){
     filters: options.filters,
     filterOptions: options.filterOptions,
     filterAliases: options.filterAliases,
-    plugins: options.plugins
+    plugins: options.plugins,
   });
 
   var body = parsed.body;
 
-  if(options.module) {
-    if(options.inlineRuntimeFunctions === false) {
+  if (options.module) {
+    if (options.inlineRuntimeFunctions === false) {
       body = 'var pug = require("pug-runtime");' + body;
     }
     body += ' module.exports = ' + (options.name || 'template') + ';';
@@ -332,7 +357,7 @@ exports.compileClientWithDependenciesTracked = function(str, options){
  * @return {String}
  * @api public
  */
-exports.compileClient = function (str, options) {
+exports.compileClient = function(str, options) {
   return exports.compileClientWithDependenciesTracked(str, options).body;
 };
 
@@ -350,7 +375,7 @@ exports.compileClient = function (str, options) {
  * @return {Function}
  * @api public
  */
-exports.compileFile = function (path, options) {
+exports.compileFile = function(path, options) {
   options = options || {};
   options.filename = path;
   return handleTemplateCache(options);
@@ -371,10 +396,10 @@ exports.compileFile = function (path, options) {
  * @api public
  */
 
-exports.render = function(str, options, fn){
+exports.render = function(str, options, fn) {
   // support callback API
   if ('function' == typeof options) {
-    fn = options, options = undefined;
+    (fn = options), (options = undefined);
   }
   if (typeof fn === 'function') {
     var res;
@@ -406,10 +431,10 @@ exports.render = function(str, options, fn){
  * @api public
  */
 
-exports.renderFile = function(path, options, fn){
+exports.renderFile = function(path, options, fn) {
   // support callback API
   if ('function' == typeof options) {
-    fn = options, options = undefined;
+    (fn = options), (options = undefined);
   }
   if (typeof fn === 'function') {
     var res;
@@ -427,7 +452,6 @@ exports.renderFile = function(path, options, fn){
   return handleTemplateCache(options)(options);
 };
 
-
 /**
  * Compile a Pug file at the given `path` for use on the client.
  *
@@ -437,7 +461,7 @@ exports.renderFile = function(path, options, fn){
  * @api public
  */
 
-exports.compileFileClient = function(path, options){
+exports.compileFileClient = function(path, options) {
   var key = path + ':client';
   options = options || {};
 
@@ -458,8 +482,11 @@ exports.compileFileClient = function(path, options){
  */
 
 exports.__express = function(path, options, fn) {
-  if(options.compileDebug == undefined && process.env.NODE_ENV === 'production') {
+  if (
+    options.compileDebug == undefined &&
+    process.env.NODE_ENV === 'production'
+  ) {
     options.compileDebug = false;
   }
   exports.renderFile(path, options, fn);
-}
+};
diff --git a/packages/pug/register.js b/packages/pug/register.js
index 02f218d57..3f7b57520 100644
--- a/packages/pug/register.js
+++ b/packages/pug/register.js
@@ -2,12 +2,19 @@ var pug = require('./');
 var resolvedPug = JSON.stringify(require.resolve('./'));
 
 function compileTemplate(module, filename) {
-  var template = pug.compileFileClient(filename, {inlineRuntimeFunctions: false});
-  var body = "var pug = require(" + resolvedPug + ").runtime;\n\n" +
-             "module.exports = " + template + ";";
+  var template = pug.compileFileClient(filename, {
+    inlineRuntimeFunctions: false,
+  });
+  var body =
+    'var pug = require(' +
+    resolvedPug +
+    ').runtime;\n\n' +
+    'module.exports = ' +
+    template +
+    ';';
   module._compile(body, filename);
 }
 
 if (require.extensions) {
-  require.extensions['.pug'] = compileTemplate
-};
+  require.extensions['.pug'] = compileTemplate;
+}
diff --git a/packages/pug/support/benchmark.js b/packages/pug/support/benchmark.js
index 4782f430a..f47009670 100644
--- a/packages/pug/support/benchmark.js
+++ b/packages/pug/support/benchmark.js
@@ -1,34 +1,33 @@
-
 /**
  * Module dependencies.
  */
 
-var uubench = require('uubench')
-  , pug = require('../');
-
+var uubench = require('uubench'),
+  pug = require('../');
 
 var suite = new uubench.Suite({
   min: 200,
-  result: function(name, stats){
-    var persec = 1000 / stats.elapsed
-      , ops = stats.iterations * persec;
+  result: function(name, stats) {
+    var persec = 1000 / stats.elapsed,
+      ops = stats.iterations * persec;
     console.log('%s: %d', name, ops | 0);
-  }
+  },
 });
 
 function setup(self) {
-  var suffix = self ? ' (self)' : ''
-    , options = { self: self };
+  var suffix = self ? ' (self)' : '',
+    options = {self: self};
 
-  var str = 'html\n  body\n    h1 Title'
-    , fn = pug.compile(str, options);
+  var str = 'html\n  body\n    h1 Title',
+    fn = pug.compile(str, options);
 
-  suite.bench('tiny' + suffix, function(next){
+  suite.bench('tiny' + suffix, function(next) {
     fn();
     next();
   });
 
-str = '\
+  str =
+    '\
 html\n\
   body\n\
     h1 Title\n\
@@ -42,12 +41,13 @@ html\n\
 
   var fn2 = pug.compile(str, options);
 
-  suite.bench('small' + suffix, function(next){
+  suite.bench('small' + suffix, function(next) {
     fn2();
     next();
   });
 
-str = '\
+  str =
+    '\
 html\n\
   body\n\
     h1 #{title}\n\
@@ -57,7 +57,8 @@ html\n\
 ';
 
   if (self) {
-str = '\
+    str =
+      '\
 html\n\
   body\n\
     h1 #{self.title}\n\
@@ -69,12 +70,16 @@ html\n\
 
   var fn3 = pug.compile(str, options);
 
-  suite.bench('small locals' + suffix, function(next){
-    fn3({ title: 'Title', links: ['Home', 'About Us', 'Store', 'FAQ', 'Contact'] });
+  suite.bench('small locals' + suffix, function(next) {
+    fn3({
+      title: 'Title',
+      links: ['Home', 'About Us', 'Store', 'FAQ', 'Contact'],
+    });
     next();
   });
 
-str = '\
+  str =
+    '\
 html\n\
   body\n\
     h1 Title\n\
@@ -89,12 +94,13 @@ html\n\
   str = Array(30).join(str);
   var fn4 = pug.compile(str, options);
 
-  suite.bench('medium' + suffix, function(next){
+  suite.bench('medium' + suffix, function(next) {
     fn4();
     next();
   });
 
-str = '\
+  str =
+    '\
 html\n\
   body\n\
     h1 Title\n\
@@ -109,7 +115,7 @@ html\n\
   str = Array(100).join(str);
   var fn5 = pug.compile(str, options);
 
-  suite.bench('large' + suffix, function(next){
+  suite.bench('large' + suffix, function(next) {
     fn5();
     next();
   });
@@ -118,4 +124,4 @@ html\n\
 setup();
 setup(true);
 
-suite.run();
\ No newline at end of file
+suite.run();
diff --git a/packages/pug/test/__snapshots__/pug.test.js.snap b/packages/pug/test/__snapshots__/pug.test.js.snap
index 0ce7c83c5..622f468a2 100644
--- a/packages/pug/test/__snapshots__/pug.test.js.snap
+++ b/packages/pug/test/__snapshots__/pug.test.js.snap
@@ -56,29 +56,31 @@ exports[`pug .compileClient() should support module syntax in pug.compileClient(
   return c !== r ? s + a.substring(c, r) : s;
 }
 var pug_match_html = /[\\"&<>]/;
-function pug_rethrow(n, e, r, t) {
+function pug_rethrow(n, e, t, r) {
   if (!(n instanceof Error)) throw n;
-  if (!(('undefined' == typeof window && e) || t))
-    throw ((n.message += ' on line ' + r), n);
+  if (!(('undefined' == typeof window && e) || r))
+    throw ((n.message += ' on line ' + t), n);
   try {
-    t = t || require('fs').readFileSync(e, 'utf8');
+    r = r || require('fs').readFileSync(e, 'utf8');
   } catch (e) {
-    pug_rethrow(n, null, r);
+    pug_rethrow(n, null, t);
   }
-  var i = 3,
-    a = t.split('\\\\n'),
-    o = Math.max(r - i, 0),
-    h = Math.min(a.length, r + i),
-    i = a
+  var a = 3,
+    i = r.split('\\\\n'),
+    o = Math.max(t - a, 0),
+    h = Math.min(i.length, t + a),
+    a = i
       .slice(o, h)
       .map(function(n, e) {
-        var t = e + o + 1;
-        return (t == r ? '  > ' : '    ') + t + '| ' + n;
+        var r = e + o + 1;
+        return (r == t ? '  > ' : '    ') + r + '| ' + n;
       })
       .join('\\\\n');
-  throw ((n.path = e),
-  (n.message = (e || 'Pug') + ':' + r + '\\\\n' + i + '\\\\n\\\\n' + n.message),
-  n);
+  n.path = e;
+  try {
+    n.message = (e || 'Pug') + ':' + t + '\\\\n' + a + '\\\\n\\\\n' + n.message;
+  } catch (n) {}
+  throw n;
 }
 function template(locals) {
   var pug_html = '',
diff --git a/packages/pug/test/cases/auxiliary/includable.js b/packages/pug/test/cases/auxiliary/includable.js
index f3efe1e66..38c071e0c 100644
--- a/packages/pug/test/cases/auxiliary/includable.js
+++ b/packages/pug/test/cases/auxiliary/includable.js
@@ -1,7 +1,8 @@
-var STRING_SUBSTITUTIONS = {    // table of character substitutions
+var STRING_SUBSTITUTIONS = {
+  // table of character substitutions
   '\t': '\\t',
   '\r': '\\r',
   '\n': '\\n',
-  '"' : '\\"',
-  '\\': '\\\\'
-};
\ No newline at end of file
+  '"': '\\"',
+  '\\': '\\\\',
+};
diff --git a/packages/pug/test/cases/includes-with-ext-js.html b/packages/pug/test/cases/includes-with-ext-js.html
index c36c3633d..26c9184e7 100644
--- a/packages/pug/test/cases/includes-with-ext-js.html
+++ b/packages/pug/test/cases/includes-with-ext-js.html
@@ -1,2 +1,2 @@
-<pre><code>var x = "\n here is some \n new lined text";
+<pre><code>var x = '\n here is some \n new lined text';
 </code></pre>
diff --git a/packages/pug/test/cases/includes.html b/packages/pug/test/cases/includes.html
index 2c004300a..eb61d5c8b 100644
--- a/packages/pug/test/cases/includes.html
+++ b/packages/pug/test/cases/includes.html
@@ -4,13 +4,15 @@
   console.log("foo\nbar")
 </script>
   <script type="text/javascript">
-var STRING_SUBSTITUTIONS = {    // table of character substitutions
+var STRING_SUBSTITUTIONS = {
+  // table of character substitutions
   '\t': '\\t',
   '\r': '\\r',
   '\n': '\\n',
-  '"' : '\\"',
-  '\\': '\\\\'
+  '"': '\\"',
+  '\\': '\\\\',
 };
 
+
   </script>
 </body>
\ No newline at end of file
diff --git a/packages/pug/test/cases/javascript-new-lines.js b/packages/pug/test/cases/javascript-new-lines.js
index 6893341c5..bb0c26f05 100644
--- a/packages/pug/test/cases/javascript-new-lines.js
+++ b/packages/pug/test/cases/javascript-new-lines.js
@@ -1 +1 @@
-var x = "\n here is some \n new lined text";
+var x = '\n here is some \n new lined text';
diff --git a/packages/pug/test/duplicate-block/index.test.js b/packages/pug/test/duplicate-block/index.test.js
index 99161340c..d77631f87 100644
--- a/packages/pug/test/duplicate-block/index.test.js
+++ b/packages/pug/test/duplicate-block/index.test.js
@@ -1,14 +1,10 @@
 const pug = require('../../');
 
 test('layout with duplicate block', () => {
-  const outputWithAjax = pug.renderFile(
-    __dirname + '/index.pug',
-    {ajax: true}
-  );
-  const outputWithoutAjax = pug.renderFile(
-    __dirname + '/index.pug',
-    {ajax: false}
-  );
+  const outputWithAjax = pug.renderFile(__dirname + '/index.pug', {ajax: true});
+  const outputWithoutAjax = pug.renderFile(__dirname + '/index.pug', {
+    ajax: false,
+  });
   expect(outputWithAjax).toMatchSnapshot();
   expect(outputWithoutAjax).toMatchSnapshot();
 });
diff --git a/packages/pug/test/eachOf/index.test.js b/packages/pug/test/eachOf/index.test.js
index 5faf59f34..69da0bae3 100644
--- a/packages/pug/test/eachOf/index.test.js
+++ b/packages/pug/test/eachOf/index.test.js
@@ -2,51 +2,43 @@ const pug = require('../../');
 
 describe('Inproper Usage', () => {
   test('Only left-side bracket', () => {
-    expect(
-      () => pug.compileFile(
-        __dirname + '/error/left-side.pug'
-      )
-    ).toThrow('The value variable for each must either be a valid identifier (e.g. `item`) or a pair of identifiers in square brackets (e.g. `[key, value]`).');
-  })
+    expect(() => pug.compileFile(__dirname + '/error/left-side.pug')).toThrow(
+      'The value variable for each must either be a valid identifier (e.g. `item`) or a pair of identifiers in square brackets (e.g. `[key, value]`).'
+    );
+  });
   test('Only right-side bracket', () => {
-    expect(
-      () => pug.compileFile(
-        __dirname + '/error/right-side.pug'
-      )
-    ).toThrow('The value variable for each must either be a valid identifier (e.g. `item`) or a pair of identifiers in square brackets (e.g. `[key, value]`).');
-  })
+    expect(() => pug.compileFile(__dirname + '/error/right-side.pug')).toThrow(
+      'The value variable for each must either be a valid identifier (e.g. `item`) or a pair of identifiers in square brackets (e.g. `[key, value]`).'
+    );
+  });
   test('Only one value inside brackets', () => {
-    expect(
-      () => pug.compileFile(
-        __dirname + '/error/one-val.pug'
-      )
-    ).toThrow('The value variable for each must either be a valid identifier (e.g. `item`) or a pair of identifiers in square brackets (e.g. `[key, value]`).');
-  })
+    expect(() => pug.compileFile(__dirname + '/error/one-val.pug')).toThrow(
+      'The value variable for each must either be a valid identifier (e.g. `item`) or a pair of identifiers in square brackets (e.g. `[key, value]`).'
+    );
+  });
   test('No brackets', () => {
-    expect(
-      () => pug.compileFile(
-        __dirname + '/error/no-brackets.pug'
-      )
-    ).toThrow('The value variable for each must either be a valid identifier (e.g. `item`) or a pair of identifiers in square brackets (e.g. `[key, value]`).');
-  })
-})
+    expect(() => pug.compileFile(__dirname + '/error/no-brackets.pug')).toThrow(
+      'The value variable for each must either be a valid identifier (e.g. `item`) or a pair of identifiers in square brackets (e.g. `[key, value]`).'
+    );
+  });
+});
 describe('Proper Usage', () => {
   test('Brackets', () => {
-    const html = pug.renderFile(
-      __dirname + '/passing/brackets.pug',
-      {
-        users: new Map([['a', 'b'], ['foo', 'bar']])
-      }
-    )
+    const html = pug.renderFile(__dirname + '/passing/brackets.pug', {
+      users: new Map([
+        ['a', 'b'],
+        ['foo', 'bar'],
+      ]),
+    });
     expect(html).toMatchSnapshot();
-  })
+  });
   test('No Brackets', () => {
-    const html = pug.renderFile(
-      __dirname + '/passing/no-brackets.pug',
-      {
-        users: new Map([['a', 'b'], ['foo', 'bar']])
-      }
-    )
+    const html = pug.renderFile(__dirname + '/passing/no-brackets.pug', {
+      users: new Map([
+        ['a', 'b'],
+        ['foo', 'bar'],
+      ]),
+    });
     expect(html).toMatchSnapshot();
-  })
-})
+  });
+});
diff --git a/packages/pug/test/error.reporting.test.js b/packages/pug/test/error.reporting.test.js
index dc6dc4558..e378e1f14 100644
--- a/packages/pug/test/error.reporting.test.js
+++ b/packages/pug/test/error.reporting.test.js
@@ -1,4 +1,3 @@
-
 /**
  * Module dependencies.
  */
@@ -9,7 +8,7 @@ var fs = require('fs');
 
 // Shortcut
 
-function getError(str, options){
+function getError(str, options) {
   try {
     pug.render(str, options);
   } catch (ex) {
@@ -17,7 +16,7 @@ function getError(str, options){
   }
   throw new Error('Input was supposed to result in an error.');
 }
-function getFileError(name, options){
+function getFileError(name, options) {
   try {
     pug.renderFile(name, options);
   } catch (ex) {
@@ -26,168 +25,224 @@ function getFileError(name, options){
   throw new Error('Input was supposed to result in an error.');
 }
 
-
-describe('error reporting', function () {
-  describe('compile time errors', function () {
-    describe('with no filename', function () {
-      it('includes detail of where the error was thrown', function () {
-        var err = getError('foo(')
+describe('error reporting', function() {
+  describe('compile time errors', function() {
+    describe('with no filename', function() {
+      it('includes detail of where the error was thrown', function() {
+        var err = getError('foo(');
         expect(err.message).toMatch(/Pug:1/);
         expect(err.message).toMatch(/foo\(/);
       });
     });
-    describe('with a filename', function () {
-      it('includes detail of where the error was thrown including the filename', function () {
-        var err = getError('foo(', {filename: 'test.pug'})
+    describe('with a filename', function() {
+      it('includes detail of where the error was thrown including the filename', function() {
+        var err = getError('foo(', {filename: 'test.pug'});
         expect(err.message).toMatch(/test\.pug:1/);
         expect(err.message).toMatch(/foo\(/);
       });
     });
-    describe('with a layout without block declaration (syntax)', function () {
-      it('includes detail of where the error was thrown including the filename', function () {
-        var err = getFileError(__dirname + '/fixtures/compile.with.layout.syntax.error.pug', {})
+    describe('with a layout without block declaration (syntax)', function() {
+      it('includes detail of where the error was thrown including the filename', function() {
+        var err = getFileError(
+          __dirname + '/fixtures/compile.with.layout.syntax.error.pug',
+          {}
+        );
         expect(err.message).toMatch(/[\\\/]layout.syntax.error.pug:2/);
         expect(err.message).toMatch(/foo\(/);
       });
     });
-    describe('with a layout without block declaration (locals)', function () {
-      it('includes detail of where the error was thrown including the filename', function () {
-        var err = getFileError(__dirname + '/fixtures/compile.with.layout.locals.error.pug', {})
+    describe('with a layout without block declaration (locals)', function() {
+      it('includes detail of where the error was thrown including the filename', function() {
+        var err = getFileError(
+          __dirname + '/fixtures/compile.with.layout.locals.error.pug',
+          {}
+        );
         expect(err.message).toMatch(/[\\\/]layout.locals.error.pug:2/);
         expect(err.message).toMatch(/is not a function/);
       });
     });
-    describe('with a include (syntax)', function () {
-      it('includes detail of where the error was thrown including the filename', function () {
-        var err = getFileError(__dirname + '/fixtures/compile.with.include.syntax.error.pug', {})
+    describe('with a include (syntax)', function() {
+      it('includes detail of where the error was thrown including the filename', function() {
+        var err = getFileError(
+          __dirname + '/fixtures/compile.with.include.syntax.error.pug',
+          {}
+        );
         expect(err.message).toMatch(/[\\\/]include.syntax.error.pug:2/);
         expect(err.message).toMatch(/foo\(/);
       });
     });
-    describe('with a include (locals)', function () {
-      it('includes detail of where the error was thrown including the filename', function () {
-        var err = getFileError(__dirname + '/fixtures/compile.with.include.locals.error.pug', {})
+    describe('with a include (locals)', function() {
+      it('includes detail of where the error was thrown including the filename', function() {
+        var err = getFileError(
+          __dirname + '/fixtures/compile.with.include.locals.error.pug',
+          {}
+        );
         expect(err.message).toMatch(/[\\\/]include.locals.error.pug:2/);
         expect(err.message).toMatch(/foo\(/);
       });
     });
-    describe('with a layout (without block) with an include (syntax)', function () {
-      it('includes detail of where the error was thrown including the filename', function () {
-        var err = getFileError(__dirname + '/fixtures/compile.with.layout.with.include.syntax.error.pug', {})
+    describe('with a layout (without block) with an include (syntax)', function() {
+      it('includes detail of where the error was thrown including the filename', function() {
+        var err = getFileError(
+          __dirname +
+            '/fixtures/compile.with.layout.with.include.syntax.error.pug',
+          {}
+        );
         expect(err.message).toMatch(/[\\\/]include.syntax.error.pug:2/);
         expect(err.message).toMatch(/foo\(/);
       });
     });
-    describe('with a layout (without block) with an include (locals)', function () {
-      it('includes detail of where the error was thrown including the filename', function () {
-        var err = getFileError(__dirname + '/fixtures/compile.with.layout.with.include.locals.error.pug', {})
+    describe('with a layout (without block) with an include (locals)', function() {
+      it('includes detail of where the error was thrown including the filename', function() {
+        var err = getFileError(
+          __dirname +
+            '/fixtures/compile.with.layout.with.include.locals.error.pug',
+          {}
+        );
         expect(err.message).toMatch(/[\\\/]include.locals.error.pug:2/);
         expect(err.message).toMatch(/foo\(/);
       });
     });
-    describe('block that is never actually used', function () {
-      it('includes detail of where the error was thrown including the filename', function () {
-        var err = getFileError(__dirname + '/fixtures/invalid-block-in-extends.pug', {});
-        expect(err.message).toMatch(/invalid-block-in-extends.pug:6/);;
-        expect(err.message).toMatch(/content/);;
+    describe('block that is never actually used', function() {
+      it('includes detail of where the error was thrown including the filename', function() {
+        var err = getFileError(
+          __dirname + '/fixtures/invalid-block-in-extends.pug',
+          {}
+        );
+        expect(err.message).toMatch(/invalid-block-in-extends.pug:6/);
+        expect(err.message).toMatch(/content/);
       });
     });
-    describe('Unexpected character', function () {
-      it('includes details of where the error was thrown', function () {
+    describe('Unexpected character', function() {
+      it('includes details of where the error was thrown', function() {
         var err = getError('ul?', {});
         expect(err.message).toMatch(/unexpected text \"\?\"/);
       });
     });
-    describe('Include filtered', function () {
-      it('includes details of where the error was thrown', function () {
+    describe('Include filtered', function() {
+      it('includes details of where the error was thrown', function() {
         var err = getError('include:verbatim()!', {});
         assert(err.message.indexOf('unexpected text "!"') !== -1);
         var err = getError('include:verbatim ', {});
         assert(err.message.indexOf('missing path for include') !== -1);
       });
     });
-    describe('mixin block followed by a lot of blank lines', function () {
-      it('reports the correct line number', function () {
+    describe('mixin block followed by a lot of blank lines', function() {
+      it('reports the correct line number', function() {
         var err = getError('mixin test\n    block\n\ndiv()Test');
         var line = /Pug\:(\d+)/.exec(err.message);
         assert(line, 'Line number must be included in error message');
-        assert(line[1] === '4', 'The error should be reported on line 4, not line ' + line[1]);
+        assert(
+          line[1] === '4',
+          'The error should be reported on line 4, not line ' + line[1]
+        );
       });
     });
   });
-  describe('runtime errors', function () {
-    describe('with no filename and `compileDebug` left undefined', function () {
-      it('just reports the line number', function () {
+  describe('runtime errors', function() {
+    describe('with no filename and `compileDebug` left undefined', function() {
+      it('just reports the line number', function() {
         var sentinel = new Error('sentinel');
-        var err = getError('-foo()', {foo: function () { throw sentinel; }})
+        var err = getError('-foo()', {
+          foo: function() {
+            throw sentinel;
+          },
+        });
         expect(err.message).toMatch(/on line 1/);
       });
     });
-    describe('with no filename and `compileDebug` set to `true`', function () {
-      it('includes detail of where the error was thrown', function () {
+    describe('with no filename and `compileDebug` set to `true`', function() {
+      it('includes detail of where the error was thrown', function() {
         var sentinel = new Error('sentinel');
-        var err = getError('-foo()', {foo: function () { throw sentinel; }, compileDebug: true})
+        var err = getError('-foo()', {
+          foo: function() {
+            throw sentinel;
+          },
+          compileDebug: true,
+        });
         expect(err.message).toMatch(/Pug:1/);
         expect(err.message).toMatch(/-foo\(\)/);
       });
     });
-    describe('with a filename that does not correspond to a real file and `compileDebug` left undefined', function () {
-      it('just reports the line number', function () {
+    describe('with a filename that does not correspond to a real file and `compileDebug` left undefined', function() {
+      it('just reports the line number', function() {
         var sentinel = new Error('sentinel');
-        var err = getError('-foo()', {foo: function () { throw sentinel; }, filename: 'fake.pug'})
+        var err = getError('-foo()', {
+          foo: function() {
+            throw sentinel;
+          },
+          filename: 'fake.pug',
+        });
         expect(err.message).toMatch(/on line 1/);
       });
     });
-    describe('with a filename that corresponds to a real file and `compileDebug` left undefined', function () {
-      it('includes detail of where the error was thrown including the filename', function () {
+    describe('with a filename that corresponds to a real file and `compileDebug` left undefined', function() {
+      it('includes detail of where the error was thrown including the filename', function() {
         var sentinel = new Error('sentinel');
-        var path = __dirname + '/fixtures/runtime.error.pug'
-        var err = getError(fs.readFileSync(path, 'utf8'), {foo: function () { throw sentinel; }, filename: path})
+        var path = __dirname + '/fixtures/runtime.error.pug';
+        var err = getError(fs.readFileSync(path, 'utf8'), {
+          foo: function() {
+            throw sentinel;
+          },
+          filename: path,
+        });
         expect(err.message).toMatch(/fixtures[\\\/]runtime\.error\.pug:1/);
         expect(err.message).toMatch(/-foo\(\)/);
       });
     });
-    describe('in a mixin', function () {
-      it('includes detail of where the error was thrown including the filename', function () {
-        var err = getFileError(__dirname + '/fixtures/runtime.with.mixin.error.pug', {})
+    describe('in a mixin', function() {
+      it('includes detail of where the error was thrown including the filename', function() {
+        var err = getFileError(
+          __dirname + '/fixtures/runtime.with.mixin.error.pug',
+          {}
+        );
         expect(err.message).toMatch(/mixin.error.pug:2/);
         expect(err.message).toMatch(/Cannot read property 'length' of null/);
       });
     });
-    describe('in a layout', function () {
-      it('includes detail of where the error was thrown including the filename', function () {
-        var err = getFileError(__dirname + '/fixtures/runtime.layout.error.pug', {})
+    describe('in a layout', function() {
+      it('includes detail of where the error was thrown including the filename', function() {
+        var err = getFileError(
+          __dirname + '/fixtures/runtime.layout.error.pug',
+          {}
+        );
         expect(err.message).toMatch(/layout.with.runtime.error.pug:3/);
-        expect(err.message).toMatch(/Cannot read property 'length' of undefined/);
+        expect(err.message).toMatch(
+          /Cannot read property 'length' of undefined/
+        );
       });
     });
   });
-  describe('deprecated features', function () {
-    it('warns about element-with-multiple-attributes', function () {
+  describe('deprecated features', function() {
+    it('warns about element-with-multiple-attributes', function() {
       var consoleWarn = console.warn;
       var log = '';
-      console.warn = function (str) {
+      console.warn = function(str) {
         log += str;
       };
-      var res = pug.renderFile(__dirname + '/fixtures/element-with-multiple-attributes.pug');
+      var res = pug.renderFile(
+        __dirname + '/fixtures/element-with-multiple-attributes.pug'
+      );
       console.warn = consoleWarn;
-      expect(log).toMatch(/element-with-multiple-attributes.pug, line 1:/);;
-      expect(log).toMatch(/You should not have pug tags with multiple attributes/);;
+      expect(log).toMatch(/element-with-multiple-attributes.pug, line 1:/);
+      expect(log).toMatch(
+        /You should not have pug tags with multiple attributes/
+      );
       expect(res).toBe('<div attr="val" foo="bar"></div>');
     });
   });
-  describe('if you throw something that isn\'t an error', function () {
-    it('just rethrows without modification', function () {
+  describe("if you throw something that isn't an error", function() {
+    it('just rethrows without modification', function() {
       var err = getError('- throw "foo"');
       expect(err).toBe('foo');
     });
   });
-  describe('import without a filename for a basedir', function () {
-    it('throws an error', function () {
+  describe('import without a filename for a basedir', function() {
+    it('throws an error', function() {
       var err = getError('include foo.pug');
-      expect(err.message).toMatch(/the "filename" option is required to use/);;
+      expect(err.message).toMatch(/the "filename" option is required to use/);
       var err = getError('include /foo.pug');
-      expect(err.message).toMatch(/the "basedir" option is required to use/);;
-    })
+      expect(err.message).toMatch(/the "basedir" option is required to use/);
+    });
   });
 });
diff --git a/packages/pug/test/examples.test.js b/packages/pug/test/examples.test.js
index 0537f8de3..a4a4c22a1 100644
--- a/packages/pug/test/examples.test.js
+++ b/packages/pug/test/examples.test.js
@@ -3,14 +3,14 @@
 var fs = require('fs');
 var pug = require('../');
 
-describe('examples', function () {
-  fs.readdirSync(__dirname + '/../examples').forEach(function (example) {
+describe('examples', function() {
+  fs.readdirSync(__dirname + '/../examples').forEach(function(example) {
     if (/\.js$/.test(example)) {
-      it(example + ' does not throw any error', function () {
+      it(example + ' does not throw any error', function() {
         var log = console.log;
         var err = console.error;
-        console.log = function () {};
-        console.error = function () {};
+        console.log = function() {};
+        console.error = function() {};
         try {
           require('../examples/' + example);
         } finally {
diff --git a/packages/pug/test/extends-not-top-level/index.test.js b/packages/pug/test/extends-not-top-level/index.test.js
index 43877a026..a0fbf274f 100644
--- a/packages/pug/test/extends-not-top-level/index.test.js
+++ b/packages/pug/test/extends-not-top-level/index.test.js
@@ -3,17 +3,13 @@ const pug = require('../../');
 // regression test for #2404
 
 test('extends not top level should throw an error', () => {
-  expect(
-    () => pug.compileFile(
-      __dirname + '/index.pug'
-    )
-  ).toThrow('Declaration of template inheritance ("extends") should be the first thing in the file. There can only be one extends statement per file.');
+  expect(() => pug.compileFile(__dirname + '/index.pug')).toThrow(
+    'Declaration of template inheritance ("extends") should be the first thing in the file. There can only be one extends statement per file.'
+  );
 });
 
 test('duplicate extends should throw an error', () => {
-  expect(
-    () => pug.compileFile(
-      __dirname + '/duplicate.pug'
-    )
-  ).toThrow('Declaration of template inheritance ("extends") should be the first thing in the file. There can only be one extends statement per file.');
+  expect(() => pug.compileFile(__dirname + '/duplicate.pug')).toThrow(
+    'Declaration of template inheritance ("extends") should be the first thing in the file. There can only be one extends statement per file.'
+  );
 });
diff --git a/packages/pug/test/markdown-it/index.test.js b/packages/pug/test/markdown-it/index.test.js
index 7ab82c8a1..00bef9f96 100644
--- a/packages/pug/test/markdown-it/index.test.js
+++ b/packages/pug/test/markdown-it/index.test.js
@@ -1,13 +1,13 @@
 const pug = require('../../');
 
 test('inline and include markdow-it should match ', () => {
-   const outputMarkdownInline = pug.renderFile(
-      __dirname + '/layout-markdown-inline.pug',
-   );
+  const outputMarkdownInline = pug.renderFile(
+    __dirname + '/layout-markdown-inline.pug'
+  );
 
-   const outputMarkdownIncludes = pug.renderFile(
-      __dirname + '/layout-markdown-include.pug',
-   );
+  const outputMarkdownIncludes = pug.renderFile(
+    __dirname + '/layout-markdown-include.pug'
+  );
 
-   expect(outputMarkdownIncludes).toEqual(outputMarkdownInline);
+  expect(outputMarkdownIncludes).toEqual(outputMarkdownInline);
 });
diff --git a/packages/pug/test/pug.test.js b/packages/pug/test/pug.test.js
index 3327b1a9e..0b4d85274 100644
--- a/packages/pug/test/pug.test.js
+++ b/packages/pug/test/pug.test.js
@@ -5,7 +5,7 @@ var fs = require('fs');
 var path = require('path');
 var pug = require('../');
 
-var perfTest = fs.readFileSync(__dirname + '/fixtures/perf.pug', 'utf8')
+var perfTest = fs.readFileSync(__dirname + '/fixtures/perf.pug', 'utf8');
 
 try {
   fs.mkdirSync(__dirname + '/temp');
@@ -15,267 +15,309 @@ try {
   }
 }
 
-describe('pug', function(){
-
-  describe('unit tests with .render()', function(){
-    it('should support doctypes', function(){
-      assert.equal('<?xml version="1.0" encoding="utf-8" ?>', pug.render('doctype xml'));
+describe('pug', function() {
+  describe('unit tests with .render()', function() {
+    it('should support doctypes', function() {
+      assert.equal(
+        '<?xml version="1.0" encoding="utf-8" ?>',
+        pug.render('doctype xml')
+      );
       assert.equal('<!DOCTYPE html>', pug.render('doctype html'));
       assert.equal('<!DOCTYPE foo bar baz>', pug.render('doctype foo bar baz'));
       assert.equal('<!DOCTYPE html>', pug.render('doctype html'));
-      assert.equal('<!DOCTYPE html>', pug.render('doctype', { doctype:'html' }));
-      assert.equal('<!DOCTYPE html>', pug.render('doctype html', { doctype:'xml' }));
+      assert.equal('<!DOCTYPE html>', pug.render('doctype', {doctype: 'html'}));
+      assert.equal(
+        '<!DOCTYPE html>',
+        pug.render('doctype html', {doctype: 'xml'})
+      );
       assert.equal('<html></html>', pug.render('html'));
-      assert.equal('<!DOCTYPE html><html></html>', pug.render('html', { doctype:'html' }));
-      assert.equal('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN>', pug.render('doctype html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN'));
+      assert.equal(
+        '<!DOCTYPE html><html></html>',
+        pug.render('html', {doctype: 'html'})
+      );
+      assert.equal(
+        '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN>',
+        pug.render('doctype html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN')
+      );
     });
 
-    it('should support Buffers', function(){
+    it('should support Buffers', function() {
       assert.equal('<p>foo</p>', pug.render(Buffer.from('p foo')));
     });
 
-    it('should support line endings', function(){
-      var src = [
-          'p',
-          'div',
-          'img'
-      ];
+    it('should support line endings', function() {
+      var src = ['p', 'div', 'img'];
 
-      var html = [
-          '<p></p>',
-          '<div></div>',
-          '<img/>'
-      ].join('');
+      var html = ['<p></p>', '<div></div>', '<img/>'].join('');
 
       assert.equal(html, pug.render(src.join('\n')));
       assert.equal(html, pug.render(src.join('\r')));
       assert.equal(html, pug.render(src.join('\r\n')));
 
-      html = [
-          '<p></p>',
-          '<div></div>',
-          '<img>'
-      ].join('');
+      html = ['<p></p>', '<div></div>', '<img>'].join('');
 
-      assert.equal(html, pug.render(src.join('\n'), { doctype:'html' }));
-      assert.equal(html, pug.render(src.join('\r'), { doctype:'html' }));
-      assert.equal(html, pug.render(src.join('\r\n'), { doctype:'html' }));
+      assert.equal(html, pug.render(src.join('\n'), {doctype: 'html'}));
+      assert.equal(html, pug.render(src.join('\r'), {doctype: 'html'}));
+      assert.equal(html, pug.render(src.join('\r\n'), {doctype: 'html'}));
     });
 
-    it('should support single quotes', function(){
+    it('should support single quotes', function() {
       assert.equal("<p>'foo'</p>", pug.render("p 'foo'"));
       assert.equal("<p>'foo'</p>", pug.render("p\n  | 'foo'"));
-      assert.equal('<a href="/foo"></a>', pug.render("- var path = 'foo';\na(href='/' + path)"));
+      assert.equal(
+        '<a href="/foo"></a>',
+        pug.render("- var path = 'foo';\na(href='/' + path)")
+      );
     });
 
-    it('should support block-expansion', function(){
-      assert.equal("<li><a>foo</a></li><li><a>bar</a></li><li><a>baz</a></li>", pug.render("li: a foo\nli: a bar\nli: a baz"));
-      assert.equal("<li class=\"first\"><a>foo</a></li><li><a>bar</a></li><li><a>baz</a></li>", pug.render("li.first: a foo\nli: a bar\nli: a baz"));
-      assert.equal('<div class="foo"><div class="bar">baz</div></div>', pug.render(".foo: .bar baz"));
+    it('should support block-expansion', function() {
+      assert.equal(
+        '<li><a>foo</a></li><li><a>bar</a></li><li><a>baz</a></li>',
+        pug.render('li: a foo\nli: a bar\nli: a baz')
+      );
+      assert.equal(
+        '<li class="first"><a>foo</a></li><li><a>bar</a></li><li><a>baz</a></li>',
+        pug.render('li.first: a foo\nli: a bar\nli: a baz')
+      );
+      assert.equal(
+        '<div class="foo"><div class="bar">baz</div></div>',
+        pug.render('.foo: .bar baz')
+      );
     });
 
-    it('should support tags', function(){
-      var str = [
-          'p',
-          'div',
-          'img',
-          'br/'
-      ].join('\n');
+    it('should support tags', function() {
+      var str = ['p', 'div', 'img', 'br/'].join('\n');
 
-      var html = [
-          '<p></p>',
-          '<div></div>',
-          '<img/>',
-          '<br/>'
-      ].join('');
+      var html = ['<p></p>', '<div></div>', '<img/>', '<br/>'].join('');
 
       assert.equal(html, pug.render(str), 'Test basic tags');
-      assert.equal('<fb:foo-bar></fb:foo-bar>', pug.render('fb:foo-bar'), 'Test hyphens');
-      assert.equal('<div class="something"></div>', pug.render('div.something'), 'Test classes');
-      assert.equal('<div id="something"></div>', pug.render('div#something'), 'Test ids');
-      assert.equal('<div class="something"></div>', pug.render('.something'), 'Test stand-alone classes');
-      assert.equal('<div id="something"></div>', pug.render('#something'), 'Test stand-alone ids');
+      assert.equal(
+        '<fb:foo-bar></fb:foo-bar>',
+        pug.render('fb:foo-bar'),
+        'Test hyphens'
+      );
+      assert.equal(
+        '<div class="something"></div>',
+        pug.render('div.something'),
+        'Test classes'
+      );
+      assert.equal(
+        '<div id="something"></div>',
+        pug.render('div#something'),
+        'Test ids'
+      );
+      assert.equal(
+        '<div class="something"></div>',
+        pug.render('.something'),
+        'Test stand-alone classes'
+      );
+      assert.equal(
+        '<div id="something"></div>',
+        pug.render('#something'),
+        'Test stand-alone ids'
+      );
       assert.equal('<div class="bar" id="foo"></div>', pug.render('#foo.bar'));
       assert.equal('<div class="bar" id="foo"></div>', pug.render('.bar#foo'));
-      assert.equal('<div class="bar" id="foo"></div>', pug.render('div#foo(class="bar")'));
-      assert.equal('<div class="bar" id="foo"></div>', pug.render('div(class="bar")#foo'));
-      assert.equal('<div class="foo" id="bar"></div>', pug.render('div(id="bar").foo'));
-      assert.equal('<div class="foo bar baz"></div>', pug.render('div.foo.bar.baz'));
-      assert.equal('<div class="foo bar baz"></div>', pug.render('div(class="foo").bar.baz'));
-      assert.equal('<div class="foo bar baz"></div>', pug.render('div.foo(class="bar").baz'));
-      assert.equal('<div class="foo bar baz"></div>', pug.render('div.foo.bar(class="baz")'));
+      assert.equal(
+        '<div class="bar" id="foo"></div>',
+        pug.render('div#foo(class="bar")')
+      );
+      assert.equal(
+        '<div class="bar" id="foo"></div>',
+        pug.render('div(class="bar")#foo')
+      );
+      assert.equal(
+        '<div class="foo" id="bar"></div>',
+        pug.render('div(id="bar").foo')
+      );
+      assert.equal(
+        '<div class="foo bar baz"></div>',
+        pug.render('div.foo.bar.baz')
+      );
+      assert.equal(
+        '<div class="foo bar baz"></div>',
+        pug.render('div(class="foo").bar.baz')
+      );
+      assert.equal(
+        '<div class="foo bar baz"></div>',
+        pug.render('div.foo(class="bar").baz')
+      );
+      assert.equal(
+        '<div class="foo bar baz"></div>',
+        pug.render('div.foo.bar(class="baz")')
+      );
       assert.equal('<div class="a-b2"></div>', pug.render('div.a-b2'));
       assert.equal('<div class="a_b2"></div>', pug.render('div.a_b2'));
       assert.equal('<fb:user></fb:user>', pug.render('fb:user'));
       assert.equal('<fb:user:role></fb:user:role>', pug.render('fb:user:role'));
-      assert.equal('<colgroup><col class="test"/></colgroup>', pug.render('colgroup\n  col.test'));
+      assert.equal(
+        '<colgroup><col class="test"/></colgroup>',
+        pug.render('colgroup\n  col.test')
+      );
     });
 
-    it('should support nested tags', function(){
+    it('should support nested tags', function() {
       var str = [
-          'ul',
-          '  li a',
-          '  li b',
-          '  li',
-          '    ul',
-          '      li c',
-          '      li d',
-          '  li e',
+        'ul',
+        '  li a',
+        '  li b',
+        '  li',
+        '    ul',
+        '      li c',
+        '      li d',
+        '  li e',
       ].join('\n');
 
       var html = [
-          '<ul>',
-          '<li>a</li>',
-          '<li>b</li>',
-          '<li><ul><li>c</li><li>d</li></ul></li>',
-          '<li>e</li>',
-          '</ul>'
+        '<ul>',
+        '<li>a</li>',
+        '<li>b</li>',
+        '<li><ul><li>c</li><li>d</li></ul></li>',
+        '<li>e</li>',
+        '</ul>',
       ].join('');
 
       assert.equal(html, pug.render(str));
 
-      var str = [
-          'a(href="#")',
-          '  | foo ',
-          '  | bar ',
-          '  | baz'
-      ].join('\n');
+      var str = ['a(href="#")', '  | foo ', '  | bar ', '  | baz'].join('\n');
 
       assert.equal('<a href="#">foo \nbar \nbaz</a>', pug.render(str));
 
-      var str = [
-          'ul',
-          '  li one',
-          '  ul',
-          '    | two',
-          '    li three'
-      ].join('\n');
+      var str = ['ul', '  li one', '  ul', '    | two', '    li three'].join(
+        '\n'
+      );
 
       var html = [
-          '<ul>',
-          '<li>one</li>',
-          '<ul>two',
-          '<li>three</li>',
-          '</ul>',
-          '</ul>'
+        '<ul>',
+        '<li>one</li>',
+        '<ul>two',
+        '<li>three</li>',
+        '</ul>',
+        '</ul>',
       ].join('');
 
       assert.equal(html, pug.render(str));
     });
 
-    it('should support variable length newlines', function(){
+    it('should support variable length newlines', function() {
       var str = [
-          'ul',
-          '  li a',
-          '  ',
-          '  li b',
-          ' ',
-          '         ',
-          '  li',
-          '    ul',
-          '      li c',
-          '',
-          '      li d',
-          '  li e',
+        'ul',
+        '  li a',
+        '  ',
+        '  li b',
+        ' ',
+        '         ',
+        '  li',
+        '    ul',
+        '      li c',
+        '',
+        '      li d',
+        '  li e',
       ].join('\n');
 
       var html = [
-          '<ul>',
-          '<li>a</li>',
-          '<li>b</li>',
-          '<li><ul><li>c</li><li>d</li></ul></li>',
-          '<li>e</li>',
-          '</ul>'
+        '<ul>',
+        '<li>a</li>',
+        '<li>b</li>',
+        '<li><ul><li>c</li><li>d</li></ul></li>',
+        '<li>e</li>',
+        '</ul>',
       ].join('');
 
       assert.equal(html, pug.render(str));
     });
 
-    it('should support tab conversion', function(){
+    it('should support tab conversion', function() {
       var str = [
-          'ul',
-          '\tli a',
-          '\t',
-          '\tli b',
-          '\t\t',
-          '\t\t\t\t\t\t',
-          '\tli',
-          '\t\tul',
-          '\t\t\tli c',
-          '',
-          '\t\t\tli d',
-          '\tli e',
+        'ul',
+        '\tli a',
+        '\t',
+        '\tli b',
+        '\t\t',
+        '\t\t\t\t\t\t',
+        '\tli',
+        '\t\tul',
+        '\t\t\tli c',
+        '',
+        '\t\t\tli d',
+        '\tli e',
       ].join('\n');
 
       var html = [
-          '<ul>',
-          '<li>a</li>',
-          '<li>b</li>',
-          '<li><ul><li>c</li><li>d</li></ul></li>',
-          '<li>e</li>',
-          '</ul>'
+        '<ul>',
+        '<li>a</li>',
+        '<li>b</li>',
+        '<li><ul><li>c</li><li>d</li></ul></li>',
+        '<li>e</li>',
+        '</ul>',
       ].join('');
 
       assert.equal(html, pug.render(str));
     });
 
-    it('should support newlines', function(){
+    it('should support newlines', function() {
       var str = [
-          'ul',
-          '  li a',
-          '  ',
-          '    ',
-          '',
-          ' ',
-          '  li b',
-          '  li',
-          '    ',
-          '        ',
-          ' ',
-          '    ul',
-          '      ',
-          '      li c',
-          '      li d',
-          '  li e',
+        'ul',
+        '  li a',
+        '  ',
+        '    ',
+        '',
+        ' ',
+        '  li b',
+        '  li',
+        '    ',
+        '        ',
+        ' ',
+        '    ul',
+        '      ',
+        '      li c',
+        '      li d',
+        '  li e',
       ].join('\n');
 
       var html = [
-          '<ul>',
-          '<li>a</li>',
-          '<li>b</li>',
-          '<li><ul><li>c</li><li>d</li></ul></li>',
-          '<li>e</li>',
-          '</ul>'
+        '<ul>',
+        '<li>a</li>',
+        '<li>b</li>',
+        '<li><ul><li>c</li><li>d</li></ul></li>',
+        '<li>e</li>',
+        '</ul>',
       ].join('');
 
       assert.equal(html, pug.render(str));
 
       var str = [
-          'html',
-          ' ',
-          '  head',
-          '    != "test"',
-          '  ',
-          '  ',
-          '  ',
-          '  body'
+        'html',
+        ' ',
+        '  head',
+        '    != "test"',
+        '  ',
+        '  ',
+        '  ',
+        '  body',
       ].join('\n');
 
       var html = [
-          '<html>',
-          '<head>',
-          'test',
-          '</head>',
-          '<body></body>',
-          '</html>'
+        '<html>',
+        '<head>',
+        'test',
+        '</head>',
+        '<body></body>',
+        '</html>',
       ].join('');
 
       assert.equal(html, pug.render(str));
-      assert.equal('<foo></foo>something<bar></bar>', pug.render('foo\n= "something"\nbar'));
-      assert.equal('<foo></foo>something<bar></bar>else', pug.render('foo\n= "something"\nbar\n= "else"'));
+      assert.equal(
+        '<foo></foo>something<bar></bar>',
+        pug.render('foo\n= "something"\nbar')
+      );
+      assert.equal(
+        '<foo></foo>something<bar></bar>else',
+        pug.render('foo\n= "something"\nbar\n= "else"')
+      );
     });
 
-    it('should support text', function(){
+    it('should support text', function() {
       assert.equal('foo\nbar\nbaz', pug.render('| foo\n| bar\n| baz'));
       assert.equal('foo \nbar \nbaz', pug.render('| foo \n| bar \n| baz'));
       assert.equal('(hey)', pug.render('| (hey)'));
@@ -285,167 +327,435 @@ describe('pug', function(){
       assert.equal('  foo  \n bar    ', pug.render('|   foo  \n|  bar    '));
     });
 
-    it('should support pipe-less text', function(){
-      assert.equal('<pre><code><foo></foo><bar></bar></code></pre>', pug.render('pre\n  code\n    foo\n\n    bar'));
+    it('should support pipe-less text', function() {
+      assert.equal(
+        '<pre><code><foo></foo><bar></bar></code></pre>',
+        pug.render('pre\n  code\n    foo\n\n    bar')
+      );
       assert.equal('<p>foo\n\nbar</p>', pug.render('p.\n  foo\n\n  bar'));
-      assert.equal('<p>foo\n\n\n\nbar</p>', pug.render('p.\n  foo\n\n\n\n  bar'));
-      assert.equal('<p>foo\n  bar\nfoo</p>', pug.render('p.\n  foo\n    bar\n  foo'));
-      assert.equal('<script>s.parentNode.insertBefore(g,s)</script>', pug.render('script.\n  s.parentNode.insertBefore(g,s)\n'));
-      assert.equal('<script>s.parentNode.insertBefore(g,s)</script>', pug.render('script.\n  s.parentNode.insertBefore(g,s)'));
-    });
-
-    it('should support tag text', function(){
+      assert.equal(
+        '<p>foo\n\n\n\nbar</p>',
+        pug.render('p.\n  foo\n\n\n\n  bar')
+      );
+      assert.equal(
+        '<p>foo\n  bar\nfoo</p>',
+        pug.render('p.\n  foo\n    bar\n  foo')
+      );
+      assert.equal(
+        '<script>s.parentNode.insertBefore(g,s)</script>',
+        pug.render('script.\n  s.parentNode.insertBefore(g,s)\n')
+      );
+      assert.equal(
+        '<script>s.parentNode.insertBefore(g,s)</script>',
+        pug.render('script.\n  s.parentNode.insertBefore(g,s)')
+      );
+    });
+
+    it('should support tag text', function() {
       assert.equal('<p>some random text</p>', pug.render('p some random text'));
-      assert.equal('<p>click<a>Google</a>.</p>', pug.render('p\n  | click\n  a Google\n  | .'));
+      assert.equal(
+        '<p>click<a>Google</a>.</p>',
+        pug.render('p\n  | click\n  a Google\n  | .')
+      );
       assert.equal('<p>(parens)</p>', pug.render('p (parens)'));
-      assert.equal('<p foo="bar">(parens)</p>', pug.render('p(foo="bar") (parens)'));
-      assert.equal('<option value="">-- (optional) foo --</option>', pug.render('option(value="") -- (optional) foo --'));
-    });
-
-    it('should support tag text block', function(){
-      assert.equal('<p>foo \nbar \nbaz</p>', pug.render('p\n  | foo \n  | bar \n  | baz'));
-      assert.equal('<label>Password:<input/></label>', pug.render('label\n  | Password:\n  input'));
-      assert.equal('<label>Password:<input/></label>', pug.render('label Password:\n  input'));
-    });
-
-    it('should support tag text interpolation', function(){
-      assert.equal('yo, pug is cool', pug.render('| yo, #{name} is cool\n', { name: 'pug' }));
-      assert.equal('<p>yo, pug is cool</p>', pug.render('p yo, #{name} is cool', { name: 'pug' }));
-      assert.equal('yo, pug is cool', pug.render('| yo, #{name || "pug"} is cool', { name: null }));
-      assert.equal('yo, \'pug\' is cool', pug.render('| yo, #{name || "\'pug\'"} is cool', { name: null }));
-      assert.equal('foo &lt;script&gt; bar', pug.render('| foo #{code} bar', { code: '<script>' }));
-      assert.equal('foo <script> bar', pug.render('| foo !{code} bar', { code: '<script>' }));
-    });
-
-    it('should support flexible indentation', function(){
-      assert.equal('<html><body><h1>Wahoo</h1><p>test</p></body></html>', pug.render('html\n  body\n   h1 Wahoo\n   p test'));
-    });
-
-    it('should support interpolation values', function(){
+      assert.equal(
+        '<p foo="bar">(parens)</p>',
+        pug.render('p(foo="bar") (parens)')
+      );
+      assert.equal(
+        '<option value="">-- (optional) foo --</option>',
+        pug.render('option(value="") -- (optional) foo --')
+      );
+    });
+
+    it('should support tag text block', function() {
+      assert.equal(
+        '<p>foo \nbar \nbaz</p>',
+        pug.render('p\n  | foo \n  | bar \n  | baz')
+      );
+      assert.equal(
+        '<label>Password:<input/></label>',
+        pug.render('label\n  | Password:\n  input')
+      );
+      assert.equal(
+        '<label>Password:<input/></label>',
+        pug.render('label Password:\n  input')
+      );
+    });
+
+    it('should support tag text interpolation', function() {
+      assert.equal(
+        'yo, pug is cool',
+        pug.render('| yo, #{name} is cool\n', {name: 'pug'})
+      );
+      assert.equal(
+        '<p>yo, pug is cool</p>',
+        pug.render('p yo, #{name} is cool', {name: 'pug'})
+      );
+      assert.equal(
+        'yo, pug is cool',
+        pug.render('| yo, #{name || "pug"} is cool', {name: null})
+      );
+      assert.equal(
+        "yo, 'pug' is cool",
+        pug.render('| yo, #{name || "\'pug\'"} is cool', {name: null})
+      );
+      assert.equal(
+        'foo &lt;script&gt; bar',
+        pug.render('| foo #{code} bar', {code: '<script>'})
+      );
+      assert.equal(
+        'foo <script> bar',
+        pug.render('| foo !{code} bar', {code: '<script>'})
+      );
+    });
+
+    it('should support flexible indentation', function() {
+      assert.equal(
+        '<html><body><h1>Wahoo</h1><p>test</p></body></html>',
+        pug.render('html\n  body\n   h1 Wahoo\n   p test')
+      );
+    });
+
+    it('should support interpolation values', function() {
       assert.equal('<p>Users: 15</p>', pug.render('p Users: #{15}'));
       assert.equal('<p>Users: </p>', pug.render('p Users: #{null}'));
       assert.equal('<p>Users: </p>', pug.render('p Users: #{undefined}'));
-      assert.equal('<p>Users: none</p>', pug.render('p Users: #{undefined || "none"}'));
+      assert.equal(
+        '<p>Users: none</p>',
+        pug.render('p Users: #{undefined || "none"}')
+      );
       assert.equal('<p>Users: 0</p>', pug.render('p Users: #{0}'));
       assert.equal('<p>Users: false</p>', pug.render('p Users: #{false}'));
     });
 
-    it('should support test html 5 mode', function(){
-      assert.equal('<!DOCTYPE html><input type="checkbox" checked>', pug.render('doctype html\ninput(type="checkbox", checked)'));
-      assert.equal('<!DOCTYPE html><input type="checkbox" checked>', pug.render('doctype html\ninput(type="checkbox", checked=true)'));
-      assert.equal('<!DOCTYPE html><input type="checkbox">', pug.render('doctype html\ninput(type="checkbox", checked= false)'));
-    });
-
-    it('should support multi-line attrs', function(){
-      assert.equal('<a foo="bar" bar="baz" checked="checked">foo</a>', pug.render('a(foo="bar"\n  bar="baz"\n  checked) foo'));
-      assert.equal('<a foo="bar" bar="baz" checked="checked">foo</a>', pug.render('a(foo="bar"\nbar="baz"\nchecked) foo'));
-      assert.equal('<a foo="bar" bar="baz" checked="checked">foo</a>', pug.render('a(foo="bar"\n,bar="baz"\n,checked) foo'));
-      assert.equal('<a foo="bar" bar="baz" checked="checked">foo</a>', pug.render('a(foo="bar",\nbar="baz",\nchecked) foo'));
-    });
-
-    it('should support attrs', function(){
-      assert.equal('<img src="&lt;script&gt;"/>', pug.render('img(src="<script>")'), 'Test attr escaping');
+    it('should support test html 5 mode', function() {
+      assert.equal(
+        '<!DOCTYPE html><input type="checkbox" checked>',
+        pug.render('doctype html\ninput(type="checkbox", checked)')
+      );
+      assert.equal(
+        '<!DOCTYPE html><input type="checkbox" checked>',
+        pug.render('doctype html\ninput(type="checkbox", checked=true)')
+      );
+      assert.equal(
+        '<!DOCTYPE html><input type="checkbox">',
+        pug.render('doctype html\ninput(type="checkbox", checked= false)')
+      );
+    });
+
+    it('should support multi-line attrs', function() {
+      assert.equal(
+        '<a foo="bar" bar="baz" checked="checked">foo</a>',
+        pug.render('a(foo="bar"\n  bar="baz"\n  checked) foo')
+      );
+      assert.equal(
+        '<a foo="bar" bar="baz" checked="checked">foo</a>',
+        pug.render('a(foo="bar"\nbar="baz"\nchecked) foo')
+      );
+      assert.equal(
+        '<a foo="bar" bar="baz" checked="checked">foo</a>',
+        pug.render('a(foo="bar"\n,bar="baz"\n,checked) foo')
+      );
+      assert.equal(
+        '<a foo="bar" bar="baz" checked="checked">foo</a>',
+        pug.render('a(foo="bar",\nbar="baz",\nchecked) foo')
+      );
+    });
+
+    it('should support attrs', function() {
+      assert.equal(
+        '<img src="&lt;script&gt;"/>',
+        pug.render('img(src="<script>")'),
+        'Test attr escaping'
+      );
 
       assert.equal('<a data-attr="bar"></a>', pug.render('a(data-attr="bar")'));
-      assert.equal('<a data-attr="bar" data-attr-2="baz"></a>', pug.render('a(data-attr="bar", data-attr-2="baz")'));
-
-      assert.equal('<a title="foo,bar"></a>', pug.render('a(title= "foo,bar")'));
-      assert.equal('<a title="foo,bar" href="#"></a>', pug.render('a(title= "foo,bar", href="#")'));
-
-      assert.equal('<p class="foo"></p>', pug.render("p(class='foo')"), 'Test single quoted attrs');
-      assert.equal('<input type="checkbox" checked="checked"/>', pug.render('input( type="checkbox", checked )'));
-      assert.equal('<input type="checkbox" checked="checked"/>', pug.render('input( type="checkbox", checked = true )'));
-      assert.equal('<input type="checkbox"/>', pug.render('input(type="checkbox", checked= false)'));
-      assert.equal('<input type="checkbox"/>', pug.render('input(type="checkbox", checked= null)'));
-      assert.equal('<input type="checkbox"/>', pug.render('input(type="checkbox", checked= undefined)'));
-
-      assert.equal('<img src="/foo.png"/>', pug.render('img(src="/foo.png")'), 'Test attr =');
-      assert.equal('<img src="/foo.png"/>', pug.render('img(src  =  "/foo.png")'), 'Test attr = whitespace');
-      assert.equal('<img src="/foo.png"/>', pug.render('img(src="/foo.png")'), 'Test attr :');
-      assert.equal('<img src="/foo.png"/>', pug.render('img(src  =  "/foo.png")'), 'Test attr : whitespace');
-
-      assert.equal('<img src="/foo.png" alt="just some foo"/>', pug.render('img(src="/foo.png", alt="just some foo")'));
-      assert.equal('<img src="/foo.png" alt="just some foo"/>', pug.render('img(src = "/foo.png", alt = "just some foo")'));
-
-      assert.equal('<p class="foo,bar,baz"></p>', pug.render('p(class="foo,bar,baz")'));
-      assert.equal('<a href="http://google.com" title="Some : weird = title"></a>', pug.render('a(href= "http://google.com", title= "Some : weird = title")'));
-      assert.equal('<label for="name"></label>', pug.render('label(for="name")'));
-      assert.equal('<meta name="viewport" content="width=device-width"/>', pug.render("meta(name= 'viewport', content='width=device-width')"), 'Test attrs that contain attr separators');
-      assert.equal('<div style="color= white"></div>', pug.render("div(style='color= white')"));
-      assert.equal('<div style="color: white"></div>', pug.render("div(style='color: white')"));
-      assert.equal('<p class="foo"></p>', pug.render("p('class'='foo')"), 'Test keys with single quotes');
-      assert.equal('<p class="foo"></p>', pug.render("p(\"class\"= 'foo')"), 'Test keys with double quotes');
+      assert.equal(
+        '<a data-attr="bar" data-attr-2="baz"></a>',
+        pug.render('a(data-attr="bar", data-attr-2="baz")')
+      );
+
+      assert.equal(
+        '<a title="foo,bar"></a>',
+        pug.render('a(title= "foo,bar")')
+      );
+      assert.equal(
+        '<a title="foo,bar" href="#"></a>',
+        pug.render('a(title= "foo,bar", href="#")')
+      );
+
+      assert.equal(
+        '<p class="foo"></p>',
+        pug.render("p(class='foo')"),
+        'Test single quoted attrs'
+      );
+      assert.equal(
+        '<input type="checkbox" checked="checked"/>',
+        pug.render('input( type="checkbox", checked )')
+      );
+      assert.equal(
+        '<input type="checkbox" checked="checked"/>',
+        pug.render('input( type="checkbox", checked = true )')
+      );
+      assert.equal(
+        '<input type="checkbox"/>',
+        pug.render('input(type="checkbox", checked= false)')
+      );
+      assert.equal(
+        '<input type="checkbox"/>',
+        pug.render('input(type="checkbox", checked= null)')
+      );
+      assert.equal(
+        '<input type="checkbox"/>',
+        pug.render('input(type="checkbox", checked= undefined)')
+      );
+
+      assert.equal(
+        '<img src="/foo.png"/>',
+        pug.render('img(src="/foo.png")'),
+        'Test attr ='
+      );
+      assert.equal(
+        '<img src="/foo.png"/>',
+        pug.render('img(src  =  "/foo.png")'),
+        'Test attr = whitespace'
+      );
+      assert.equal(
+        '<img src="/foo.png"/>',
+        pug.render('img(src="/foo.png")'),
+        'Test attr :'
+      );
+      assert.equal(
+        '<img src="/foo.png"/>',
+        pug.render('img(src  =  "/foo.png")'),
+        'Test attr : whitespace'
+      );
+
+      assert.equal(
+        '<img src="/foo.png" alt="just some foo"/>',
+        pug.render('img(src="/foo.png", alt="just some foo")')
+      );
+      assert.equal(
+        '<img src="/foo.png" alt="just some foo"/>',
+        pug.render('img(src = "/foo.png", alt = "just some foo")')
+      );
+
+      assert.equal(
+        '<p class="foo,bar,baz"></p>',
+        pug.render('p(class="foo,bar,baz")')
+      );
+      assert.equal(
+        '<a href="http://google.com" title="Some : weird = title"></a>',
+        pug.render(
+          'a(href= "http://google.com", title= "Some : weird = title")'
+        )
+      );
+      assert.equal(
+        '<label for="name"></label>',
+        pug.render('label(for="name")')
+      );
+      assert.equal(
+        '<meta name="viewport" content="width=device-width"/>',
+        pug.render("meta(name= 'viewport', content='width=device-width')"),
+        'Test attrs that contain attr separators'
+      );
+      assert.equal(
+        '<div style="color= white"></div>',
+        pug.render("div(style='color= white')")
+      );
+      assert.equal(
+        '<div style="color: white"></div>',
+        pug.render("div(style='color: white')")
+      );
+      assert.equal(
+        '<p class="foo"></p>',
+        pug.render("p('class'='foo')"),
+        'Test keys with single quotes'
+      );
+      assert.equal(
+        '<p class="foo"></p>',
+        pug.render('p("class"= \'foo\')'),
+        'Test keys with double quotes'
+      );
 
       assert.equal('<p data-lang="en"></p>', pug.render('p(data-lang = "en")'));
-      assert.equal('<p data-dynamic="true"></p>', pug.render('p("data-dynamic"= "true")'));
-      assert.equal('<p class="name" data-dynamic="true"></p>', pug.render('p("class"= "name", "data-dynamic"= "true")'));
-      assert.equal('<p data-dynamic="true"></p>', pug.render('p(\'data-dynamic\'= "true")'));
-      assert.equal('<p class="name" data-dynamic="true"></p>', pug.render('p(\'class\'= "name", \'data-dynamic\'= "true")'));
-      assert.equal('<p class="name" data-dynamic="true" yay="yay"></p>', pug.render('p(\'class\'= "name", \'data-dynamic\'= "true", yay)'));
-
-      assert.equal('<input checked="checked" type="checkbox"/>', pug.render('input(checked, type="checkbox")'));
-
-      assert.equal('<a data-foo="{ foo: \'bar\', bar= \'baz\' }"></a>', pug.render('a(data-foo  = "{ foo: \'bar\', bar= \'baz\' }")'));
-
-      assert.equal('<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1"/>', pug.render('meta(http-equiv="X-UA-Compatible", content="IE=edge,chrome=1")'));
-
-      assert.equal('<div style="background: url(/images/test.png)">Foo</div>', pug.render("div(style= 'background: url(/images/test.png)') Foo"));
-      assert.equal('<div style="background = url(/images/test.png)">Foo</div>', pug.render("div(style= 'background = url(/images/test.png)') Foo"));
-      assert.equal('<div style="foo">Foo</div>', pug.render("div(style= ['foo', 'bar'][0]) Foo"));
-      assert.equal('<div style="bar">Foo</div>', pug.render("div(style= { foo: 'bar', baz: 'raz' }['foo']) Foo"));
-      assert.equal('<a href="def">Foo</a>', pug.render("a(href='abcdefg'.substr(3,3)) Foo"));
-      assert.equal('<a href="def">Foo</a>', pug.render("a(href={test: 'abcdefg'}.test.substr(3,3)) Foo"));
-      assert.equal('<a href="def">Foo</a>', pug.render("a(href={test: 'abcdefg'}.test.substr(3,[0,3][1])) Foo"));
-
-      assert.equal('<rss xmlns:atom="atom"></rss>', pug.render("rss(xmlns:atom=\"atom\")"));
-      assert.equal('<rss xmlns:atom="atom"></rss>', pug.render("rss('xmlns:atom'=\"atom\")"));
-      assert.equal('<rss xmlns:atom="atom"></rss>', pug.render("rss(\"xmlns:atom\"='atom')"));
-      assert.equal('<rss xmlns:atom="atom" foo="bar"></rss>', pug.render("rss('xmlns:atom'=\"atom\", 'foo'= 'bar')"));
-      assert.equal('<a data-obj="{ foo: \'bar\' }"></a>', pug.render("a(data-obj= \"{ foo: 'bar' }\")"));
-
-      assert.equal('<meta content="what\'s up? \'weee\'"/>', pug.render('meta(content="what\'s up? \'weee\'")'));
-    });
-
-    it('should support class attr array', function(){
-      assert.equal('<body class="foo bar baz"></body>', pug.render('body(class=["foo", "bar", "baz"])'));
-    });
-
-    it('should support attr parens', function(){
-      assert.equal('<p foo="bar">baz</p>', pug.render('p(foo=((("bar"))))= ((("baz")))'));
-    });
-
-    it('should support code attrs', function(){
-      assert.equal('<p></p>', pug.render('p(id= name)', { name: undefined }));
-      assert.equal('<p></p>', pug.render('p(id= name)', { name: null }));
-      assert.equal('<p></p>', pug.render('p(id= name)', { name: false }));
-      assert.equal('<p id=""></p>', pug.render('p(id= name)', { name: '' }));
-      assert.equal('<p id="tj"></p>', pug.render('p(id= name)', { name: 'tj' }));
-      assert.equal('<p id="default"></p>', pug.render('p(id= name || "default")', { name: null }));
-      assert.equal('<p id="something"></p>', pug.render("p(id= 'something')", { name: null }));
-      assert.equal('<p id="something"></p>', pug.render("p(id = 'something')", { name: null }));
-      assert.equal('<p id="foo"></p>', pug.render("p(id= (true ? 'foo' : 'bar'))"));
-      assert.equal('<option value="">Foo</option>', pug.render("option(value='') Foo"));
-    });
-
-    it('should support code attrs class', function(){
-      assert.equal('<p class="tj"></p>', pug.render('p(class= name)', { name: 'tj' }));
-      assert.equal('<p class="tj"></p>', pug.render('p( class= name )', { name: 'tj' }));
-      assert.equal('<p class="default"></p>', pug.render('p(class= name || "default")', { name: null }));
-      assert.equal('<p class="foo default"></p>', pug.render('p.foo(class= name || "default")', { name: null }));
-      assert.equal('<p class="default foo"></p>', pug.render('p(class= name || "default").foo', { name: null }));
-      assert.equal('<p id="default"></p>', pug.render('p(id = name || "default")', { name: null }));
+      assert.equal(
+        '<p data-dynamic="true"></p>',
+        pug.render('p("data-dynamic"= "true")')
+      );
+      assert.equal(
+        '<p class="name" data-dynamic="true"></p>',
+        pug.render('p("class"= "name", "data-dynamic"= "true")')
+      );
+      assert.equal(
+        '<p data-dynamic="true"></p>',
+        pug.render('p(\'data-dynamic\'= "true")')
+      );
+      assert.equal(
+        '<p class="name" data-dynamic="true"></p>',
+        pug.render('p(\'class\'= "name", \'data-dynamic\'= "true")')
+      );
+      assert.equal(
+        '<p class="name" data-dynamic="true" yay="yay"></p>',
+        pug.render('p(\'class\'= "name", \'data-dynamic\'= "true", yay)')
+      );
+
+      assert.equal(
+        '<input checked="checked" type="checkbox"/>',
+        pug.render('input(checked, type="checkbox")')
+      );
+
+      assert.equal(
+        "<a data-foo=\"{ foo: 'bar', bar= 'baz' }\"></a>",
+        pug.render("a(data-foo  = \"{ foo: 'bar', bar= 'baz' }\")")
+      );
+
+      assert.equal(
+        '<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1"/>',
+        pug.render(
+          'meta(http-equiv="X-UA-Compatible", content="IE=edge,chrome=1")'
+        )
+      );
+
+      assert.equal(
+        '<div style="background: url(/images/test.png)">Foo</div>',
+        pug.render("div(style= 'background: url(/images/test.png)') Foo")
+      );
+      assert.equal(
+        '<div style="background = url(/images/test.png)">Foo</div>',
+        pug.render("div(style= 'background = url(/images/test.png)') Foo")
+      );
+      assert.equal(
+        '<div style="foo">Foo</div>',
+        pug.render("div(style= ['foo', 'bar'][0]) Foo")
+      );
+      assert.equal(
+        '<div style="bar">Foo</div>',
+        pug.render("div(style= { foo: 'bar', baz: 'raz' }['foo']) Foo")
+      );
+      assert.equal(
+        '<a href="def">Foo</a>',
+        pug.render("a(href='abcdefg'.substr(3,3)) Foo")
+      );
+      assert.equal(
+        '<a href="def">Foo</a>',
+        pug.render("a(href={test: 'abcdefg'}.test.substr(3,3)) Foo")
+      );
+      assert.equal(
+        '<a href="def">Foo</a>',
+        pug.render("a(href={test: 'abcdefg'}.test.substr(3,[0,3][1])) Foo")
+      );
+
+      assert.equal(
+        '<rss xmlns:atom="atom"></rss>',
+        pug.render('rss(xmlns:atom="atom")')
+      );
+      assert.equal(
+        '<rss xmlns:atom="atom"></rss>',
+        pug.render('rss(\'xmlns:atom\'="atom")')
+      );
+      assert.equal(
+        '<rss xmlns:atom="atom"></rss>',
+        pug.render('rss("xmlns:atom"=\'atom\')')
+      );
+      assert.equal(
+        '<rss xmlns:atom="atom" foo="bar"></rss>',
+        pug.render("rss('xmlns:atom'=\"atom\", 'foo'= 'bar')")
+      );
+      assert.equal(
+        '<a data-obj="{ foo: \'bar\' }"></a>',
+        pug.render('a(data-obj= "{ foo: \'bar\' }")')
+      );
+
+      assert.equal(
+        "<meta content=\"what's up? 'weee'\"/>",
+        pug.render("meta(content=\"what's up? 'weee'\")")
+      );
+    });
+
+    it('should support class attr array', function() {
+      assert.equal(
+        '<body class="foo bar baz"></body>',
+        pug.render('body(class=["foo", "bar", "baz"])')
+      );
+    });
+
+    it('should support attr parens', function() {
+      assert.equal(
+        '<p foo="bar">baz</p>',
+        pug.render('p(foo=((("bar"))))= ((("baz")))')
+      );
+    });
+
+    it('should support code attrs', function() {
+      assert.equal('<p></p>', pug.render('p(id= name)', {name: undefined}));
+      assert.equal('<p></p>', pug.render('p(id= name)', {name: null}));
+      assert.equal('<p></p>', pug.render('p(id= name)', {name: false}));
+      assert.equal('<p id=""></p>', pug.render('p(id= name)', {name: ''}));
+      assert.equal('<p id="tj"></p>', pug.render('p(id= name)', {name: 'tj'}));
+      assert.equal(
+        '<p id="default"></p>',
+        pug.render('p(id= name || "default")', {name: null})
+      );
+      assert.equal(
+        '<p id="something"></p>',
+        pug.render("p(id= 'something')", {name: null})
+      );
+      assert.equal(
+        '<p id="something"></p>',
+        pug.render("p(id = 'something')", {name: null})
+      );
+      assert.equal(
+        '<p id="foo"></p>',
+        pug.render("p(id= (true ? 'foo' : 'bar'))")
+      );
+      assert.equal(
+        '<option value="">Foo</option>',
+        pug.render("option(value='') Foo")
+      );
+    });
+
+    it('should support code attrs class', function() {
+      assert.equal(
+        '<p class="tj"></p>',
+        pug.render('p(class= name)', {name: 'tj'})
+      );
+      assert.equal(
+        '<p class="tj"></p>',
+        pug.render('p( class= name )', {name: 'tj'})
+      );
+      assert.equal(
+        '<p class="default"></p>',
+        pug.render('p(class= name || "default")', {name: null})
+      );
+      assert.equal(
+        '<p class="foo default"></p>',
+        pug.render('p.foo(class= name || "default")', {name: null})
+      );
+      assert.equal(
+        '<p class="default foo"></p>',
+        pug.render('p(class= name || "default").foo', {name: null})
+      );
+      assert.equal(
+        '<p id="default"></p>',
+        pug.render('p(id = name || "default")', {name: null})
+      );
       assert.equal('<p id="user-1"></p>', pug.render('p(id = "user-" + 1)'));
-      assert.equal('<p class="user-1"></p>', pug.render('p(class = "user-" + 1)'));
+      assert.equal(
+        '<p class="user-1"></p>',
+        pug.render('p(class = "user-" + 1)')
+      );
     });
 
-    it('should support code buffering', function(){
+    it('should support code buffering', function() {
       assert.equal('<p></p>', pug.render('p= null'));
       assert.equal('<p></p>', pug.render('p= undefined'));
       assert.equal('<p>0</p>', pug.render('p= 0'));
       assert.equal('<p>false</p>', pug.render('p= false'));
     });
 
-    it('should support script text', function(){
+    it('should support script text', function() {
       var str = [
         'script.',
         '  p foo',
@@ -454,409 +764,330 @@ describe('pug', function(){
         '  p foo',
         '',
         'script(type="text/template").',
-        '  p foo'
+        '  p foo',
       ].join('\n');
 
       var html = [
         '<script>p foo\n</script>',
         '<script type="text/template"><p>foo</p></script>',
-        '<script type="text/template">p foo</script>'
+        '<script type="text/template">p foo</script>',
       ].join('');
 
       assert.equal(html, pug.render(str));
     });
 
-    it('should support comments', function(){
+    it('should support comments', function() {
       // Regular
-      var str = [
-          '//foo',
-          'p bar'
-      ].join('\n');
+      var str = ['//foo', 'p bar'].join('\n');
 
-      var html = [
-          '<!--foo-->',
-          '<p>bar</p>'
-      ].join('');
+      var html = ['<!--foo-->', '<p>bar</p>'].join('');
 
       assert.equal(html, pug.render(str));
 
       // Between tags
 
-      var str = [
-          'p foo',
-          '// bar ',
-          'p baz'
-      ].join('\n');
+      var str = ['p foo', '// bar ', 'p baz'].join('\n');
 
-      var html = [
-          '<p>foo</p>',
-          '<!-- bar -->',
-          '<p>baz</p>'
-      ].join('');
+      var html = ['<p>foo</p>', '<!-- bar -->', '<p>baz</p>'].join('');
 
       assert.equal(html, pug.render(str));
 
       // Quotes
 
       var str = "<!-- script(src: '/js/validate.js') -->",
-          js = "// script(src: '/js/validate.js') ";
+        js = "// script(src: '/js/validate.js') ";
       assert.equal(str, pug.render(js));
     });
 
-    it('should support unbuffered comments', function(){
-      var str = [
-          '//- foo',
-          'p bar'
-      ].join('\n');
+    it('should support unbuffered comments', function() {
+      var str = ['//- foo', 'p bar'].join('\n');
 
-      var html = [
-          '<p>bar</p>'
-      ].join('');
+      var html = ['<p>bar</p>'].join('');
 
       assert.equal(html, pug.render(str));
 
-      var str = [
-          'p foo',
-          '//- bar ',
-          'p baz'
-      ].join('\n');
+      var str = ['p foo', '//- bar ', 'p baz'].join('\n');
 
-      var html = [
-          '<p>foo</p>',
-          '<p>baz</p>'
-      ].join('');
+      var html = ['<p>foo</p>', '<p>baz</p>'].join('');
 
       assert.equal(html, pug.render(str));
     });
 
-    it('should support literal html', function(){
-      assert.equal('<!--[if IE lt 9]>weeee<![endif]-->', pug.render('<!--[if IE lt 9]>weeee<![endif]-->'));
+    it('should support literal html', function() {
+      assert.equal(
+        '<!--[if IE lt 9]>weeee<![endif]-->',
+        pug.render('<!--[if IE lt 9]>weeee<![endif]-->')
+      );
     });
 
-    it('should support code', function(){
+    it('should support code', function() {
       assert.equal('test', pug.render('!= "test"'));
       assert.equal('test', pug.render('= "test"'));
       assert.equal('test', pug.render('- var foo = "test"\n=foo'));
-      assert.equal('foo<em>test</em>bar', pug.render('- var foo = "test"\n| foo\nem= foo\n| bar'));
-      assert.equal('test<h2>something</h2>', pug.render('!= "test"\nh2 something'));
+      assert.equal(
+        'foo<em>test</em>bar',
+        pug.render('- var foo = "test"\n| foo\nem= foo\n| bar')
+      );
+      assert.equal(
+        'test<h2>something</h2>',
+        pug.render('!= "test"\nh2 something')
+      );
 
-      var str = [
-          '- var foo = "<script>";',
-          '= foo',
-          '!= foo'
-      ].join('\n');
+      var str = ['- var foo = "<script>";', '= foo', '!= foo'].join('\n');
 
-      var html = [
-          '&lt;script&gt;',
-          '<script>'
-      ].join('');
+      var html = ['&lt;script&gt;', '<script>'].join('');
 
       assert.equal(html, pug.render(str));
 
-      var str = [
-          '- var foo = "<script>";',
-          '- if (foo)',
-          '  p= foo'
-      ].join('\n');
+      var str = ['- var foo = "<script>";', '- if (foo)', '  p= foo'].join(
+        '\n'
+      );
 
-      var html = [
-          '<p>&lt;script&gt;</p>'
-      ].join('');
+      var html = ['<p>&lt;script&gt;</p>'].join('');
 
       assert.equal(html, pug.render(str));
 
-      var str = [
-          '- var foo = "<script>";',
-          '- if (foo)',
-          '  p!= foo'
-      ].join('\n');
+      var str = ['- var foo = "<script>";', '- if (foo)', '  p!= foo'].join(
+        '\n'
+      );
 
-      var html = [
-          '<p><script></p>'
-      ].join('');
+      var html = ['<p><script></p>'].join('');
 
       assert.equal(html, pug.render(str));
 
       var str = [
-          '- var foo;',
-          '- if (foo)',
-          '  p.hasFoo= foo',
-          '- else',
-          '  p.noFoo no foo'
+        '- var foo;',
+        '- if (foo)',
+        '  p.hasFoo= foo',
+        '- else',
+        '  p.noFoo no foo',
       ].join('\n');
 
-      var html = [
-          '<p class="noFoo">no foo</p>'
-      ].join('');
+      var html = ['<p class="noFoo">no foo</p>'].join('');
 
       assert.equal(html, pug.render(str));
 
       var str = [
-          '- var foo;',
-          '- if (foo)',
-          '  p.hasFoo= foo',
-          '- else if (true)',
-          '  p kinda foo',
-          '- else',
-          '  p.noFoo no foo'
+        '- var foo;',
+        '- if (foo)',
+        '  p.hasFoo= foo',
+        '- else if (true)',
+        '  p kinda foo',
+        '- else',
+        '  p.noFoo no foo',
       ].join('\n');
 
-      var html = [
-          '<p>kinda foo</p>'
-      ].join('');
+      var html = ['<p>kinda foo</p>'].join('');
 
       assert.equal(html, pug.render(str));
 
-      var str = [
-          'p foo',
-          '= "bar"',
-      ].join('\n');
+      var str = ['p foo', '= "bar"'].join('\n');
 
-      var html = [
-          '<p>foo</p>bar'
-      ].join('');
+      var html = ['<p>foo</p>bar'].join('');
 
       assert.equal(html, pug.render(str));
 
-      var str = [
-          'title foo',
-          '- if (true)',
-          '  p something',
-      ].join('\n');
+      var str = ['title foo', '- if (true)', '  p something'].join('\n');
 
-      var html = [
-          '<title>foo</title><p>something</p>'
-      ].join('');
+      var html = ['<title>foo</title><p>something</p>'].join('');
 
       assert.equal(html, pug.render(str));
 
-      var str = [
-          'foo',
-          '  bar= "bar"',
-          '    baz= "baz"',
-      ].join('\n');
+      var str = ['foo', '  bar= "bar"', '    baz= "baz"'].join('\n');
 
       var html = [
-          '<foo>',
-          '<bar>bar',
-          '<baz>baz</baz>',
-          '</bar>',
-          '</foo>'
+        '<foo>',
+        '<bar>bar',
+        '<baz>baz</baz>',
+        '</bar>',
+        '</foo>',
       ].join('');
 
       assert.equal(html, pug.render(str));
 
-      var str = [
-          '-',
-          '  var a =',
-          '    5;',
-          'p= a'
-      ].join('\n')
+      var str = ['-', '  var a =', '    5;', 'p= a'].join('\n');
 
-      var html = [
-          '<p>5</p>'
-      ].join('');
+      var html = ['<p>5</p>'].join('');
 
       assert.equal(html, pug.render(str));
     });
 
-    it('should support each', function(){
+    it('should support each', function() {
       // Array
       var str = [
-          '- var items = ["one", "two", "three"];',
-          'each item in items',
-          '  li= item'
+        '- var items = ["one", "two", "three"];',
+        'each item in items',
+        '  li= item',
       ].join('\n');
 
-      var html = [
-          '<li>one</li>',
-          '<li>two</li>',
-          '<li>three</li>'
-      ].join('');
+      var html = ['<li>one</li>', '<li>two</li>', '<li>three</li>'].join('');
 
       assert.equal(html, pug.render(str));
 
       // Any enumerable (length property)
       var str = [
-          '- var jQuery = { length: 3, 0: 1, 1: 2, 2: 3 };',
-          'each item in jQuery',
-          '  li= item'
+        '- var jQuery = { length: 3, 0: 1, 1: 2, 2: 3 };',
+        'each item in jQuery',
+        '  li= item',
       ].join('\n');
 
-      var html = [
-          '<li>1</li>',
-          '<li>2</li>',
-          '<li>3</li>'
-      ].join('');
+      var html = ['<li>1</li>', '<li>2</li>', '<li>3</li>'].join('');
 
       assert.equal(html, pug.render(str));
 
       // Empty array
-      var str = [
-          '- var items = [];',
-          'each item in items',
-          '  li= item'
-      ].join('\n');
+      var str = ['- var items = [];', 'each item in items', '  li= item'].join(
+        '\n'
+      );
 
       assert.equal('', pug.render(str));
 
       // Object
       var str = [
-          '- var obj = { foo: "bar", baz: "raz" };',
-          'each val in obj',
-          '  li= val'
+        '- var obj = { foo: "bar", baz: "raz" };',
+        'each val in obj',
+        '  li= val',
       ].join('\n');
 
-      var html = [
-          '<li>bar</li>',
-          '<li>raz</li>'
-      ].join('');
+      var html = ['<li>bar</li>', '<li>raz</li>'].join('');
 
       assert.equal(html, pug.render(str));
 
       // Complex
       var str = [
-          '- var obj = { foo: "bar", baz: "raz" };',
-          'each key in Object.keys(obj)',
-          '  li= key'
+        '- var obj = { foo: "bar", baz: "raz" };',
+        'each key in Object.keys(obj)',
+        '  li= key',
       ].join('\n');
 
-      var html = [
-          '<li>foo</li>',
-          '<li>baz</li>'
-      ].join('');
+      var html = ['<li>foo</li>', '<li>baz</li>'].join('');
 
       assert.equal(html, pug.render(str));
 
       // Keys
       var str = [
-          '- var obj = { foo: "bar", baz: "raz" };',
-          'each val, key in obj',
-          '  li #{key}: #{val}'
+        '- var obj = { foo: "bar", baz: "raz" };',
+        'each val, key in obj',
+        '  li #{key}: #{val}',
       ].join('\n');
 
-      var html = [
-          '<li>foo: bar</li>',
-          '<li>baz: raz</li>'
-      ].join('');
+      var html = ['<li>foo: bar</li>', '<li>baz: raz</li>'].join('');
 
       assert.equal(html, pug.render(str));
 
       // Nested
       var str = [
-          '- var users = [{ name: "tj" }]',
-          'each user in users',
-          '  each val, key in user',
-          '    li #{key} #{val}',
+        '- var users = [{ name: "tj" }]',
+        'each user in users',
+        '  each val, key in user',
+        '    li #{key} #{val}',
       ].join('\n');
 
-      var html = [
-          '<li>name tj</li>'
-      ].join('');
+      var html = ['<li>name tj</li>'].join('');
 
       assert.equal(html, pug.render(str));
 
       var str = [
-          '- var users = ["tobi", "loki", "jane"]',
-          'each user in users',
-          '  li= user',
+        '- var users = ["tobi", "loki", "jane"]',
+        'each user in users',
+        '  li= user',
       ].join('\n');
 
-      var html = [
-          '<li>tobi</li>',
-          '<li>loki</li>',
-          '<li>jane</li>',
-      ].join('');
+      var html = ['<li>tobi</li>', '<li>loki</li>', '<li>jane</li>'].join('');
 
       assert.equal(html, pug.render(str));
 
       var str = [
-          '- var users = ["tobi", "loki", "jane"]',
-          'for user in users',
-          '  li= user',
+        '- var users = ["tobi", "loki", "jane"]',
+        'for user in users',
+        '  li= user',
       ].join('\n');
 
-      var html = [
-          '<li>tobi</li>',
-          '<li>loki</li>',
-          '<li>jane</li>',
-      ].join('');
+      var html = ['<li>tobi</li>', '<li>loki</li>', '<li>jane</li>'].join('');
 
       assert.equal(html, pug.render(str));
     });
 
-    it('should support if', function(){
+    it('should support if', function() {
       var str = [
-          '- var users = ["tobi", "loki", "jane"]',
-          'if users.length',
-          '  p users: #{users.length}',
+        '- var users = ["tobi", "loki", "jane"]',
+        'if users.length',
+        '  p users: #{users.length}',
       ].join('\n');
 
       assert.equal('<p>users: 3</p>', pug.render(str));
 
-      assert.equal('<iframe foo="bar"></iframe>', pug.render('iframe(foo="bar")'));
+      assert.equal(
+        '<iframe foo="bar"></iframe>',
+        pug.render('iframe(foo="bar")')
+      );
     });
 
-    it('should support unless', function(){
+    it('should support unless', function() {
       var str = [
-          '- var users = ["tobi", "loki", "jane"]',
-          'unless users.length',
-          '  p no users',
+        '- var users = ["tobi", "loki", "jane"]',
+        'unless users.length',
+        '  p no users',
       ].join('\n');
 
       assert.equal('', pug.render(str));
 
       var str = [
-          '- var users = []',
-          'unless users.length',
-          '  p no users',
+        '- var users = []',
+        'unless users.length',
+        '  p no users',
       ].join('\n');
 
       assert.equal('<p>no users</p>', pug.render(str));
     });
 
-    it('should support else', function(){
+    it('should support else', function() {
       var str = [
-          '- var users = []',
-          'if users.length',
-          '  p users: #{users.length}',
-          'else',
-          '  p users: none',
+        '- var users = []',
+        'if users.length',
+        '  p users: #{users.length}',
+        'else',
+        '  p users: none',
       ].join('\n');
 
       assert.equal('<p>users: none</p>', pug.render(str));
     });
 
-    it('should else if', function(){
+    it('should else if', function() {
       var str = [
-          '- var users = ["tobi", "jane", "loki"]',
-          'for user in users',
-          '  if user == "tobi"',
-          '    p awesome #{user}',
-          '  else if user == "jane"',
-          '    p lame #{user}',
-          '  else',
-          '    p #{user}',
+        '- var users = ["tobi", "jane", "loki"]',
+        'for user in users',
+        '  if user == "tobi"',
+        '    p awesome #{user}',
+        '  else if user == "jane"',
+        '    p lame #{user}',
+        '  else',
+        '    p #{user}',
       ].join('\n');
 
-      assert.equal('<p>awesome tobi</p><p>lame jane</p><p>loki</p>', pug.render(str));
+      assert.equal(
+        '<p>awesome tobi</p><p>lame jane</p><p>loki</p>',
+        pug.render(str)
+      );
     });
 
-    it('should include block', function(){
+    it('should include block', function() {
       var str = [
-          'html',
-          '  head',
-          '    include fixtures/scripts.pug',
-          '      scripts(src="/app.js")',
+        'html',
+        '  head',
+        '    include fixtures/scripts.pug',
+        '      scripts(src="/app.js")',
       ].join('\n');
 
-      assert.equal('<html><head><script src=\"/jquery.js\"></script><script src=\"/caustic.js\"></script><scripts src=\"/app.js\"></scripts></head></html>'
-      , pug.render(str, { filename: __dirname + '/pug.test.js' }));
+      assert.equal(
+        '<html><head><script src="/jquery.js"></script><script src="/caustic.js"></script><scripts src="/app.js"></scripts></head></html>',
+        pug.render(str, {filename: __dirname + '/pug.test.js'})
+      );
     });
 
-    it('should not fail on js newlines', function(){
-      assert.equal("<p>foo\u2028bar</p>", pug.render("p foo\u2028bar"));
-      assert.equal("<p>foo\u2029bar</p>", pug.render("p foo\u2029bar"));
+    it('should not fail on js newlines', function() {
+      assert.equal('<p>foo\u2028bar</p>', pug.render('p foo\u2028bar'));
+      assert.equal('<p>foo\u2029bar</p>', pug.render('p foo\u2029bar'));
     });
 
     it('should display error line number correctly up to token level', function() {
@@ -882,235 +1113,323 @@ describe('pug', function(){
           return err.message.split('\n')[0];
         }
       };
-      assert.equal(errorLocation(str), "Pug:13:16");
+      assert.equal(errorLocation(str), 'Pug:13:16');
     });
   });
 
-  describe('.compileFile()', function () {
-    it('does not produce warnings for issue-1593', function () {
+  describe('.compileFile()', function() {
+    it('does not produce warnings for issue-1593', function() {
       pug.compileFile(__dirname + '/fixtures/issue-1593/index.pug');
     });
-    it('should support caching (pass 1)', function () {
+    it('should support caching (pass 1)', function() {
       fs.writeFileSync(__dirname + '/temp/input-compileFile.pug', '.foo bar');
-      var fn = pug.compileFile(__dirname + '/temp/input-compileFile.pug',
-                                { cache: true });
+      var fn = pug.compileFile(__dirname + '/temp/input-compileFile.pug', {
+        cache: true,
+      });
       var expected = '<div class="foo">bar</div>';
       assert(fn() === expected);
     });
-    it('should support caching (pass 2)', function () {
+    it('should support caching (pass 2)', function() {
       // Poison the input file
-      fs.writeFileSync(__dirname + '/temp/input-compileFile.pug', '.big fat hen');
-      var fn = pug.compileFile(__dirname + '/temp/input-compileFile.pug',
-                                { cache: true });
+      fs.writeFileSync(
+        __dirname + '/temp/input-compileFile.pug',
+        '.big fat hen'
+      );
+      var fn = pug.compileFile(__dirname + '/temp/input-compileFile.pug', {
+        cache: true,
+      });
       var expected = '<div class="foo">bar</div>';
       assert(fn() === expected);
     });
   });
 
-  describe('.render()', function () {
-    it('should support .pug.render(str, fn)', function(){
-      pug.render('p foo bar', function(err, str){
+  describe('.render()', function() {
+    it('should support .pug.render(str, fn)', function() {
+      pug.render('p foo bar', function(err, str) {
         assert.ok(!err);
         assert.equal('<p>foo bar</p>', str);
       });
     });
 
-    it('should support .pug.render(str, options, fn)', function(){
-      pug.render('p #{foo}', { foo: 'bar' }, function(err, str){
+    it('should support .pug.render(str, options, fn)', function() {
+      pug.render('p #{foo}', {foo: 'bar'}, function(err, str) {
         assert.ok(!err);
         assert.equal('<p>bar</p>', str);
       });
     });
 
-    it('should support .pug.render(str, options, fn) cache', function(){
-      pug.render('p bar', { cache: true }, function(err, str){
-        assert.ok(/the "filename" option is required for caching/.test(err.message));
+    it('should support .pug.render(str, options, fn) cache', function() {
+      pug.render('p bar', {cache: true}, function(err, str) {
+        assert.ok(
+          /the "filename" option is required for caching/.test(err.message)
+        );
       });
 
-      pug.render('p foo bar', { cache: true, filename: 'test' }, function(err, str){
+      pug.render('p foo bar', {cache: true, filename: 'test'}, function(
+        err,
+        str
+      ) {
         assert.ok(!err);
         assert.equal('<p>foo bar</p>', str);
       });
     });
-  })
+  });
 
-  describe('.compile()', function(){
-    it('should support .compile()', function(){
+  describe('.compile()', function() {
+    it('should support .compile()', function() {
       var fn = pug.compile('p foo');
       assert.equal('<p>foo</p>', fn());
     });
 
-    it('should support .compile() locals', function(){
+    it('should support .compile() locals', function() {
       var fn = pug.compile('p= foo');
-      assert.equal('<p>bar</p>', fn({ foo: 'bar' }));
+      assert.equal('<p>bar</p>', fn({foo: 'bar'}));
     });
 
-    it('should support .compile() locals in \'self\' hash', function(){
+    it("should support .compile() locals in 'self' hash", function() {
       var fn = pug.compile('p= self.foo', {self: true});
-      assert.equal('<p>bar</p>', fn({ foo: 'bar' }));
+      assert.equal('<p>bar</p>', fn({foo: 'bar'}));
     });
 
-    it('should support .compile() no debug', function(){
+    it('should support .compile() no debug', function() {
       var fn = pug.compile('p foo\np #{bar}', {compileDebug: false});
       assert.equal('<p>foo</p><p>baz</p>', fn({bar: 'baz'}));
     });
 
-    it('should support .compile() no debug and global helpers', function(){
-      var fn = pug.compile('p foo\np #{bar}', {compileDebug: false, helpers: 'global'});
+    it('should support .compile() no debug and global helpers', function() {
+      var fn = pug.compile('p foo\np #{bar}', {
+        compileDebug: false,
+        helpers: 'global',
+      });
       assert.equal('<p>foo</p><p>baz</p>', fn({bar: 'baz'}));
     });
 
-    it('should be reasonably fast', function(){
-      pug.compile(perfTest, {})
+    it('should be reasonably fast', function() {
+      pug.compile(perfTest, {});
     });
-    it('allows trailing space (see #1586)', function () {
+    it('allows trailing space (see #1586)', function() {
       var res = pug.render('ul \n  li An Item');
       assert.equal('<ul> <li>An Item</li></ul>', res);
     });
   });
 
-  describe('.compileClient()', function () {
-    it('should support pug.compileClient(str)', function () {
+  describe('.compileClient()', function() {
+    it('should support pug.compileClient(str)', function() {
       var src = fs.readFileSync(__dirname + '/cases/basic.pug');
-      var expected = fs.readFileSync(__dirname + '/cases/basic.html', 'utf8').replace(/\s/g, '');
+      var expected = fs
+        .readFileSync(__dirname + '/cases/basic.html', 'utf8')
+        .replace(/\s/g, '');
       var fn = pug.compileClient(src);
       fn = Function('pug', fn.toString() + '\nreturn template;')(pug.runtime);
       var actual = fn({name: 'foo'}).replace(/\s/g, '');
       expect(actual).toBe(expected);
     });
-    it('should support pug.compileClient(str, options)', function () {
+    it('should support pug.compileClient(str, options)', function() {
       var src = '.bar= self.foo';
       var fn = pug.compileClient(src, {self: true});
       fn = Function('pug', fn.toString() + '\nreturn template;')(pug.runtime);
       var actual = fn({foo: 'baz'});
       expect(actual).toBe('<div class="bar">baz</div>');
     });
-    it('should support module syntax in pug.compileClient(str, options) when inlineRuntimeFunctions it true', function () {
+    it('should support module syntax in pug.compileClient(str, options) when inlineRuntimeFunctions it true', function() {
       var src = '.bar= self.foo';
-      var fn = pug.compileClient(src, {self: true, module: true, inlineRuntimeFunctions: true});
+      var fn = pug.compileClient(src, {
+        self: true,
+        module: true,
+        inlineRuntimeFunctions: true,
+      });
       expect(fn).toMatchSnapshot();
-      fs.writeFileSync(__dirname + '/temp/input-compileModuleFileClient.js', fn);
+      fs.writeFileSync(
+        __dirname + '/temp/input-compileModuleFileClient.js',
+        fn
+      );
       var expected = '<div class="bar">baz</div>';
       var fn = require(__dirname + '/temp/input-compileModuleFileClient.js');
       expect(fn({foo: 'baz'})).toBe('<div class="bar">baz</div>');
     });
-    it('should support module syntax in pug.compileClient(str, options) when inlineRuntimeFunctions it false', function () {
+    it('should support module syntax in pug.compileClient(str, options) when inlineRuntimeFunctions it false', function() {
       var src = '.bar= self.foo';
-      var fn = pug.compileClient(src, {self: true, module: true, inlineRuntimeFunctions: false});
+      var fn = pug.compileClient(src, {
+        self: true,
+        module: true,
+        inlineRuntimeFunctions: false,
+      });
       expect(fn).toMatchSnapshot();
-      fs.writeFileSync(__dirname + '/temp/input-compileModuleFileClient.js', fn);
+      fs.writeFileSync(
+        __dirname + '/temp/input-compileModuleFileClient.js',
+        fn
+      );
       var fn = require(__dirname + '/temp/input-compileModuleFileClient.js');
       expect(fn({foo: 'baz'})).toBe('<div class="bar">baz</div>');
     });
   });
 
-  describe('.renderFile()', function () {
-    it('will synchronously return a string', function () {
-      var expected = fs.readFileSync(__dirname + '/cases/basic.html', 'utf8').replace(/\s/g, '');
-      var actual = pug.renderFile(__dirname + '/cases/basic.pug', {name: 'foo'}).replace(/\s/g, '');
+  describe('.renderFile()', function() {
+    it('will synchronously return a string', function() {
+      var expected = fs
+        .readFileSync(__dirname + '/cases/basic.html', 'utf8')
+        .replace(/\s/g, '');
+      var actual = pug
+        .renderFile(__dirname + '/cases/basic.pug', {name: 'foo'})
+        .replace(/\s/g, '');
       assert(actual === expected);
     });
-    it('when given a callback, it calls that rather than returning', function (done) {
-      var expected = fs.readFileSync(__dirname + '/cases/basic.html', 'utf8').replace(/\s/g, '');
-      pug.renderFile(__dirname + '/cases/basic.pug', {name: 'foo'}, function (err, actual) {
+    it('when given a callback, it calls that rather than returning', function(done) {
+      var expected = fs
+        .readFileSync(__dirname + '/cases/basic.html', 'utf8')
+        .replace(/\s/g, '');
+      pug.renderFile(__dirname + '/cases/basic.pug', {name: 'foo'}, function(
+        err,
+        actual
+      ) {
         if (err) return done(err);
         assert(actual.replace(/\s/g, '') === expected);
         done();
       });
     });
-    it('when given a callback, it calls that rather than returning even if there are no options', function (done) {
-      var expected = fs.readFileSync(__dirname + '/cases/basic.html', 'utf8').replace(/\s/g, '');
-      pug.renderFile(__dirname + '/cases/basic.pug', function (err, actual) {
+    it('when given a callback, it calls that rather than returning even if there are no options', function(done) {
+      var expected = fs
+        .readFileSync(__dirname + '/cases/basic.html', 'utf8')
+        .replace(/\s/g, '');
+      pug.renderFile(__dirname + '/cases/basic.pug', function(err, actual) {
         if (err) return done(err);
         assert(actual.replace(/\s/g, '') === expected);
         done();
       });
     });
-    it('when given a callback, it calls that with any errors', function (done) {
-      pug.renderFile(__dirname + '/fixtures/runtime.error.pug', function (err, actual) {
+    it('when given a callback, it calls that with any errors', function(done) {
+      pug.renderFile(__dirname + '/fixtures/runtime.error.pug', function(
+        err,
+        actual
+      ) {
         assert.ok(err);
         done();
       });
     });
-    it('should support caching (pass 1)', function (done) {
+    it('should support caching (pass 1)', function(done) {
       fs.writeFileSync(__dirname + '/temp/input-renderFile.pug', '.foo bar');
-      pug.renderFile(__dirname + '/temp/input-renderFile.pug', { cache: true }, function (err, actual) {
-        if (err) return done(err);
-        assert.equal('<div class="foo">bar</div>', actual);
-        done();
-      });
+      pug.renderFile(
+        __dirname + '/temp/input-renderFile.pug',
+        {cache: true},
+        function(err, actual) {
+          if (err) return done(err);
+          assert.equal('<div class="foo">bar</div>', actual);
+          done();
+        }
+      );
     });
-    it('should support caching (pass 2)', function (done) {
+    it('should support caching (pass 2)', function(done) {
       // Poison the input file
-      fs.writeFileSync(__dirname + '/temp/input-renderFile.pug', '.big fat hen');
-      pug.renderFile(__dirname + '/temp/input-renderFile.pug', { cache: true }, function (err, actual) {
-        if (err) return done(err);
-        assert.equal('<div class="foo">bar</div>', actual);
-        done();
-      });
+      fs.writeFileSync(
+        __dirname + '/temp/input-renderFile.pug',
+        '.big fat hen'
+      );
+      pug.renderFile(
+        __dirname + '/temp/input-renderFile.pug',
+        {cache: true},
+        function(err, actual) {
+          if (err) return done(err);
+          assert.equal('<div class="foo">bar</div>', actual);
+          done();
+        }
+      );
     });
   });
 
-  describe('.compileFileClient(path, options)', function () {
-    it('returns a string form of a function called `template`', function () {
+  describe('.compileFileClient(path, options)', function() {
+    it('returns a string form of a function called `template`', function() {
       var src = pug.compileFileClient(__dirname + '/cases/basic.pug');
-      var expected = fs.readFileSync(__dirname + '/cases/basic.html', 'utf8').replace(/\s/g, '');
+      var expected = fs
+        .readFileSync(__dirname + '/cases/basic.html', 'utf8')
+        .replace(/\s/g, '');
       var fn = Function('pug', src + '\nreturn template;')(pug.runtime);
       var actual = fn({name: 'foo'}).replace(/\s/g, '');
       assert(actual === expected);
     });
-    it('accepts the `name` option to rename the resulting function', function () {
-      var src = pug.compileFileClient(__dirname + '/cases/basic.pug', {name: 'myTemplateName'});
-      var expected = fs.readFileSync(__dirname + '/cases/basic.html', 'utf8').replace(/\s/g, '');
+    it('accepts the `name` option to rename the resulting function', function() {
+      var src = pug.compileFileClient(__dirname + '/cases/basic.pug', {
+        name: 'myTemplateName',
+      });
+      var expected = fs
+        .readFileSync(__dirname + '/cases/basic.html', 'utf8')
+        .replace(/\s/g, '');
       var fn = Function('pug', src + '\nreturn myTemplateName;')(pug.runtime);
       var actual = fn({name: 'foo'}).replace(/\s/g, '');
       assert(actual === expected);
     });
-    it('should support caching (pass 1)', function () {
-      fs.writeFileSync(__dirname + '/temp/input-compileFileClient.pug', '.foo bar');
-      var src = pug.compileFileClient(__dirname + '/temp/input-compileFileClient.pug',
-                                        { name: 'myTemplateName',
-                                          cache: true });
+    it('should support caching (pass 1)', function() {
+      fs.writeFileSync(
+        __dirname + '/temp/input-compileFileClient.pug',
+        '.foo bar'
+      );
+      var src = pug.compileFileClient(
+        __dirname + '/temp/input-compileFileClient.pug',
+        {name: 'myTemplateName', cache: true}
+      );
       var expected = '<div class="foo">bar</div>';
       var fn = Function('pug', src + '\nreturn myTemplateName;')(pug.runtime);
       assert(fn() === expected);
     });
-    it('should support caching (pass 2)', function () {
+    it('should support caching (pass 2)', function() {
       // Poison the input file
-      fs.writeFileSync(__dirname + '/temp/input-compileFileClient.pug', '.big fat hen');
-      var src = pug.compileFileClient(__dirname + '/temp/input-compileFileClient.pug',
-                                        { name: 'myTemplateName',
-                                          cache: true });
+      fs.writeFileSync(
+        __dirname + '/temp/input-compileFileClient.pug',
+        '.big fat hen'
+      );
+      var src = pug.compileFileClient(
+        __dirname + '/temp/input-compileFileClient.pug',
+        {name: 'myTemplateName', cache: true}
+      );
       var expected = '<div class="foo">bar</div>';
       var fn = Function('pug', src + '\nreturn myTemplateName;')(pug.runtime);
       assert(fn() === expected);
     });
   });
 
-  describe('.runtime', function () {
-    describe('.merge', function () {
-      it('merges two attribute objects, giving precedensce to the second object', function () {
-        assert.deepEqual(pug.runtime.merge({}, {'class': ['foo', 'bar'], 'foo': 'bar'}), {'class': ['foo', 'bar'], 'foo': 'bar'});
-        assert.deepEqual(pug.runtime.merge({'class': ['foo'], 'foo': 'baz'}, {'class': ['bar'], 'foo': 'bar'}), {'class': ['foo', 'bar'], 'foo': 'bar'});
-        assert.deepEqual(pug.runtime.merge({'class': ['foo', 'bar'], 'foo': 'bar'}, {}), {'class': ['foo', 'bar'], 'foo': 'bar'});
+  describe('.runtime', function() {
+    describe('.merge', function() {
+      it('merges two attribute objects, giving precedensce to the second object', function() {
+        assert.deepEqual(
+          pug.runtime.merge({}, {class: ['foo', 'bar'], foo: 'bar'}),
+          {class: ['foo', 'bar'], foo: 'bar'}
+        );
+        assert.deepEqual(
+          pug.runtime.merge(
+            {class: ['foo'], foo: 'baz'},
+            {class: ['bar'], foo: 'bar'}
+          ),
+          {class: ['foo', 'bar'], foo: 'bar'}
+        );
+        assert.deepEqual(
+          pug.runtime.merge({class: ['foo', 'bar'], foo: 'bar'}, {}),
+          {class: ['foo', 'bar'], foo: 'bar'}
+        );
       });
     });
-    describe('.attrs', function () {
-      it('Renders the given attributes object', function () {
+    describe('.attrs', function() {
+      it('Renders the given attributes object', function() {
         assert.equal(pug.runtime.attrs({}), '');
-        assert.equal(pug.runtime.attrs({'class': []}), '');
-        assert.equal(pug.runtime.attrs({'class': ['foo']}), ' class="foo"');
-        assert.equal(pug.runtime.attrs({'class': ['foo'], 'id': 'bar'}), ' class="foo" id="bar"');
+        assert.equal(pug.runtime.attrs({class: []}), '');
+        assert.equal(pug.runtime.attrs({class: ['foo']}), ' class="foo"');
+        assert.equal(
+          pug.runtime.attrs({class: ['foo'], id: 'bar'}),
+          ' class="foo" id="bar"'
+        );
       });
     });
   });
 
-  describe('filter indentation', function () {
-    it('is maintained', function () {
+  describe('filter indentation', function() {
+    it('is maintained', function() {
       var filters = {
-        indents: function(str){
-          return str.split(/\n/).map(function (line) { return line.match(/^ */)[0].length; }).join(",");
-        }
+        indents: function(str) {
+          return str
+            .split(/\n/)
+            .map(function(line) {
+              return line.match(/^ */)[0].length;
+            })
+            .join(',');
+        },
       };
 
       var indents = [
@@ -1129,47 +1448,58 @@ describe('pug', function(){
         '  x',
         '    x',
         '  x',
-        '   x'
+        '   x',
       ].join('\n');
 
-      assert.equal(pug.render(indents, {filters: filters}), '0,1,2,3,0,4,4,3,3,4,2,0,2,0,1');
+      assert.equal(
+        pug.render(indents, {filters: filters}),
+        '0,1,2,3,0,4,4,3,3,4,2,0,2,0,1'
+      );
     });
   });
 
   describe('.compile().dependencies', function() {
-    it('should list the filename of the template referenced by extends', function(){
+    it('should list the filename of the template referenced by extends', function() {
       var filename = __dirname + '/dependencies/extends1.pug';
       var str = fs.readFileSync(filename, 'utf8');
       var info = pug.compile(str, {filename: filename});
-      assert.deepEqual([
-        path.resolve(__dirname + '/dependencies/dependency1.pug')
-      ], info.dependencies);
+      assert.deepEqual(
+        [path.resolve(__dirname + '/dependencies/dependency1.pug')],
+        info.dependencies
+      );
     });
     it('should list the filename of the template referenced by an include', function() {
       var filename = __dirname + '/dependencies/include1.pug';
       var str = fs.readFileSync(filename, 'utf8');
       var info = pug.compile(str, {filename: filename});
-      assert.deepEqual([
-        path.resolve(__dirname + '/dependencies/dependency1.pug')
-      ], info.dependencies);
+      assert.deepEqual(
+        [path.resolve(__dirname + '/dependencies/dependency1.pug')],
+        info.dependencies
+      );
     });
     it('should list the dependencies of extends dependencies', function() {
       var filename = __dirname + '/dependencies/extends2.pug';
       var str = fs.readFileSync(filename, 'utf8');
       var info = pug.compile(str, {filename: filename});
-      assert.deepEqual([
-        path.resolve(__dirname + '/dependencies/dependency2.pug'),
-        path.resolve(__dirname + '/dependencies/dependency3.pug')
-      ], info.dependencies);
+      assert.deepEqual(
+        [
+          path.resolve(__dirname + '/dependencies/dependency2.pug'),
+          path.resolve(__dirname + '/dependencies/dependency3.pug'),
+        ],
+        info.dependencies
+      );
     });
     it('should list the dependencies of include dependencies', function() {
       var filename = __dirname + '/dependencies/include2.pug';
       var str = fs.readFileSync(filename, 'utf8');
       var info = pug.compile(str, {filename: filename});
-      assert.deepEqual([
-        path.resolve(__dirname + '/dependencies/dependency2.pug'),
-        path.resolve(__dirname + '/dependencies/dependency3.pug')
-      ],info.dependencies);
+      assert.deepEqual(
+        [
+          path.resolve(__dirname + '/dependencies/dependency2.pug'),
+          path.resolve(__dirname + '/dependencies/dependency3.pug'),
+        ],
+        info.dependencies
+      );
     });
   });
 
diff --git a/packages/pug/test/regression-2436/index.test.js b/packages/pug/test/regression-2436/index.test.js
index 47a1ae44b..d9647b83b 100644
--- a/packages/pug/test/regression-2436/index.test.js
+++ b/packages/pug/test/regression-2436/index.test.js
@@ -1,17 +1,11 @@
 const pug = require('../../');
 
 test('#2436 - block with a same name extends from the same layout in nesting', () => {
-    const output = pug.renderFile(
-        __dirname + '/issue1.pug',
-        {pretty: true}
-    );
-    expect(output).toMatchSnapshot();
+  const output = pug.renderFile(__dirname + '/issue1.pug', {pretty: true});
+  expect(output).toMatchSnapshot();
 });
 
 test('#2436 - block with a same name extends from different layout in nesting', () => {
-    const output = pug.renderFile(
-        __dirname + '/issue2.pug',
-        {pretty: true}
-    );
-    expect(output).toMatchSnapshot();
+  const output = pug.renderFile(__dirname + '/issue2.pug', {pretty: true});
+  expect(output).toMatchSnapshot();
 });
diff --git a/packages/pug/test/run-es2015.test.js b/packages/pug/test/run-es2015.test.js
index 0ab14df5d..0ee3d35bc 100644
--- a/packages/pug/test/run-es2015.test.js
+++ b/packages/pug/test/run-es2015.test.js
@@ -11,7 +11,7 @@ var es2015 = runUtils.findCases(__dirname + '/cases-es2015');
 
 mkdirp(__dirname + '/output-es2015');
 
-describe('test cases for ECMAScript 2015', function () {
+describe('test cases for ECMAScript 2015', function() {
   try {
     eval('``');
     es2015.forEach(runUtils.testSingle.bind(null, it, '-es2015'));
diff --git a/packages/pug/test/run-syntax-errors.test.js b/packages/pug/test/run-syntax-errors.test.js
index 8a0a54a18..379750cdd 100644
--- a/packages/pug/test/run-syntax-errors.test.js
+++ b/packages/pug/test/run-syntax-errors.test.js
@@ -5,10 +5,10 @@ const pug = require('../');
 
 const anti = runUtils.findCases(__dirname + '/anti-cases');
 
-describe('certain syntax is not allowed and will throw a compile time error', function () {
-  anti.forEach(function(test){
+describe('certain syntax is not allowed and will throw a compile time error', function() {
+  anti.forEach(function(test) {
     var name = test.replace(/[-.]/g, ' ');
-    it(name, function(){
+    it(name, function() {
       var path = __dirname.replace(/\\/g, '/') + '/anti-cases/' + test + '.pug';
       var str = fs.readFileSync(path, 'utf8');
       try {
@@ -16,19 +16,28 @@ describe('certain syntax is not allowed and will throw a compile time error', fu
           filename: path,
           pretty: true,
           basedir: __dirname + '/anti-cases',
-          filters: runUtils.filters
+          filters: runUtils.filters,
         });
       } catch (ex) {
         if (!ex.code) {
           throw ex;
         }
         assert(ex instanceof Error, 'Should throw a real Error');
-        assert(ex.code.indexOf('PUG:') === 0, 'It should have a code of "PUG:SOMETHING"');
-        assert(ex.message.replace(/\\/g, '/').indexOf(path) === 0, 'it should start with the path');
-        assert(/:\d+$/m.test(ex.message.replace(/\\/g, '/')), 'it should include a line number.');
+        assert(
+          ex.code.indexOf('PUG:') === 0,
+          'It should have a code of "PUG:SOMETHING"'
+        );
+        assert(
+          ex.message.replace(/\\/g, '/').indexOf(path) === 0,
+          'it should start with the path'
+        );
+        assert(
+          /:\d+$/m.test(ex.message.replace(/\\/g, '/')),
+          'it should include a line number.'
+        );
         return;
       }
       throw new Error(test + ' should have thrown an error');
-    })
+    });
   });
 });
diff --git a/packages/pug/test/run-utils.js b/packages/pug/test/run-utils.js
index 53078981f..2d1eccf3e 100644
--- a/packages/pug/test/run-utils.js
+++ b/packages/pug/test/run-utils.js
@@ -5,11 +5,11 @@ var uglify = require('uglify-js');
 var mkdirp = require('mkdirp').sync;
 
 var filters = {
-  custom: function (str, options) {
+  custom: function(str, options) {
     assert(options.opt === 'val');
     assert(options.num === 2);
     return 'BEGIN' + str + 'END';
-  }
+  },
 };
 
 // test cases
@@ -28,16 +28,19 @@ function writeFileSync(filename, data) {
 }
 
 function findCases(dir) {
-  return fs.readdirSync(dir).filter(function(file){
-    return ~file.indexOf('.pug');
-  }).map(function(file){
-    return file.replace('.pug', '');
-  });
+  return fs
+    .readdirSync(dir)
+    .filter(function(file) {
+      return ~file.indexOf('.pug');
+    })
+    .map(function(file) {
+      return file.replace('.pug', '');
+    });
 }
 
-function testSingle(it, suffix, test){
+function testSingle(it, suffix, test) {
   var name = test.replace(/[-.]/g, ' ');
-  it(name, function(){
+  it(name, function() {
     var path = __dirname + '/cases' + suffix + '/' + test + '.pug';
     var str = fs.readFileSync(path, 'utf8');
     var fn = pug.compile(str, {
@@ -45,52 +48,98 @@ function testSingle(it, suffix, test){
       pretty: true,
       basedir: __dirname + '/cases' + suffix,
       filters: filters,
-      filterAliases: {'markdown': 'markdown-it'},
+      filterAliases: {markdown: 'markdown-it'},
     });
-    var actual = fn({ title: 'Pug' });
+    var actual = fn({title: 'Pug'});
 
-    writeFileSync(__dirname + '/output' + suffix + '/' + test + '.html', actual);
+    writeFileSync(
+      __dirname + '/output' + suffix + '/' + test + '.html',
+      actual
+    );
 
-    var html = fs.readFileSync(__dirname + '/cases' + suffix + '/' + test + '.html', 'utf8').trim().replace(/\r/g, '');
-    var clientCode = uglify.minify(pug.compileClient(str, {
-      filename: path,
-      pretty: true,
-      compileDebug: false,
-      basedir: __dirname + '/cases' + suffix,
-      filters: filters,
-      filterAliases: {'markdown': 'markdown-it'},
-    }), {output: {beautify: true}, mangle: false, compress: false, fromString: true}).code;
-    var clientCodeDebug = uglify.minify(pug.compileClient(str, {
-      filename: path,
-      pretty: true,
-      compileDebug: true,
-      basedir: __dirname + '/cases' + suffix,
-      filters: filters,
-      filterAliases: {'markdown': 'markdown-it'},
-    }), {output: {beautify: true}, mangle: false, compress: false, fromString: true}).code;
-    writeFileSync(__dirname + '/output' + suffix + '/' + test + '.js', uglify.minify(pug.compileClient(str, {
-      filename: path,
-      pretty: false,
-      compileDebug: false,
-      basedir: __dirname + '/cases' + suffix,
-      filters: filters,
-      filterAliases: {'markdown': 'markdown-it'},
-    }), {output: {beautify: true}, mangle: false, compress: false, fromString: true}).code);
+    var html = fs
+      .readFileSync(
+        __dirname + '/cases' + suffix + '/' + test + '.html',
+        'utf8'
+      )
+      .trim()
+      .replace(/\r/g, '');
+    var clientCode = uglify.minify(
+      pug.compileClient(str, {
+        filename: path,
+        pretty: true,
+        compileDebug: false,
+        basedir: __dirname + '/cases' + suffix,
+        filters: filters,
+        filterAliases: {markdown: 'markdown-it'},
+      }),
+      {
+        output: {beautify: true},
+        mangle: false,
+        compress: false,
+        fromString: true,
+      }
+    ).code;
+    var clientCodeDebug = uglify.minify(
+      pug.compileClient(str, {
+        filename: path,
+        pretty: true,
+        compileDebug: true,
+        basedir: __dirname + '/cases' + suffix,
+        filters: filters,
+        filterAliases: {markdown: 'markdown-it'},
+      }),
+      {
+        output: {beautify: true},
+        mangle: false,
+        compress: false,
+        fromString: true,
+      }
+    ).code;
+    writeFileSync(
+      __dirname + '/output' + suffix + '/' + test + '.js',
+      uglify.minify(
+        pug.compileClient(str, {
+          filename: path,
+          pretty: false,
+          compileDebug: false,
+          basedir: __dirname + '/cases' + suffix,
+          filters: filters,
+          filterAliases: {markdown: 'markdown-it'},
+        }),
+        {
+          output: {beautify: true},
+          mangle: false,
+          compress: false,
+          fromString: true,
+        }
+      ).code
+    );
     if (/filter/.test(test)) {
       actual = actual.replace(/\n| /g, '');
       html = html.replace(/\n| /g, '');
     }
     if (/mixins-unused/.test(test)) {
-      assert(/never-called/.test(str), 'never-called is in the pug file for mixins-unused');
-      assert(!/never-called/.test(clientCode), 'never-called should be removed from the code');
+      assert(
+        /never-called/.test(str),
+        'never-called is in the pug file for mixins-unused'
+      );
+      assert(
+        !/never-called/.test(clientCode),
+        'never-called should be removed from the code'
+      );
     }
     expect(actual.trim()).toEqual(html);
-    actual = Function('pug', clientCode + '\nreturn template;')()({ title: 'Pug' });
+    actual = Function('pug', clientCode + '\nreturn template;')()({
+      title: 'Pug',
+    });
     if (/filter/.test(test)) {
       actual = actual.replace(/\n| /g, '');
     }
     expect(actual.trim()).toEqual(html);
-    actual = Function('pug', clientCodeDebug + '\nreturn template;')()({ title: 'Pug' });
+    actual = Function('pug', clientCodeDebug + '\nreturn template;')()({
+      title: 'Pug',
+    });
     if (/filter/.test(test)) {
       actual = actual.replace(/\n| /g, '');
     }
@@ -98,7 +147,6 @@ function testSingle(it, suffix, test){
   });
 }
 
-
 module.exports = {
   filters,
   findCases,
diff --git a/packages/pug/test/run.test.js b/packages/pug/test/run.test.js
index 83a668ffe..b5c0270fb 100644
--- a/packages/pug/test/run.test.js
+++ b/packages/pug/test/run.test.js
@@ -13,7 +13,7 @@ var es2015 = runUtils.findCases(__dirname + '/cases-es2015');
 
 mkdirp(__dirname + '/output');
 
-describe('test cases', function () {
+describe('test cases', function() {
   cases.forEach((test, i) => {
     runUtils.testSingle(it, '', test);
   });
diff --git a/packages/pug/test/shadowed-block/index.test.js b/packages/pug/test/shadowed-block/index.test.js
index 82f82f416..97999a851 100644
--- a/packages/pug/test/shadowed-block/index.test.js
+++ b/packages/pug/test/shadowed-block/index.test.js
@@ -1,14 +1,10 @@
 const pug = require('../../');
 
 test('layout with shadowed block', () => {
-  const outputWithAjax = pug.renderFile(
-    __dirname + '/index.pug',
-    {ajax: true}
-  );
-  const outputWithoutAjax = pug.renderFile(
-    __dirname + '/index.pug',
-    {ajax: false}
-  );
+  const outputWithAjax = pug.renderFile(__dirname + '/index.pug', {ajax: true});
+  const outputWithoutAjax = pug.renderFile(__dirname + '/index.pug', {
+    ajax: false,
+  });
   expect(outputWithAjax).toMatchSnapshot();
   expect(outputWithoutAjax).toMatchSnapshot();
 });
diff --git a/scripts/filename-serializer.js b/scripts/filename-serializer.js
index fc172ccac..1f78ffd5e 100644
--- a/scripts/filename-serializer.js
+++ b/scripts/filename-serializer.js
@@ -2,7 +2,10 @@ const path = require('path');
 const basedir = path.resolve(__dirname + '/..');
 
 function matchesBasedir(value) {
-  return typeof value === 'string' && value.replace(/\\/g, '/').indexOf(basedir.replace(/\\/g, '/')) === 0
+  return (
+    typeof value === 'string' &&
+    value.replace(/\\/g, '/').indexOf(basedir.replace(/\\/g, '/')) === 0
+  );
 }
 function removeBasedir(value) {
   return '<basedir>' + value.substr(basedir.length).replace(/\\/g, '/');
@@ -11,7 +14,9 @@ function removeBasedir(value) {
 module.exports = {
   test: function(val) {
     return (
-      val && typeof val === 'object' && (matchesBasedir(val.filename) || matchesBasedir(val.message))
+      val &&
+      typeof val === 'object' &&
+      (matchesBasedir(val.filename) || matchesBasedir(val.message))
     );
   },
   print: function(val, serialize, indent) {
@@ -26,5 +31,5 @@ module.exports = {
       output.message = removeBasedir(output.message);
     }
     return serialize(output);
-  }
+  },
 };
diff --git a/scripts/prettier-javascript-serializer.js b/scripts/prettier-javascript-serializer.js
index 0f56b1d1f..bee91b90e 100644
--- a/scripts/prettier-javascript-serializer.js
+++ b/scripts/prettier-javascript-serializer.js
@@ -27,5 +27,5 @@ module.exports = {
   },
   print: function(val, serialize, indent) {
     return serialize(prettier.format(val, prettierOptions));
-  }
+  },
 };
diff --git a/yarn.lock b/yarn.lock
index 774e87e83..d9d942497 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -139,80 +139,6 @@
     exec-sh "^0.3.2"
     minimist "^1.2.0"
 
-"@evocateur/libnpmaccess@^3.1.2":
-  version "3.1.2"
-  resolved "https://registry.npmjs.org/@evocateur/libnpmaccess/-/libnpmaccess-3.1.2.tgz#ecf7f6ce6b004e9f942b098d92200be4a4b1c845"
-  integrity sha512-KSCAHwNWro0CF2ukxufCitT9K5LjL/KuMmNzSu8wuwN2rjyKHD8+cmOsiybK+W5hdnwc5M1SmRlVCaMHQo+3rg==
-  dependencies:
-    "@evocateur/npm-registry-fetch" "^4.0.0"
-    aproba "^2.0.0"
-    figgy-pudding "^3.5.1"
-    get-stream "^4.0.0"
-    npm-package-arg "^6.1.0"
-
-"@evocateur/libnpmpublish@^1.2.2":
-  version "1.2.2"
-  resolved "https://registry.npmjs.org/@evocateur/libnpmpublish/-/libnpmpublish-1.2.2.tgz#55df09d2dca136afba9c88c759ca272198db9f1a"
-  integrity sha512-MJrrk9ct1FeY9zRlyeoyMieBjGDG9ihyyD9/Ft6MMrTxql9NyoEx2hw9casTIP4CdqEVu+3nQ2nXxoJ8RCXyFg==
-  dependencies:
-    "@evocateur/npm-registry-fetch" "^4.0.0"
-    aproba "^2.0.0"
-    figgy-pudding "^3.5.1"
-    get-stream "^4.0.0"
-    lodash.clonedeep "^4.5.0"
-    normalize-package-data "^2.4.0"
-    npm-package-arg "^6.1.0"
-    semver "^5.5.1"
-    ssri "^6.0.1"
-
-"@evocateur/npm-registry-fetch@^4.0.0":
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/@evocateur/npm-registry-fetch/-/npm-registry-fetch-4.0.0.tgz#8c4c38766d8d32d3200fcb0a83f064b57365ed66"
-  integrity sha512-k1WGfKRQyhJpIr+P17O5vLIo2ko1PFLKwoetatdduUSt/aQ4J2sJrJwwatdI5Z3SiYk/mRH9S3JpdmMFd/IK4g==
-  dependencies:
-    JSONStream "^1.3.4"
-    bluebird "^3.5.1"
-    figgy-pudding "^3.4.1"
-    lru-cache "^5.1.1"
-    make-fetch-happen "^5.0.0"
-    npm-package-arg "^6.1.0"
-    safe-buffer "^5.1.2"
-
-"@evocateur/pacote@^9.6.3":
-  version "9.6.5"
-  resolved "https://registry.npmjs.org/@evocateur/pacote/-/pacote-9.6.5.tgz#33de32ba210b6f17c20ebab4d497efc6755f4ae5"
-  integrity sha512-EI552lf0aG2nOV8NnZpTxNo2PcXKPmDbF9K8eCBFQdIZwHNGN/mi815fxtmUMa2wTa1yndotICIDt/V0vpEx2w==
-  dependencies:
-    "@evocateur/npm-registry-fetch" "^4.0.0"
-    bluebird "^3.5.3"
-    cacache "^12.0.3"
-    chownr "^1.1.2"
-    figgy-pudding "^3.5.1"
-    get-stream "^4.1.0"
-    glob "^7.1.4"
-    infer-owner "^1.0.4"
-    lru-cache "^5.1.1"
-    make-fetch-happen "^5.0.0"
-    minimatch "^3.0.4"
-    minipass "^2.3.5"
-    mississippi "^3.0.0"
-    mkdirp "^0.5.1"
-    normalize-package-data "^2.5.0"
-    npm-package-arg "^6.1.0"
-    npm-packlist "^1.4.4"
-    npm-pick-manifest "^3.0.0"
-    osenv "^0.1.5"
-    promise-inflight "^1.0.1"
-    promise-retry "^1.1.1"
-    protoduck "^5.0.1"
-    rimraf "^2.6.3"
-    safe-buffer "^5.2.0"
-    semver "^5.7.0"
-    ssri "^6.0.1"
-    tar "^4.4.10"
-    unique-filename "^1.1.1"
-    which "^1.3.1"
-
 "@jest/console@^24.7.1", "@jest/console@^24.9.0":
   version "24.9.0"
   resolved "https://registry.npmjs.org/@jest/console/-/console-24.9.0.tgz#79b1bc06fb74a8cfb01cbdedf945584b1b9707f0"
@@ -361,797 +287,6 @@
     "@types/istanbul-reports" "^1.1.1"
     "@types/yargs" "^13.0.0"
 
-"@lerna/add@3.20.0":
-  version "3.20.0"
-  resolved "https://registry.npmjs.org/@lerna/add/-/add-3.20.0.tgz#bea7edf36fc93fb72ec34cb9ba854c48d4abf309"
-  integrity sha512-AnH1oRIEEg/VDa3SjYq4x1/UglEAvrZuV0WssHUMN81RTZgQk3we+Mv3qZNddrZ/fBcZu2IAdN/EQ3+ie2JxKQ==
-  dependencies:
-    "@evocateur/pacote" "^9.6.3"
-    "@lerna/bootstrap" "3.20.0"
-    "@lerna/command" "3.18.5"
-    "@lerna/filter-options" "3.20.0"
-    "@lerna/npm-conf" "3.16.0"
-    "@lerna/validation-error" "3.13.0"
-    dedent "^0.7.0"
-    npm-package-arg "^6.1.0"
-    p-map "^2.1.0"
-    semver "^6.2.0"
-
-"@lerna/bootstrap@3.20.0":
-  version "3.20.0"
-  resolved "https://registry.npmjs.org/@lerna/bootstrap/-/bootstrap-3.20.0.tgz#635d71046830f208e851ab429a63da1747589e37"
-  integrity sha512-Wylullx3uthKE7r4izo09qeRGL20Y5yONlQEjPCfnbxCC2Elu+QcPu4RC6kqKQ7b+g7pdC3OOgcHZjngrwr5XQ==
-  dependencies:
-    "@lerna/command" "3.18.5"
-    "@lerna/filter-options" "3.20.0"
-    "@lerna/has-npm-version" "3.16.5"
-    "@lerna/npm-install" "3.16.5"
-    "@lerna/package-graph" "3.18.5"
-    "@lerna/pulse-till-done" "3.13.0"
-    "@lerna/rimraf-dir" "3.16.5"
-    "@lerna/run-lifecycle" "3.16.2"
-    "@lerna/run-topologically" "3.18.5"
-    "@lerna/symlink-binary" "3.17.0"
-    "@lerna/symlink-dependencies" "3.17.0"
-    "@lerna/validation-error" "3.13.0"
-    dedent "^0.7.0"
-    get-port "^4.2.0"
-    multimatch "^3.0.0"
-    npm-package-arg "^6.1.0"
-    npmlog "^4.1.2"
-    p-finally "^1.0.0"
-    p-map "^2.1.0"
-    p-map-series "^1.0.0"
-    p-waterfall "^1.0.0"
-    read-package-tree "^5.1.6"
-    semver "^6.2.0"
-
-"@lerna/changed@3.20.0":
-  version "3.20.0"
-  resolved "https://registry.npmjs.org/@lerna/changed/-/changed-3.20.0.tgz#66b97ebd6c8f8d207152ee524a0791846a9097ae"
-  integrity sha512-+hzMFSldbRPulZ0vbKk6RD9f36gaH3Osjx34wrrZ62VB4pKmjyuS/rxVYkCA3viPLHoiIw2F8zHM5BdYoDSbjw==
-  dependencies:
-    "@lerna/collect-updates" "3.20.0"
-    "@lerna/command" "3.18.5"
-    "@lerna/listable" "3.18.5"
-    "@lerna/output" "3.13.0"
-
-"@lerna/check-working-tree@3.16.5":
-  version "3.16.5"
-  resolved "https://registry.npmjs.org/@lerna/check-working-tree/-/check-working-tree-3.16.5.tgz#b4f8ae61bb4523561dfb9f8f8d874dd46bb44baa"
-  integrity sha512-xWjVBcuhvB8+UmCSb5tKVLB5OuzSpw96WEhS2uz6hkWVa/Euh1A0/HJwn2cemyK47wUrCQXtczBUiqnq9yX5VQ==
-  dependencies:
-    "@lerna/collect-uncommitted" "3.16.5"
-    "@lerna/describe-ref" "3.16.5"
-    "@lerna/validation-error" "3.13.0"
-
-"@lerna/child-process@3.16.5":
-  version "3.16.5"
-  resolved "https://registry.npmjs.org/@lerna/child-process/-/child-process-3.16.5.tgz#38fa3c18064aa4ac0754ad80114776a7b36a69b2"
-  integrity sha512-vdcI7mzei9ERRV4oO8Y1LHBZ3A5+ampRKg1wq5nutLsUA4mEBN6H7JqjWOMY9xZemv6+kATm2ofjJ3lW5TszQg==
-  dependencies:
-    chalk "^2.3.1"
-    execa "^1.0.0"
-    strong-log-transformer "^2.0.0"
-
-"@lerna/clean@3.20.0":
-  version "3.20.0"
-  resolved "https://registry.npmjs.org/@lerna/clean/-/clean-3.20.0.tgz#ba777e373ddeae63e57860df75d47a9e5264c5b2"
-  integrity sha512-9ZdYrrjQvR5wNXmHfDsfjWjp0foOkCwKe3hrckTzkAeQA1ibyz5llGwz5e1AeFrV12e2/OLajVqYfe+qdkZUgg==
-  dependencies:
-    "@lerna/command" "3.18.5"
-    "@lerna/filter-options" "3.20.0"
-    "@lerna/prompt" "3.18.5"
-    "@lerna/pulse-till-done" "3.13.0"
-    "@lerna/rimraf-dir" "3.16.5"
-    p-map "^2.1.0"
-    p-map-series "^1.0.0"
-    p-waterfall "^1.0.0"
-
-"@lerna/cli@3.18.5":
-  version "3.18.5"
-  resolved "https://registry.npmjs.org/@lerna/cli/-/cli-3.18.5.tgz#c90c461542fcd35b6d5b015a290fb0dbfb41d242"
-  integrity sha512-erkbxkj9jfc89vVs/jBLY/fM0I80oLmJkFUV3Q3wk9J3miYhP14zgVEBsPZY68IZlEjT6T3Xlq2xO1AVaatHsA==
-  dependencies:
-    "@lerna/global-options" "3.13.0"
-    dedent "^0.7.0"
-    npmlog "^4.1.2"
-    yargs "^14.2.2"
-
-"@lerna/collect-uncommitted@3.16.5":
-  version "3.16.5"
-  resolved "https://registry.npmjs.org/@lerna/collect-uncommitted/-/collect-uncommitted-3.16.5.tgz#a494d61aac31cdc7aec4bbe52c96550274132e63"
-  integrity sha512-ZgqnGwpDZiWyzIQVZtQaj9tRizsL4dUOhuOStWgTAw1EMe47cvAY2kL709DzxFhjr6JpJSjXV5rZEAeU3VE0Hg==
-  dependencies:
-    "@lerna/child-process" "3.16.5"
-    chalk "^2.3.1"
-    figgy-pudding "^3.5.1"
-    npmlog "^4.1.2"
-
-"@lerna/collect-updates@3.20.0":
-  version "3.20.0"
-  resolved "https://registry.npmjs.org/@lerna/collect-updates/-/collect-updates-3.20.0.tgz#62f9d76ba21a25b7d9fbf31c02de88744a564bd1"
-  integrity sha512-qBTVT5g4fupVhBFuY4nI/3FSJtQVcDh7/gEPOpRxoXB/yCSnT38MFHXWl+y4einLciCjt/+0x6/4AG80fjay2Q==
-  dependencies:
-    "@lerna/child-process" "3.16.5"
-    "@lerna/describe-ref" "3.16.5"
-    minimatch "^3.0.4"
-    npmlog "^4.1.2"
-    slash "^2.0.0"
-
-"@lerna/command@3.18.5":
-  version "3.18.5"
-  resolved "https://registry.npmjs.org/@lerna/command/-/command-3.18.5.tgz#14c6d2454adbfd365f8027201523e6c289cd3cd9"
-  integrity sha512-36EnqR59yaTU4HrR1C9XDFti2jRx0BgpIUBeWn129LZZB8kAB3ov1/dJNa1KcNRKp91DncoKHLY99FZ6zTNpMQ==
-  dependencies:
-    "@lerna/child-process" "3.16.5"
-    "@lerna/package-graph" "3.18.5"
-    "@lerna/project" "3.18.0"
-    "@lerna/validation-error" "3.13.0"
-    "@lerna/write-log-file" "3.13.0"
-    clone-deep "^4.0.1"
-    dedent "^0.7.0"
-    execa "^1.0.0"
-    is-ci "^2.0.0"
-    npmlog "^4.1.2"
-
-"@lerna/conventional-commits@3.18.5":
-  version "3.18.5"
-  resolved "https://registry.npmjs.org/@lerna/conventional-commits/-/conventional-commits-3.18.5.tgz#08efd2e5b45acfaf3f151a53a3ec7ecade58a7bc"
-  integrity sha512-qcvXIEJ3qSgalxXnQ7Yxp5H9Ta5TVyai6vEor6AAEHc20WiO7UIdbLDCxBtiiHMdGdpH85dTYlsoYUwsCJu3HQ==
-  dependencies:
-    "@lerna/validation-error" "3.13.0"
-    conventional-changelog-angular "^5.0.3"
-    conventional-changelog-core "^3.1.6"
-    conventional-recommended-bump "^5.0.0"
-    fs-extra "^8.1.0"
-    get-stream "^4.0.0"
-    lodash.template "^4.5.0"
-    npm-package-arg "^6.1.0"
-    npmlog "^4.1.2"
-    pify "^4.0.1"
-    semver "^6.2.0"
-
-"@lerna/create-symlink@3.16.2":
-  version "3.16.2"
-  resolved "https://registry.npmjs.org/@lerna/create-symlink/-/create-symlink-3.16.2.tgz#412cb8e59a72f5a7d9463e4e4721ad2070149967"
-  integrity sha512-pzXIJp6av15P325sgiIRpsPXLFmkisLhMBCy4764d+7yjf2bzrJ4gkWVMhsv4AdF0NN3OyZ5jjzzTtLNqfR+Jw==
-  dependencies:
-    "@zkochan/cmd-shim" "^3.1.0"
-    fs-extra "^8.1.0"
-    npmlog "^4.1.2"
-
-"@lerna/create@3.18.5":
-  version "3.18.5"
-  resolved "https://registry.npmjs.org/@lerna/create/-/create-3.18.5.tgz#11ac539f069248eaf7bc4c42e237784330f4fc47"
-  integrity sha512-cHpjocbpKmLopCuZFI7cKEM3E/QY8y+yC7VtZ4FQRSaLU8D8i2xXtXmYaP1GOlVNavji0iwoXjuNpnRMInIr2g==
-  dependencies:
-    "@evocateur/pacote" "^9.6.3"
-    "@lerna/child-process" "3.16.5"
-    "@lerna/command" "3.18.5"
-    "@lerna/npm-conf" "3.16.0"
-    "@lerna/validation-error" "3.13.0"
-    camelcase "^5.0.0"
-    dedent "^0.7.0"
-    fs-extra "^8.1.0"
-    globby "^9.2.0"
-    init-package-json "^1.10.3"
-    npm-package-arg "^6.1.0"
-    p-reduce "^1.0.0"
-    pify "^4.0.1"
-    semver "^6.2.0"
-    slash "^2.0.0"
-    validate-npm-package-license "^3.0.3"
-    validate-npm-package-name "^3.0.0"
-    whatwg-url "^7.0.0"
-
-"@lerna/describe-ref@3.16.5":
-  version "3.16.5"
-  resolved "https://registry.npmjs.org/@lerna/describe-ref/-/describe-ref-3.16.5.tgz#a338c25aaed837d3dc70b8a72c447c5c66346ac0"
-  integrity sha512-c01+4gUF0saOOtDBzbLMFOTJDHTKbDFNErEY6q6i9QaXuzy9LNN62z+Hw4acAAZuJQhrVWncVathcmkkjvSVGw==
-  dependencies:
-    "@lerna/child-process" "3.16.5"
-    npmlog "^4.1.2"
-
-"@lerna/diff@3.18.5":
-  version "3.18.5"
-  resolved "https://registry.npmjs.org/@lerna/diff/-/diff-3.18.5.tgz#e9e2cb882f84d5b84f0487c612137305f07accbc"
-  integrity sha512-u90lGs+B8DRA9Z/2xX4YaS3h9X6GbypmGV6ITzx9+1Ga12UWGTVlKaCXBgONMBjzJDzAQOK8qPTwLA57SeBLgA==
-  dependencies:
-    "@lerna/child-process" "3.16.5"
-    "@lerna/command" "3.18.5"
-    "@lerna/validation-error" "3.13.0"
-    npmlog "^4.1.2"
-
-"@lerna/exec@3.20.0":
-  version "3.20.0"
-  resolved "https://registry.npmjs.org/@lerna/exec/-/exec-3.20.0.tgz#29f0c01aee2340eb46f90706731fef2062a49639"
-  integrity sha512-pS1mmC7kzV668rHLWuv31ClngqeXjeHC8kJuM+W2D6IpUVMGQHLcCTYLudFgQsuKGVpl0DGNYG+sjLhAPiiu6A==
-  dependencies:
-    "@lerna/child-process" "3.16.5"
-    "@lerna/command" "3.18.5"
-    "@lerna/filter-options" "3.20.0"
-    "@lerna/profiler" "3.20.0"
-    "@lerna/run-topologically" "3.18.5"
-    "@lerna/validation-error" "3.13.0"
-    p-map "^2.1.0"
-
-"@lerna/filter-options@3.20.0":
-  version "3.20.0"
-  resolved "https://registry.npmjs.org/@lerna/filter-options/-/filter-options-3.20.0.tgz#0f0f5d5a4783856eece4204708cc902cbc8af59b"
-  integrity sha512-bmcHtvxn7SIl/R9gpiNMVG7yjx7WyT0HSGw34YVZ9B+3xF/83N3r5Rgtjh4hheLZ+Q91Or0Jyu5O3Nr+AwZe2g==
-  dependencies:
-    "@lerna/collect-updates" "3.20.0"
-    "@lerna/filter-packages" "3.18.0"
-    dedent "^0.7.0"
-    figgy-pudding "^3.5.1"
-    npmlog "^4.1.2"
-
-"@lerna/filter-packages@3.18.0":
-  version "3.18.0"
-  resolved "https://registry.npmjs.org/@lerna/filter-packages/-/filter-packages-3.18.0.tgz#6a7a376d285208db03a82958cfb8172e179b4e70"
-  integrity sha512-6/0pMM04bCHNATIOkouuYmPg6KH3VkPCIgTfQmdkPJTullERyEQfNUKikrefjxo1vHOoCACDpy65JYyKiAbdwQ==
-  dependencies:
-    "@lerna/validation-error" "3.13.0"
-    multimatch "^3.0.0"
-    npmlog "^4.1.2"
-
-"@lerna/get-npm-exec-opts@3.13.0":
-  version "3.13.0"
-  resolved "https://registry.npmjs.org/@lerna/get-npm-exec-opts/-/get-npm-exec-opts-3.13.0.tgz#d1b552cb0088199fc3e7e126f914e39a08df9ea5"
-  integrity sha512-Y0xWL0rg3boVyJk6An/vurKzubyJKtrxYv2sj4bB8Mc5zZ3tqtv0ccbOkmkXKqbzvNNF7VeUt1OJ3DRgtC/QZw==
-  dependencies:
-    npmlog "^4.1.2"
-
-"@lerna/get-packed@3.16.0":
-  version "3.16.0"
-  resolved "https://registry.npmjs.org/@lerna/get-packed/-/get-packed-3.16.0.tgz#1b316b706dcee86c7baa55e50b087959447852ff"
-  integrity sha512-AjsFiaJzo1GCPnJUJZiTW6J1EihrPkc2y3nMu6m3uWFxoleklsSCyImumzVZJssxMi3CPpztj8LmADLedl9kXw==
-  dependencies:
-    fs-extra "^8.1.0"
-    ssri "^6.0.1"
-    tar "^4.4.8"
-
-"@lerna/github-client@3.16.5":
-  version "3.16.5"
-  resolved "https://registry.npmjs.org/@lerna/github-client/-/github-client-3.16.5.tgz#2eb0235c3bf7a7e5d92d73e09b3761ab21f35c2e"
-  integrity sha512-rHQdn8Dv/CJrO3VouOP66zAcJzrHsm+wFuZ4uGAai2At2NkgKH+tpNhQy2H1PSC0Ezj9LxvdaHYrUzULqVK5Hw==
-  dependencies:
-    "@lerna/child-process" "3.16.5"
-    "@octokit/plugin-enterprise-rest" "^3.6.1"
-    "@octokit/rest" "^16.28.4"
-    git-url-parse "^11.1.2"
-    npmlog "^4.1.2"
-
-"@lerna/gitlab-client@3.15.0":
-  version "3.15.0"
-  resolved "https://registry.npmjs.org/@lerna/gitlab-client/-/gitlab-client-3.15.0.tgz#91f4ec8c697b5ac57f7f25bd50fe659d24aa96a6"
-  integrity sha512-OsBvRSejHXUBMgwWQqNoioB8sgzL/Pf1pOUhHKtkiMl6aAWjklaaq5HPMvTIsZPfS6DJ9L5OK2GGZuooP/5c8Q==
-  dependencies:
-    node-fetch "^2.5.0"
-    npmlog "^4.1.2"
-    whatwg-url "^7.0.0"
-
-"@lerna/global-options@3.13.0":
-  version "3.13.0"
-  resolved "https://registry.npmjs.org/@lerna/global-options/-/global-options-3.13.0.tgz#217662290db06ad9cf2c49d8e3100ee28eaebae1"
-  integrity sha512-SlZvh1gVRRzYLVluz9fryY1nJpZ0FHDGB66U9tFfvnnxmueckRQxLopn3tXj3NU1kc3QANT2I5BsQkOqZ4TEFQ==
-
-"@lerna/has-npm-version@3.16.5":
-  version "3.16.5"
-  resolved "https://registry.npmjs.org/@lerna/has-npm-version/-/has-npm-version-3.16.5.tgz#ab83956f211d8923ea6afe9b979b38cc73b15326"
-  integrity sha512-WL7LycR9bkftyqbYop5rEGJ9sRFIV55tSGmbN1HLrF9idwOCD7CLrT64t235t3t4O5gehDnwKI5h2U3oxTrF8Q==
-  dependencies:
-    "@lerna/child-process" "3.16.5"
-    semver "^6.2.0"
-
-"@lerna/import@3.18.5":
-  version "3.18.5"
-  resolved "https://registry.npmjs.org/@lerna/import/-/import-3.18.5.tgz#a9c7d8601870729851293c10abd18b3707f7ba5e"
-  integrity sha512-PH0WVLEgp+ORyNKbGGwUcrueW89K3Iuk/DDCz8mFyG2IG09l/jOF0vzckEyGyz6PO5CMcz4TI1al/qnp3FrahQ==
-  dependencies:
-    "@lerna/child-process" "3.16.5"
-    "@lerna/command" "3.18.5"
-    "@lerna/prompt" "3.18.5"
-    "@lerna/pulse-till-done" "3.13.0"
-    "@lerna/validation-error" "3.13.0"
-    dedent "^0.7.0"
-    fs-extra "^8.1.0"
-    p-map-series "^1.0.0"
-
-"@lerna/info@3.20.0":
-  version "3.20.0"
-  resolved "https://registry.npmjs.org/@lerna/info/-/info-3.20.0.tgz#3a5212f3029f2bc6255f9533bdf4bcb120ef329a"
-  integrity sha512-Rsz+KQF9mczbGUbPTrtOed1N0C+cA08Qz0eX/oI+NNjvsryZIju/o7uedG4I3P55MBiAioNrJI88fHH3eTgYug==
-  dependencies:
-    "@lerna/command" "3.18.5"
-    "@lerna/output" "3.13.0"
-    envinfo "^7.3.1"
-
-"@lerna/init@3.18.5":
-  version "3.18.5"
-  resolved "https://registry.npmjs.org/@lerna/init/-/init-3.18.5.tgz#86dd0b2b3290755a96975069b5cb007f775df9f5"
-  integrity sha512-oCwipWrha98EcJAHm8AGd2YFFLNI7AW9AWi0/LbClj1+XY9ah+uifXIgYGfTk63LbgophDd8936ZEpHMxBsbAg==
-  dependencies:
-    "@lerna/child-process" "3.16.5"
-    "@lerna/command" "3.18.5"
-    fs-extra "^8.1.0"
-    p-map "^2.1.0"
-    write-json-file "^3.2.0"
-
-"@lerna/link@3.18.5":
-  version "3.18.5"
-  resolved "https://registry.npmjs.org/@lerna/link/-/link-3.18.5.tgz#f24347e4f0b71d54575bd37cfa1794bc8ee91b18"
-  integrity sha512-xTN3vktJpkT7Nqc3QkZRtHO4bT5NvuLMtKNIBDkks0HpGxC9PRyyqwOoCoh1yOGbrWIuDezhfMg3Qow+6I69IQ==
-  dependencies:
-    "@lerna/command" "3.18.5"
-    "@lerna/package-graph" "3.18.5"
-    "@lerna/symlink-dependencies" "3.17.0"
-    p-map "^2.1.0"
-    slash "^2.0.0"
-
-"@lerna/list@3.20.0":
-  version "3.20.0"
-  resolved "https://registry.npmjs.org/@lerna/list/-/list-3.20.0.tgz#7e67cc29c5cf661cfd097e8a7c2d3dcce7a81029"
-  integrity sha512-fXTicPrfioVnRzknyPawmYIVkzDRBaQqk9spejS1S3O1DOidkihK0xxNkr8HCVC0L22w6f92g83qWDp2BYRUbg==
-  dependencies:
-    "@lerna/command" "3.18.5"
-    "@lerna/filter-options" "3.20.0"
-    "@lerna/listable" "3.18.5"
-    "@lerna/output" "3.13.0"
-
-"@lerna/listable@3.18.5":
-  version "3.18.5"
-  resolved "https://registry.npmjs.org/@lerna/listable/-/listable-3.18.5.tgz#e82798405b5ed8fc51843c8ef1e7a0e497388a1a"
-  integrity sha512-Sdr3pVyaEv5A7ZkGGYR7zN+tTl2iDcinryBPvtuv20VJrXBE8wYcOks1edBTcOWsPjCE/rMP4bo1pseyk3UTsg==
-  dependencies:
-    "@lerna/query-graph" "3.18.5"
-    chalk "^2.3.1"
-    columnify "^1.5.4"
-
-"@lerna/log-packed@3.16.0":
-  version "3.16.0"
-  resolved "https://registry.npmjs.org/@lerna/log-packed/-/log-packed-3.16.0.tgz#f83991041ee77b2495634e14470b42259fd2bc16"
-  integrity sha512-Fp+McSNBV/P2mnLUYTaSlG8GSmpXM7krKWcllqElGxvAqv6chk2K3c2k80MeVB4WvJ9tRjUUf+i7HUTiQ9/ckQ==
-  dependencies:
-    byte-size "^5.0.1"
-    columnify "^1.5.4"
-    has-unicode "^2.0.1"
-    npmlog "^4.1.2"
-
-"@lerna/npm-conf@3.16.0":
-  version "3.16.0"
-  resolved "https://registry.npmjs.org/@lerna/npm-conf/-/npm-conf-3.16.0.tgz#1c10a89ae2f6c2ee96962557738685300d376827"
-  integrity sha512-HbO3DUrTkCAn2iQ9+FF/eisDpWY5POQAOF1m7q//CZjdC2HSW3UYbKEGsSisFxSfaF9Z4jtrV+F/wX6qWs3CuA==
-  dependencies:
-    config-chain "^1.1.11"
-    pify "^4.0.1"
-
-"@lerna/npm-dist-tag@3.18.5":
-  version "3.18.5"
-  resolved "https://registry.npmjs.org/@lerna/npm-dist-tag/-/npm-dist-tag-3.18.5.tgz#9ef9abb7c104077b31f6fab22cc73b314d54ac55"
-  integrity sha512-xw0HDoIG6HreVsJND9/dGls1c+lf6vhu7yJoo56Sz5bvncTloYGLUppIfDHQr4ZvmPCK8rsh0euCVh2giPxzKQ==
-  dependencies:
-    "@evocateur/npm-registry-fetch" "^4.0.0"
-    "@lerna/otplease" "3.18.5"
-    figgy-pudding "^3.5.1"
-    npm-package-arg "^6.1.0"
-    npmlog "^4.1.2"
-
-"@lerna/npm-install@3.16.5":
-  version "3.16.5"
-  resolved "https://registry.npmjs.org/@lerna/npm-install/-/npm-install-3.16.5.tgz#d6bfdc16f81285da66515ae47924d6e278d637d3"
-  integrity sha512-hfiKk8Eku6rB9uApqsalHHTHY+mOrrHeWEs+gtg7+meQZMTS3kzv4oVp5cBZigndQr3knTLjwthT/FX4KvseFg==
-  dependencies:
-    "@lerna/child-process" "3.16.5"
-    "@lerna/get-npm-exec-opts" "3.13.0"
-    fs-extra "^8.1.0"
-    npm-package-arg "^6.1.0"
-    npmlog "^4.1.2"
-    signal-exit "^3.0.2"
-    write-pkg "^3.1.0"
-
-"@lerna/npm-publish@3.18.5":
-  version "3.18.5"
-  resolved "https://registry.npmjs.org/@lerna/npm-publish/-/npm-publish-3.18.5.tgz#240e4039959fd9816b49c5b07421e11b5cb000af"
-  integrity sha512-3etLT9+2L8JAx5F8uf7qp6iAtOLSMj+ZYWY6oUgozPi/uLqU0/gsMsEXh3F0+YVW33q0M61RpduBoAlOOZnaTg==
-  dependencies:
-    "@evocateur/libnpmpublish" "^1.2.2"
-    "@lerna/otplease" "3.18.5"
-    "@lerna/run-lifecycle" "3.16.2"
-    figgy-pudding "^3.5.1"
-    fs-extra "^8.1.0"
-    npm-package-arg "^6.1.0"
-    npmlog "^4.1.2"
-    pify "^4.0.1"
-    read-package-json "^2.0.13"
-
-"@lerna/npm-run-script@3.16.5":
-  version "3.16.5"
-  resolved "https://registry.npmjs.org/@lerna/npm-run-script/-/npm-run-script-3.16.5.tgz#9c2ec82453a26c0b46edc0bb7c15816c821f5c15"
-  integrity sha512-1asRi+LjmVn3pMjEdpqKJZFT/3ZNpb+VVeJMwrJaV/3DivdNg7XlPK9LTrORuKU4PSvhdEZvJmSlxCKyDpiXsQ==
-  dependencies:
-    "@lerna/child-process" "3.16.5"
-    "@lerna/get-npm-exec-opts" "3.13.0"
-    npmlog "^4.1.2"
-
-"@lerna/otplease@3.18.5":
-  version "3.18.5"
-  resolved "https://registry.npmjs.org/@lerna/otplease/-/otplease-3.18.5.tgz#b77b8e760b40abad9f7658d988f3ea77d4fd0231"
-  integrity sha512-S+SldXAbcXTEDhzdxYLU0ZBKuYyURP/ND2/dK6IpKgLxQYh/z4ScljPDMyKymmEvgiEJmBsPZAAPfmNPEzxjog==
-  dependencies:
-    "@lerna/prompt" "3.18.5"
-    figgy-pudding "^3.5.1"
-
-"@lerna/output@3.13.0":
-  version "3.13.0"
-  resolved "https://registry.npmjs.org/@lerna/output/-/output-3.13.0.tgz#3ded7cc908b27a9872228a630d950aedae7a4989"
-  integrity sha512-7ZnQ9nvUDu/WD+bNsypmPG5MwZBwu86iRoiW6C1WBuXXDxM5cnIAC1m2WxHeFnjyMrYlRXM9PzOQ9VDD+C15Rg==
-  dependencies:
-    npmlog "^4.1.2"
-
-"@lerna/pack-directory@3.16.4":
-  version "3.16.4"
-  resolved "https://registry.npmjs.org/@lerna/pack-directory/-/pack-directory-3.16.4.tgz#3eae5f91bdf5acfe0384510ed53faddc4c074693"
-  integrity sha512-uxSF0HZeGyKaaVHz5FroDY9A5NDDiCibrbYR6+khmrhZtY0Bgn6hWq8Gswl9iIlymA+VzCbshWIMX4o2O8C8ng==
-  dependencies:
-    "@lerna/get-packed" "3.16.0"
-    "@lerna/package" "3.16.0"
-    "@lerna/run-lifecycle" "3.16.2"
-    figgy-pudding "^3.5.1"
-    npm-packlist "^1.4.4"
-    npmlog "^4.1.2"
-    tar "^4.4.10"
-    temp-write "^3.4.0"
-
-"@lerna/package-graph@3.18.5":
-  version "3.18.5"
-  resolved "https://registry.npmjs.org/@lerna/package-graph/-/package-graph-3.18.5.tgz#c740e2ea3578d059e551633e950690831b941f6b"
-  integrity sha512-8QDrR9T+dBegjeLr+n9WZTVxUYUhIUjUgZ0gvNxUBN8S1WB9r6H5Yk56/MVaB64tA3oGAN9IIxX6w0WvTfFudA==
-  dependencies:
-    "@lerna/prerelease-id-from-version" "3.16.0"
-    "@lerna/validation-error" "3.13.0"
-    npm-package-arg "^6.1.0"
-    npmlog "^4.1.2"
-    semver "^6.2.0"
-
-"@lerna/package@3.16.0":
-  version "3.16.0"
-  resolved "https://registry.npmjs.org/@lerna/package/-/package-3.16.0.tgz#7e0a46e4697ed8b8a9c14d59c7f890e0d38ba13c"
-  integrity sha512-2lHBWpaxcBoiNVbtyLtPUuTYEaB/Z+eEqRS9duxpZs6D+mTTZMNy6/5vpEVSCBmzvdYpyqhqaYjjSLvjjr5Riw==
-  dependencies:
-    load-json-file "^5.3.0"
-    npm-package-arg "^6.1.0"
-    write-pkg "^3.1.0"
-
-"@lerna/prerelease-id-from-version@3.16.0":
-  version "3.16.0"
-  resolved "https://registry.npmjs.org/@lerna/prerelease-id-from-version/-/prerelease-id-from-version-3.16.0.tgz#b24bfa789f5e1baab914d7b08baae9b7bd7d83a1"
-  integrity sha512-qZyeUyrE59uOK8rKdGn7jQz+9uOpAaF/3hbslJVFL1NqF9ELDTqjCPXivuejMX/lN4OgD6BugTO4cR7UTq/sZA==
-  dependencies:
-    semver "^6.2.0"
-
-"@lerna/profiler@3.20.0":
-  version "3.20.0"
-  resolved "https://registry.npmjs.org/@lerna/profiler/-/profiler-3.20.0.tgz#0f6dc236f4ea8f9ea5f358c6703305a4f32ad051"
-  integrity sha512-bh8hKxAlm6yu8WEOvbLENm42i2v9SsR4WbrCWSbsmOElx3foRnMlYk7NkGECa+U5c3K4C6GeBbwgqs54PP7Ljg==
-  dependencies:
-    figgy-pudding "^3.5.1"
-    fs-extra "^8.1.0"
-    npmlog "^4.1.2"
-    upath "^1.2.0"
-
-"@lerna/project@3.18.0":
-  version "3.18.0"
-  resolved "https://registry.npmjs.org/@lerna/project/-/project-3.18.0.tgz#56feee01daeb42c03cbdf0ed8a2a10cbce32f670"
-  integrity sha512-+LDwvdAp0BurOAWmeHE3uuticsq9hNxBI0+FMHiIai8jrygpJGahaQrBYWpwbshbQyVLeQgx3+YJdW2TbEdFWA==
-  dependencies:
-    "@lerna/package" "3.16.0"
-    "@lerna/validation-error" "3.13.0"
-    cosmiconfig "^5.1.0"
-    dedent "^0.7.0"
-    dot-prop "^4.2.0"
-    glob-parent "^5.0.0"
-    globby "^9.2.0"
-    load-json-file "^5.3.0"
-    npmlog "^4.1.2"
-    p-map "^2.1.0"
-    resolve-from "^4.0.0"
-    write-json-file "^3.2.0"
-
-"@lerna/prompt@3.18.5":
-  version "3.18.5"
-  resolved "https://registry.npmjs.org/@lerna/prompt/-/prompt-3.18.5.tgz#628cd545f225887d060491ab95df899cfc5218a1"
-  integrity sha512-rkKj4nm1twSbBEb69+Em/2jAERK8htUuV8/xSjN0NPC+6UjzAwY52/x9n5cfmpa9lyKf/uItp7chCI7eDmNTKQ==
-  dependencies:
-    inquirer "^6.2.0"
-    npmlog "^4.1.2"
-
-"@lerna/publish@3.20.2":
-  version "3.20.2"
-  resolved "https://registry.npmjs.org/@lerna/publish/-/publish-3.20.2.tgz#a45d29813099b3249657ea913d0dc3f8ebc5cc2e"
-  integrity sha512-N7Y6PdhJ+tYQPdI1tZum8W25cDlTp4D6brvRacKZusweWexxaopbV8RprBaKexkEX/KIbncuADq7qjDBdQHzaA==
-  dependencies:
-    "@evocateur/libnpmaccess" "^3.1.2"
-    "@evocateur/npm-registry-fetch" "^4.0.0"
-    "@evocateur/pacote" "^9.6.3"
-    "@lerna/check-working-tree" "3.16.5"
-    "@lerna/child-process" "3.16.5"
-    "@lerna/collect-updates" "3.20.0"
-    "@lerna/command" "3.18.5"
-    "@lerna/describe-ref" "3.16.5"
-    "@lerna/log-packed" "3.16.0"
-    "@lerna/npm-conf" "3.16.0"
-    "@lerna/npm-dist-tag" "3.18.5"
-    "@lerna/npm-publish" "3.18.5"
-    "@lerna/otplease" "3.18.5"
-    "@lerna/output" "3.13.0"
-    "@lerna/pack-directory" "3.16.4"
-    "@lerna/prerelease-id-from-version" "3.16.0"
-    "@lerna/prompt" "3.18.5"
-    "@lerna/pulse-till-done" "3.13.0"
-    "@lerna/run-lifecycle" "3.16.2"
-    "@lerna/run-topologically" "3.18.5"
-    "@lerna/validation-error" "3.13.0"
-    "@lerna/version" "3.20.2"
-    figgy-pudding "^3.5.1"
-    fs-extra "^8.1.0"
-    npm-package-arg "^6.1.0"
-    npmlog "^4.1.2"
-    p-finally "^1.0.0"
-    p-map "^2.1.0"
-    p-pipe "^1.2.0"
-    semver "^6.2.0"
-
-"@lerna/pulse-till-done@3.13.0":
-  version "3.13.0"
-  resolved "https://registry.npmjs.org/@lerna/pulse-till-done/-/pulse-till-done-3.13.0.tgz#c8e9ce5bafaf10d930a67d7ed0ccb5d958fe0110"
-  integrity sha512-1SOHpy7ZNTPulzIbargrgaJX387csN7cF1cLOGZiJQA6VqnS5eWs2CIrG8i8wmaUavj2QlQ5oEbRMVVXSsGrzA==
-  dependencies:
-    npmlog "^4.1.2"
-
-"@lerna/query-graph@3.18.5":
-  version "3.18.5"
-  resolved "https://registry.npmjs.org/@lerna/query-graph/-/query-graph-3.18.5.tgz#df4830bb5155273003bf35e8dda1c32d0927bd86"
-  integrity sha512-50Lf4uuMpMWvJ306be3oQDHrWV42nai9gbIVByPBYJuVW8dT8O8pA3EzitNYBUdLL9/qEVbrR0ry1HD7EXwtRA==
-  dependencies:
-    "@lerna/package-graph" "3.18.5"
-    figgy-pudding "^3.5.1"
-
-"@lerna/resolve-symlink@3.16.0":
-  version "3.16.0"
-  resolved "https://registry.npmjs.org/@lerna/resolve-symlink/-/resolve-symlink-3.16.0.tgz#37fc7095fabdbcf317c26eb74e0d0bde8efd2386"
-  integrity sha512-Ibj5e7njVHNJ/NOqT4HlEgPFPtPLWsO7iu59AM5bJDcAJcR96mLZ7KGVIsS2tvaO7akMEJvt2P+ErwCdloG3jQ==
-  dependencies:
-    fs-extra "^8.1.0"
-    npmlog "^4.1.2"
-    read-cmd-shim "^1.0.1"
-
-"@lerna/rimraf-dir@3.16.5":
-  version "3.16.5"
-  resolved "https://registry.npmjs.org/@lerna/rimraf-dir/-/rimraf-dir-3.16.5.tgz#04316ab5ffd2909657aaf388ea502cb8c2f20a09"
-  integrity sha512-bQlKmO0pXUsXoF8lOLknhyQjOZsCc0bosQDoX4lujBXSWxHVTg1VxURtWf2lUjz/ACsJVDfvHZbDm8kyBk5okA==
-  dependencies:
-    "@lerna/child-process" "3.16.5"
-    npmlog "^4.1.2"
-    path-exists "^3.0.0"
-    rimraf "^2.6.2"
-
-"@lerna/run-lifecycle@3.16.2":
-  version "3.16.2"
-  resolved "https://registry.npmjs.org/@lerna/run-lifecycle/-/run-lifecycle-3.16.2.tgz#67b288f8ea964db9ea4fb1fbc7715d5bbb0bce00"
-  integrity sha512-RqFoznE8rDpyyF0rOJy3+KjZCeTkO8y/OB9orPauR7G2xQ7PTdCpgo7EO6ZNdz3Al+k1BydClZz/j78gNCmL2A==
-  dependencies:
-    "@lerna/npm-conf" "3.16.0"
-    figgy-pudding "^3.5.1"
-    npm-lifecycle "^3.1.2"
-    npmlog "^4.1.2"
-
-"@lerna/run-topologically@3.18.5":
-  version "3.18.5"
-  resolved "https://registry.npmjs.org/@lerna/run-topologically/-/run-topologically-3.18.5.tgz#3cd639da20e967d7672cb88db0f756b92f2fdfc3"
-  integrity sha512-6N1I+6wf4hLOnPW+XDZqwufyIQ6gqoPfHZFkfWlvTQ+Ue7CuF8qIVQ1Eddw5HKQMkxqN10thKOFfq/9NQZ4NUg==
-  dependencies:
-    "@lerna/query-graph" "3.18.5"
-    figgy-pudding "^3.5.1"
-    p-queue "^4.0.0"
-
-"@lerna/run@3.20.0":
-  version "3.20.0"
-  resolved "https://registry.npmjs.org/@lerna/run/-/run-3.20.0.tgz#a479f7c42bdf9ebabb3a1e5a2bdebb7a8d201151"
-  integrity sha512-9U3AqeaCeB7KsGS9oyKNp62s9vYoULg/B4cqXTKZkc+OKL6QOEjYHYVSBcMK9lUXrMjCjDIuDSX3PnTCPxQ2Dw==
-  dependencies:
-    "@lerna/command" "3.18.5"
-    "@lerna/filter-options" "3.20.0"
-    "@lerna/npm-run-script" "3.16.5"
-    "@lerna/output" "3.13.0"
-    "@lerna/profiler" "3.20.0"
-    "@lerna/run-topologically" "3.18.5"
-    "@lerna/timer" "3.13.0"
-    "@lerna/validation-error" "3.13.0"
-    p-map "^2.1.0"
-
-"@lerna/symlink-binary@3.17.0":
-  version "3.17.0"
-  resolved "https://registry.npmjs.org/@lerna/symlink-binary/-/symlink-binary-3.17.0.tgz#8f8031b309863814883d3f009877f82e38aef45a"
-  integrity sha512-RLpy9UY6+3nT5J+5jkM5MZyMmjNHxZIZvXLV+Q3MXrf7Eaa1hNqyynyj4RO95fxbS+EZc4XVSk25DGFQbcRNSQ==
-  dependencies:
-    "@lerna/create-symlink" "3.16.2"
-    "@lerna/package" "3.16.0"
-    fs-extra "^8.1.0"
-    p-map "^2.1.0"
-
-"@lerna/symlink-dependencies@3.17.0":
-  version "3.17.0"
-  resolved "https://registry.npmjs.org/@lerna/symlink-dependencies/-/symlink-dependencies-3.17.0.tgz#48d6360e985865a0e56cd8b51b308a526308784a"
-  integrity sha512-KmjU5YT1bpt6coOmdFueTJ7DFJL4H1w5eF8yAQ2zsGNTtZ+i5SGFBWpb9AQaw168dydc3s4eu0W0Sirda+F59Q==
-  dependencies:
-    "@lerna/create-symlink" "3.16.2"
-    "@lerna/resolve-symlink" "3.16.0"
-    "@lerna/symlink-binary" "3.17.0"
-    fs-extra "^8.1.0"
-    p-finally "^1.0.0"
-    p-map "^2.1.0"
-    p-map-series "^1.0.0"
-
-"@lerna/timer@3.13.0":
-  version "3.13.0"
-  resolved "https://registry.npmjs.org/@lerna/timer/-/timer-3.13.0.tgz#bcd0904551db16e08364d6c18e5e2160fc870781"
-  integrity sha512-RHWrDl8U4XNPqY5MQHkToWS9jHPnkLZEt5VD+uunCKTfzlxGnRCr3/zVr8VGy/uENMYpVP3wJa4RKGY6M0vkRw==
-
-"@lerna/validation-error@3.13.0":
-  version "3.13.0"
-  resolved "https://registry.npmjs.org/@lerna/validation-error/-/validation-error-3.13.0.tgz#c86b8f07c5ab9539f775bd8a54976e926f3759c3"
-  integrity sha512-SiJP75nwB8GhgwLKQfdkSnDufAaCbkZWJqEDlKOUPUvVOplRGnfL+BPQZH5nvq2BYSRXsksXWZ4UHVnQZI/HYA==
-  dependencies:
-    npmlog "^4.1.2"
-
-"@lerna/version@3.20.2":
-  version "3.20.2"
-  resolved "https://registry.npmjs.org/@lerna/version/-/version-3.20.2.tgz#3709141c0f537741d9bc10cb24f56897bcb30428"
-  integrity sha512-ckBJMaBWc+xJen0cMyCE7W67QXLLrc0ELvigPIn8p609qkfNM0L0CF803MKxjVOldJAjw84b8ucNWZLvJagP/Q==
-  dependencies:
-    "@lerna/check-working-tree" "3.16.5"
-    "@lerna/child-process" "3.16.5"
-    "@lerna/collect-updates" "3.20.0"
-    "@lerna/command" "3.18.5"
-    "@lerna/conventional-commits" "3.18.5"
-    "@lerna/github-client" "3.16.5"
-    "@lerna/gitlab-client" "3.15.0"
-    "@lerna/output" "3.13.0"
-    "@lerna/prerelease-id-from-version" "3.16.0"
-    "@lerna/prompt" "3.18.5"
-    "@lerna/run-lifecycle" "3.16.2"
-    "@lerna/run-topologically" "3.18.5"
-    "@lerna/validation-error" "3.13.0"
-    chalk "^2.3.1"
-    dedent "^0.7.0"
-    load-json-file "^5.3.0"
-    minimatch "^3.0.4"
-    npmlog "^4.1.2"
-    p-map "^2.1.0"
-    p-pipe "^1.2.0"
-    p-reduce "^1.0.0"
-    p-waterfall "^1.0.0"
-    semver "^6.2.0"
-    slash "^2.0.0"
-    temp-write "^3.4.0"
-    write-json-file "^3.2.0"
-
-"@lerna/write-log-file@3.13.0":
-  version "3.13.0"
-  resolved "https://registry.npmjs.org/@lerna/write-log-file/-/write-log-file-3.13.0.tgz#b78d9e4cfc1349a8be64d91324c4c8199e822a26"
-  integrity sha512-RibeMnDPvlL8bFYW5C8cs4mbI3AHfQef73tnJCQ/SgrXZHehmHnsyWUiE7qDQCAo+B1RfTapvSyFF69iPj326A==
-  dependencies:
-    npmlog "^4.1.2"
-    write-file-atomic "^2.3.0"
-
-"@mrmlnc/readdir-enhanced@^2.2.1":
-  version "2.2.1"
-  resolved "https://registry.npmjs.org/@mrmlnc/readdir-enhanced/-/readdir-enhanced-2.2.1.tgz#524af240d1a360527b730475ecfa1344aa540dde"
-  integrity sha512-bPHp6Ji8b41szTOcaP63VlnbbO5Ny6dwAATtY6JTjh5N2OLrb5Qk/Th5cRkRQhkWCt+EJsYrNB0MiL+Gpn6e3g==
-  dependencies:
-    call-me-maybe "^1.0.1"
-    glob-to-regexp "^0.3.0"
-
-"@nodelib/fs.stat@^1.1.2":
-  version "1.1.3"
-  resolved "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-1.1.3.tgz#2b5a3ab3f918cca48a8c754c08168e3f03eba61b"
-  integrity sha512-shAmDyaQC4H92APFoIaVDHCx5bStIocgvbwQyxPRrbUY20V1EYTbSDchWbuwlMG3V17cprZhA6+78JfB+3DTPw==
-
-"@octokit/auth-token@^2.4.0":
-  version "2.4.0"
-  resolved "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-2.4.0.tgz#b64178975218b99e4dfe948253f0673cbbb59d9f"
-  integrity sha512-eoOVMjILna7FVQf96iWc3+ZtE/ZT6y8ob8ZzcqKY1ibSQCnu4O/B7pJvzMx5cyZ/RjAff6DAdEb0O0Cjcxidkg==
-  dependencies:
-    "@octokit/types" "^2.0.0"
-
-"@octokit/endpoint@^5.5.0":
-  version "5.5.3"
-  resolved "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-5.5.3.tgz#0397d1baaca687a4c8454ba424a627699d97c978"
-  integrity sha512-EzKwkwcxeegYYah5ukEeAI/gYRLv2Y9U5PpIsseGSFDk+G3RbipQGBs8GuYS1TLCtQaqoO66+aQGtITPalxsNQ==
-  dependencies:
-    "@octokit/types" "^2.0.0"
-    is-plain-object "^3.0.0"
-    universal-user-agent "^5.0.0"
-
-"@octokit/plugin-enterprise-rest@^3.6.1":
-  version "3.6.2"
-  resolved "https://registry.npmjs.org/@octokit/plugin-enterprise-rest/-/plugin-enterprise-rest-3.6.2.tgz#74de25bef21e0182b4fa03a8678cd00a4e67e561"
-  integrity sha512-3wF5eueS5OHQYuAEudkpN+xVeUsg8vYEMMenEzLphUZ7PRZ8OJtDcsreL3ad9zxXmBbaFWzLmFcdob5CLyZftA==
-
-"@octokit/plugin-paginate-rest@^1.1.1":
-  version "1.1.2"
-  resolved "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-1.1.2.tgz#004170acf8c2be535aba26727867d692f7b488fc"
-  integrity sha512-jbsSoi5Q1pj63sC16XIUboklNw+8tL9VOnJsWycWYR78TKss5PVpIPb1TUUcMQ+bBh7cY579cVAWmf5qG+dw+Q==
-  dependencies:
-    "@octokit/types" "^2.0.1"
-
-"@octokit/plugin-request-log@^1.0.0":
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/@octokit/plugin-request-log/-/plugin-request-log-1.0.0.tgz#eef87a431300f6148c39a7f75f8cfeb218b2547e"
-  integrity sha512-ywoxP68aOT3zHCLgWZgwUJatiENeHE7xJzYjfz8WI0goynp96wETBF+d95b8g/uL4QmS6owPVlaxiz3wyMAzcw==
-
-"@octokit/plugin-rest-endpoint-methods@2.4.0":
-  version "2.4.0"
-  resolved "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-2.4.0.tgz#3288ecf5481f68c494dd0602fc15407a59faf61e"
-  integrity sha512-EZi/AWhtkdfAYi01obpX0DF7U6b1VRr30QNQ5xSFPITMdLSfhcBqjamE3F+sKcxPbD7eZuMHu3Qkk2V+JGxBDQ==
-  dependencies:
-    "@octokit/types" "^2.0.1"
-    deprecation "^2.3.1"
-
-"@octokit/request-error@^1.0.1", "@octokit/request-error@^1.0.2":
-  version "1.2.1"
-  resolved "https://registry.npmjs.org/@octokit/request-error/-/request-error-1.2.1.tgz#ede0714c773f32347576c25649dc013ae6b31801"
-  integrity sha512-+6yDyk1EES6WK+l3viRDElw96MvwfJxCt45GvmjDUKWjYIb3PJZQkq3i46TwGwoPD4h8NmTrENmtyA1FwbmhRA==
-  dependencies:
-    "@octokit/types" "^2.0.0"
-    deprecation "^2.0.0"
-    once "^1.4.0"
-
-"@octokit/request@^5.2.0":
-  version "5.3.2"
-  resolved "https://registry.npmjs.org/@octokit/request/-/request-5.3.2.tgz#1ca8b90a407772a1ee1ab758e7e0aced213b9883"
-  integrity sha512-7NPJpg19wVQy1cs2xqXjjRq/RmtSomja/VSWnptfYwuBxLdbYh2UjhGi0Wx7B1v5Iw5GKhfFDQL7jM7SSp7K2g==
-  dependencies:
-    "@octokit/endpoint" "^5.5.0"
-    "@octokit/request-error" "^1.0.1"
-    "@octokit/types" "^2.0.0"
-    deprecation "^2.0.0"
-    is-plain-object "^3.0.0"
-    node-fetch "^2.3.0"
-    once "^1.4.0"
-    universal-user-agent "^5.0.0"
-
-"@octokit/rest@^16.28.4":
-  version "16.43.1"
-  resolved "https://registry.npmjs.org/@octokit/rest/-/rest-16.43.1.tgz#3b11e7d1b1ac2bbeeb23b08a17df0b20947eda6b"
-  integrity sha512-gfFKwRT/wFxq5qlNjnW2dh+qh74XgTQ2B179UX5K1HYCluioWj8Ndbgqw2PVqa1NnVJkGHp2ovMpVn/DImlmkw==
-  dependencies:
-    "@octokit/auth-token" "^2.4.0"
-    "@octokit/plugin-paginate-rest" "^1.1.1"
-    "@octokit/plugin-request-log" "^1.0.0"
-    "@octokit/plugin-rest-endpoint-methods" "2.4.0"
-    "@octokit/request" "^5.2.0"
-    "@octokit/request-error" "^1.0.2"
-    atob-lite "^2.0.0"
-    before-after-hook "^2.0.0"
-    btoa-lite "^1.0.0"
-    deprecation "^2.0.0"
-    lodash.get "^4.4.2"
-    lodash.set "^4.3.2"
-    lodash.uniq "^4.5.0"
-    octokit-pagination-methods "^1.1.0"
-    once "^1.4.0"
-    universal-user-agent "^4.0.0"
-
-"@octokit/types@^2.0.0", "@octokit/types@^2.0.1":
-  version "2.5.0"
-  resolved "https://registry.npmjs.org/@octokit/types/-/types-2.5.0.tgz#f1bbd147e662ae2c79717d518aac686e58257773"
-  integrity sha512-KEnLwOfdXzxPNL34fj508bhi9Z9cStyN7qY1kOfVahmqtAfrWw6Oq3P4R+dtsg0lYtZdWBpUrS/Ixmd5YILSww==
-  dependencies:
-    "@types/node" ">= 8"
-
 "@types/babel__core@^7.1.0":
   version "7.1.6"
   resolved "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.1.6.tgz#16ff42a5ae203c9af1c6e190ed1f30f83207b610"
@@ -1185,20 +320,6 @@
   dependencies:
     "@babel/types" "^7.3.0"
 
-"@types/events@*":
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/@types/events/-/events-3.0.0.tgz#2862f3f58a9a7f7c3e78d79f130dd4d71c25c2a7"
-  integrity sha512-EaObqwIvayI5a8dCzhFrjKzVwKLxjoG9T6Ppd5CEo07LRKfQ8Yokw54r5+Wq7FaBQ+yXRvQAYPrHwya1/UFt9g==
-
-"@types/glob@^7.1.1":
-  version "7.1.1"
-  resolved "https://registry.npmjs.org/@types/glob/-/glob-7.1.1.tgz#aa59a1c6e3fbc421e07ccd31a944c30eba521575"
-  integrity sha512-1Bh06cbWJUHMC97acuD6UMG29nMt0Aqz1vF3guLfG+kHHJhy3AyohZFFxYk2f7Q1SQIrNwvncxAE0N/9s70F2w==
-  dependencies:
-    "@types/events" "*"
-    "@types/minimatch" "*"
-    "@types/node" "*"
-
 "@types/istanbul-lib-coverage@*", "@types/istanbul-lib-coverage@^2.0.0":
   version "2.0.1"
   resolved "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.1.tgz#42995b446db9a48a11a07ec083499a860e9138ff"
@@ -1219,16 +340,6 @@
     "@types/istanbul-lib-coverage" "*"
     "@types/istanbul-lib-report" "*"
 
-"@types/minimatch@*":
-  version "3.0.3"
-  resolved "https://registry.npmjs.org/@types/minimatch/-/minimatch-3.0.3.tgz#3dca0e3f33b200fc7d1139c0cd96c1268cadfd9d"
-  integrity sha512-tHq6qdbT9U1IRSGf14CL0pUlULksvY9OZ+5eEgl1N7t+OA3tGvNpxJCzuKQlsNgCVwbAs670L1vcVQi8j9HjnA==
-
-"@types/node@*", "@types/node@>= 8":
-  version "13.9.1"
-  resolved "https://registry.npmjs.org/@types/node/-/node-13.9.1.tgz#96f606f8cd67fb018847d9b61e93997dabdefc72"
-  integrity sha512-E6M6N0blf/jiZx8Q3nb0vNaswQeEyn0XlupO+xN6DtJ6r6IT4nXrTry7zhIfYvFCl3/8Cu6WIysmUBKiqV0bqQ==
-
 "@types/stack-utils@^1.0.1":
   version "1.0.1"
   resolved "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-1.0.1.tgz#0a851d3bd96498fa25c33ab7278ed3bd65f06c3e"
@@ -1246,33 +357,11 @@
   dependencies:
     "@types/yargs-parser" "*"
 
-"@zkochan/cmd-shim@^3.1.0":
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/@zkochan/cmd-shim/-/cmd-shim-3.1.0.tgz#2ab8ed81f5bb5452a85f25758eb9b8681982fd2e"
-  integrity sha512-o8l0+x7C7sMZU3v9GuJIAU10qQLtwR1dtRQIOmlNMtyaqhmpXOzx1HWiYoWfmmf9HHZoAkXpc9TM9PQYF9d4Jg==
-  dependencies:
-    is-windows "^1.0.0"
-    mkdirp-promise "^5.0.1"
-    mz "^2.5.0"
-
-JSONStream@^1.0.4, JSONStream@^1.3.4:
-  version "1.3.5"
-  resolved "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.5.tgz#3208c1f08d3a4d99261ab64f92302bc15e111ca0"
-  integrity sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==
-  dependencies:
-    jsonparse "^1.2.0"
-    through ">=2.2.7 <3"
-
 abab@^2.0.0:
   version "2.0.3"
   resolved "https://registry.npmjs.org/abab/-/abab-2.0.3.tgz#623e2075e02eb2d3f2475e49f99c91846467907a"
   integrity sha512-tsFzPpcttalNjFBCFMqsKYQcWxxen1pgJR56by//QwvJc4/OUS3kPOOttx2tSIfjsylB0pYu7f5D3K1RCxUnUg==
 
-abbrev@1:
-  version "1.1.1"
-  resolved "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz#f8f2c887ad10bf67f634f005b6987fed3179aac8"
-  integrity sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==
-
 acorn-globals@^4.1.0:
   version "4.3.4"
   resolved "https://registry.npmjs.org/acorn-globals/-/acorn-globals-4.3.4.tgz#9fa1926addc11c97308c4e66d7add0d40c3272e7"
@@ -1311,27 +400,6 @@ acorn@~4.0.2:
   resolved "https://registry.npmjs.org/acorn/-/acorn-4.0.13.tgz#105495ae5361d697bd195c825192e1ad7f253787"
   integrity sha1-EFSVrlNh1pe9GVyCUZLhrX8lN4c=
 
-agent-base@4, agent-base@^4.3.0:
-  version "4.3.0"
-  resolved "https://registry.npmjs.org/agent-base/-/agent-base-4.3.0.tgz#8165f01c436009bccad0b1d122f05ed770efc6ee"
-  integrity sha512-salcGninV0nPrwpGNn4VTXBb1SOuXQBiqbrNXoeizJsHrsL6ERFM2Ne3JUSBWRE6aeNJI2ROP/WEEIDUiDe3cg==
-  dependencies:
-    es6-promisify "^5.0.0"
-
-agent-base@~4.2.1:
-  version "4.2.1"
-  resolved "https://registry.npmjs.org/agent-base/-/agent-base-4.2.1.tgz#d89e5999f797875674c07d87f260fc41e83e8ca9"
-  integrity sha512-JVwXMr9nHYTUXsBFKUqhJwvlcYU/blreOEUkhNR2eXZIvwd+c+o5V4MgDPKWnMS/56awN3TRzIP+KoPn+roQtg==
-  dependencies:
-    es6-promisify "^5.0.0"
-
-agentkeepalive@^3.4.1:
-  version "3.5.2"
-  resolved "https://registry.npmjs.org/agentkeepalive/-/agentkeepalive-3.5.2.tgz#a113924dd3fa24a0bc3b78108c450c2abee00f67"
-  integrity sha512-e0L/HNe6qkQ7H19kTlRRqUibEAwDK5AFk6y3PtMsuut2VAH6+Q4xZml1tNDJD7kSAyqmbG/K08K5WEJYtUrSlQ==
-  dependencies:
-    humanize-ms "^1.2.1"
-
 ajv@^4.9.1:
   version "4.11.8"
   resolved "https://registry.npmjs.org/ajv/-/ajv-4.11.8.tgz#82ffb02b29e662ae53bdc20af15947706739c536"
@@ -1364,14 +432,14 @@ amdefine@>=0.0.4:
   resolved "https://registry.npmjs.org/amdefine/-/amdefine-1.0.1.tgz#4a5282ac164729e93619bcfd3ad151f817ce91f5"
   integrity sha1-SlKCrBZHKek2Gbz9OtFR+BfOkfU=
 
-ansi-escapes@^3.0.0, ansi-escapes@^3.2.0:
+ansi-escapes@^3.0.0:
   version "3.2.0"
   resolved "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-3.2.0.tgz#8780b98ff9dbf5638152d1f1fe5c1d7b4442976b"
   integrity sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==
 
 ansi-regex@^2.0.0:
   version "2.1.1"
-  resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz#c3b33ab5ee360d86e0e628f0468ae7ef27d654df"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-2.1.1.tgz#c3b33ab5ee360d86e0e628f0468ae7ef27d654df"
   integrity sha1-w7M6te42DYbg5ijwRorn7yfWVN8=
 
 ansi-regex@^3.0.0:
@@ -1391,11 +459,6 @@ ansi-styles@^3.2.0, ansi-styles@^3.2.1:
   dependencies:
     color-convert "^1.9.0"
 
-any-promise@^1.0.0:
-  version "1.3.0"
-  resolved "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz#abc6afeedcea52e809cdc0376aed3ce39635d17f"
-  integrity sha1-q8av7tzqUugJzcA3au0845Y10X8=
-
 anymatch@^2.0.0:
   version "2.0.0"
   resolved "https://registry.npmjs.org/anymatch/-/anymatch-2.0.0.tgz#bcb24b4f37934d9aa7ac17b4adaf89e7c76ef2eb"
@@ -1404,24 +467,6 @@ anymatch@^2.0.0:
     micromatch "^3.1.4"
     normalize-path "^2.1.1"
 
-aproba@^1.0.3, aproba@^1.1.1:
-  version "1.2.0"
-  resolved "https://registry.npmjs.org/aproba/-/aproba-1.2.0.tgz#6802e6264efd18c790a1b0d517f0f2627bf2c94a"
-  integrity sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==
-
-aproba@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/aproba/-/aproba-2.0.0.tgz#52520b8ae5b569215b354efc0caa3fe1e45a8adc"
-  integrity sha512-lYe4Gx7QT+MKGbDsA+Z+he/Wtef0BiwDOlK/XkBrdfsh9J/jPPXbX0tE9x9cl27Tmu5gg3QUbUrQYa/y+KOHPQ==
-
-are-we-there-yet@~1.1.2:
-  version "1.1.5"
-  resolved "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-1.1.5.tgz#4b35c2944f062a8bfcda66410760350fe9ddfc21"
-  integrity sha512-5hYdAkZlcG8tOLujVDTgCT+uPX0VnpAH28gWsLfzpXYm7wP6mp5Q/gYyR7YQ0cKVJcXJnl3j2kpBan13PtQf6w==
-  dependencies:
-    delegates "^1.0.0"
-    readable-stream "^2.0.6"
-
 argparse@^1.0.7:
   version "1.0.10"
   resolved "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911"
@@ -1444,58 +489,26 @@ arr-union@^3.1.0:
   resolved "https://registry.npmjs.org/arr-union/-/arr-union-3.1.0.tgz#e39b09aea9def866a8f206e288af63919bae39c4"
   integrity sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=
 
-array-differ@^2.0.3:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/array-differ/-/array-differ-2.1.0.tgz#4b9c1c3f14b906757082925769e8ab904f4801b1"
-  integrity sha512-KbUpJgx909ZscOc/7CLATBFam7P1Z1QRQInvgT0UztM9Q72aGKCunKASAl7WNW0tnPmPyEMeMhdsfWhfmW037w==
-
 array-equal@^1.0.0:
   version "1.0.0"
   resolved "https://registry.npmjs.org/array-equal/-/array-equal-1.0.0.tgz#8c2a5ef2472fd9ea742b04c77a75093ba2757c93"
   integrity sha1-jCpe8kcv2ep0KwTHenUJO6J1fJM=
 
-array-find-index@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/array-find-index/-/array-find-index-1.0.2.tgz#df010aa1287e164bbda6f9723b0a96a1ec4187a1"
-  integrity sha1-3wEKoSh+Fku9pvlyOwqWoexBh6E=
-
-array-ify@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/array-ify/-/array-ify-1.0.0.tgz#9e528762b4a9066ad163a6962a364418e9626ece"
-  integrity sha1-nlKHYrSpBmrRY6aWKjZEGOlibs4=
-
-array-union@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/array-union/-/array-union-1.0.2.tgz#9a34410e4f4e3da23dea375be5be70f24778ec39"
-  integrity sha1-mjRBDk9OPaI96jdb5b5w8kd47Dk=
-  dependencies:
-    array-uniq "^1.0.1"
-
-array-uniq@^1.0.1:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/array-uniq/-/array-uniq-1.0.3.tgz#af6ac877a25cc7f74e058894753858dfdb24fdb6"
-  integrity sha1-r2rId6Jcx/dOBYiUdThY39sk/bY=
-
 array-unique@^0.3.2:
   version "0.3.2"
   resolved "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz#a894b75d4bc4f6cd679ef3244a9fd8f46ae2d428"
   integrity sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=
 
-arrify@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d"
-  integrity sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0=
-
-asap@^2.0.0, asap@~2.0.3:
-  version "2.0.6"
-  resolved "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz#e50347611d7e690943208bbdafebcbc2fb866d46"
-  integrity sha1-5QNHYR1+aQlDIIu9r+vLwvuGbUY=
-
 asap@~1.0.0:
   version "1.0.0"
   resolved "https://registry.npmjs.org/asap/-/asap-1.0.0.tgz#b2a45da5fdfa20b0496fc3768cc27c12fa916a7d"
   integrity sha1-sqRdpf36ILBJb8N2jMJ8EvqRan0=
 
+asap@~2.0.3:
+  version "2.0.6"
+  resolved "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz#e50347611d7e690943208bbdafebcbc2fb866d46"
+  integrity sha1-5QNHYR1+aQlDIIu9r+vLwvuGbUY=
+
 asn1@~0.2.3:
   version "0.2.4"
   resolved "https://registry.npmjs.org/asn1/-/asn1-0.2.4.tgz#8d2475dfab553bb33e77b54e59e880bb8ce23136"
@@ -1538,11 +551,6 @@ asynckit@^0.4.0:
   resolved "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79"
   integrity sha1-x57Zf380y48robyXkLzDZkdLS3k=
 
-atob-lite@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/atob-lite/-/atob-lite-2.0.0.tgz#0fef5ad46f1bd7a8502c65727f0367d5ee43d696"
-  integrity sha1-D+9a1G8b16hQLGVyfwNn1e5D1pY=
-
 atob@^2.1.2:
   version "2.1.2"
   resolved "https://registry.npmjs.org/atob/-/atob-2.1.2.tgz#6d9517eb9e030d2436666651e86bd9f6f13533c9"
@@ -1665,11 +673,6 @@ bcrypt-pbkdf@^1.0.0:
   dependencies:
     tweetnacl "^0.14.3"
 
-before-after-hook@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/before-after-hook/-/before-after-hook-2.1.0.tgz#b6c03487f44e24200dd30ca5e6a1979c5d2fb635"
-  integrity sha512-IWIbu7pMqyw3EAJHzzHbWa85b6oud/yfKYg5rqB5hNE8CeMi3nX+2C2sj0HswfblST86hpVEOAb9x34NZd6P7A==
-
 bindings@^1.5.0:
   version "1.5.0"
   resolved "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz#10353c9e945334bc0511a6d90b38fbc7c9c504df"
@@ -1684,9 +687,9 @@ block-stream@*:
   dependencies:
     inherits "~2.0.0"
 
-bluebird@^3.5.1, bluebird@^3.5.3, bluebird@^3.5.5:
+bluebird@^3.5.1:
   version "3.7.2"
-  resolved "https://registry.npmjs.org/bluebird/-/bluebird-3.7.2.tgz#9f229c15be272454ffa973ace0dbee79a1b0c36f"
+  resolved "https://registry.yarnpkg.com/bluebird/-/bluebird-3.7.2.tgz#9f229c15be272454ffa973ace0dbee79a1b0c36f"
   integrity sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==
 
 boom@2.x.x:
@@ -1739,52 +742,11 @@ bser@2.1.1:
   dependencies:
     node-int64 "^0.4.0"
 
-btoa-lite@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/btoa-lite/-/btoa-lite-1.0.0.tgz#337766da15801210fdd956c22e9c6891ab9d0337"
-  integrity sha1-M3dm2hWAEhD92VbCLpxokaudAzc=
-
 buffer-from@^1.0.0:
   version "1.1.1"
   resolved "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz#32713bc028f75c02fdb710d7c7bcec1f2c6070ef"
   integrity sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==
 
-builtins@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/builtins/-/builtins-1.0.3.tgz#cb94faeb61c8696451db36534e1422f94f0aee88"
-  integrity sha1-y5T662HIaWRR2zZTThQi+U8K7og=
-
-byline@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/byline/-/byline-5.0.0.tgz#741c5216468eadc457b03410118ad77de8c1ddb1"
-  integrity sha1-dBxSFkaOrcRXsDQQEYrXfejB3bE=
-
-byte-size@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.npmjs.org/byte-size/-/byte-size-5.0.1.tgz#4b651039a5ecd96767e71a3d7ed380e48bed4191"
-  integrity sha512-/XuKeqWocKsYa/cBY1YbSJSWWqTi4cFgr9S6OyM7PBaPbr9zvNGwWP33vt0uqGhwDdN+y3yhbXVILEUpnwEWGw==
-
-cacache@^12.0.0, cacache@^12.0.3:
-  version "12.0.3"
-  resolved "https://registry.npmjs.org/cacache/-/cacache-12.0.3.tgz#be99abba4e1bf5df461cd5a2c1071fc432573390"
-  integrity sha512-kqdmfXEGFepesTuROHMs3MpFLWrPkSSpRqOw80RCflZXy/khxaArvFrQ7uJxSUduzAufc6G0g1VUCOZXxWavPw==
-  dependencies:
-    bluebird "^3.5.5"
-    chownr "^1.1.1"
-    figgy-pudding "^3.5.1"
-    glob "^7.1.4"
-    graceful-fs "^4.1.15"
-    infer-owner "^1.0.3"
-    lru-cache "^5.1.1"
-    mississippi "^3.0.0"
-    mkdirp "^0.5.1"
-    move-concurrently "^1.0.1"
-    promise-inflight "^1.0.1"
-    rimraf "^2.6.3"
-    ssri "^6.0.1"
-    unique-filename "^1.1.1"
-    y18n "^4.0.0"
-
 cache-base@^1.0.1:
   version "1.0.1"
   resolved "https://registry.npmjs.org/cache-base/-/cache-base-1.0.1.tgz#0a7f46416831c8b662ee36fe4e7c59d76f666ab2"
@@ -1800,65 +762,19 @@ cache-base@^1.0.1:
     union-value "^1.0.0"
     unset-value "^1.0.0"
 
-call-me-maybe@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/call-me-maybe/-/call-me-maybe-1.0.1.tgz#26d208ea89e37b5cbde60250a15f031c16a4d66b"
-  integrity sha1-JtII6onje1y95gJQoV8DHBak1ms=
-
-caller-callsite@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/caller-callsite/-/caller-callsite-2.0.0.tgz#847e0fce0a223750a9a027c54b33731ad3154134"
-  integrity sha1-hH4PzgoiN1CpoCfFSzNzGtMVQTQ=
-  dependencies:
-    callsites "^2.0.0"
-
-caller-path@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/caller-path/-/caller-path-2.0.0.tgz#468f83044e369ab2010fac5f06ceee15bb2cb1f4"
-  integrity sha1-Ro+DBE42mrIBD6xfBs7uFbsssfQ=
-  dependencies:
-    caller-callsite "^2.0.0"
-
-callsites@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/callsites/-/callsites-2.0.0.tgz#06eb84f00eea413da86affefacbffb36093b3c50"
-  integrity sha1-BuuE8A7qQT2oav/vrL/7Ngk7PFA=
-
 callsites@^3.0.0:
   version "3.1.0"
   resolved "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73"
   integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==
 
-camelcase-keys@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/camelcase-keys/-/camelcase-keys-2.1.0.tgz#308beeaffdf28119051efa1d932213c91b8f92e7"
-  integrity sha1-MIvur/3ygRkFHvodkyITyRuPkuc=
-  dependencies:
-    camelcase "^2.0.0"
-    map-obj "^1.0.0"
-
-camelcase-keys@^4.0.0:
-  version "4.2.0"
-  resolved "https://registry.npmjs.org/camelcase-keys/-/camelcase-keys-4.2.0.tgz#a2aa5fb1af688758259c32c141426d78923b9b77"
-  integrity sha1-oqpfsa9oh1glnDLBQUJteJI7m3c=
-  dependencies:
-    camelcase "^4.1.0"
-    map-obj "^2.0.0"
-    quick-lru "^1.0.0"
-
 camelcase@^1.0.2:
   version "1.2.1"
   resolved "https://registry.npmjs.org/camelcase/-/camelcase-1.2.1.tgz#9bb5304d2e0b56698b2c758b08a3eaa9daa58a39"
   integrity sha1-m7UwTS4LVmmLLHWLCKPqqdqlijk=
 
-camelcase@^2.0.0:
-  version "2.1.1"
-  resolved "https://registry.npmjs.org/camelcase/-/camelcase-2.1.1.tgz#7c1d16d679a1bbe59ca02cacecfb011e201f5a1f"
-  integrity sha1-fB0W1nmhu+WcoCys7PsBHiAfWh8=
-
 camelcase@^4.1.0:
   version "4.1.0"
-  resolved "https://registry.npmjs.org/camelcase/-/camelcase-4.1.0.tgz#d545635be1e33c542649c69173e5de6acfae34dd"
+  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-4.1.0.tgz#d545635be1e33c542649c69173e5de6acfae34dd"
   integrity sha1-1UVjW+HjPFQmScaRc+Xeas+uNN0=
 
 camelcase@^5.0.0, camelcase@^5.3.1:
@@ -1886,7 +802,7 @@ center-align@^0.1.1:
     align-text "^0.1.3"
     lazy-cache "^1.0.3"
 
-chalk@^2.0.0, chalk@^2.0.1, chalk@^2.3.1, chalk@^2.4.2:
+chalk@^2.0.0, chalk@^2.0.1, chalk@^2.3.0, chalk@^2.4.2:
   version "2.4.2"
   resolved "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
   integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==
@@ -1902,16 +818,6 @@ character-parser@^2.2.0:
   dependencies:
     is-regex "^1.0.3"
 
-chardet@^0.7.0:
-  version "0.7.0"
-  resolved "https://registry.npmjs.org/chardet/-/chardet-0.7.0.tgz#90094849f0937f2eedc2425d0d28a9e5f0cbad9e"
-  integrity sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==
-
-chownr@^1.1.1, chownr@^1.1.2:
-  version "1.1.4"
-  resolved "https://registry.npmjs.org/chownr/-/chownr-1.1.4.tgz#6fc9d7b42d32a583596337666e7d08084da2cc6b"
-  integrity sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==
-
 ci-info@^2.0.0:
   version "2.0.0"
   resolved "https://registry.npmjs.org/ci-info/-/ci-info-2.0.0.tgz#67a9e964be31a51e15e5010d58e6f12834002f46"
@@ -1934,18 +840,6 @@ clean-css@^4.2.3:
   dependencies:
     source-map "~0.6.0"
 
-cli-cursor@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/cli-cursor/-/cli-cursor-2.1.0.tgz#b35dac376479facc3e94747d41d0d0f5238ffcb5"
-  integrity sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU=
-  dependencies:
-    restore-cursor "^2.0.0"
-
-cli-width@^2.0.0:
-  version "2.2.0"
-  resolved "https://registry.npmjs.org/cli-width/-/cli-width-2.2.0.tgz#ff19ede8a9a5e579324147b0c11f0fbcbabed639"
-  integrity sha1-/xnt6Kml5XkyQUewwR8PvLq+1jk=
-
 cliui@^2.1.0:
   version "2.1.0"
   resolved "https://registry.npmjs.org/cliui/-/cliui-2.1.0.tgz#4b475760ff80264c762c3a1719032e91c7fea0d1"
@@ -1955,6 +849,15 @@ cliui@^2.1.0:
     right-align "^0.1.1"
     wordwrap "0.0.2"
 
+cliui@^4.0.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/cliui/-/cliui-4.1.0.tgz#348422dbe82d800b3022eef4f6ac10bf2e4d1b49"
+  integrity sha512-4FG+RSG9DL7uEwRUZXZn3SS34DiDPfzP0VOiEwtUWlE+AR2EIg+hSyvrIgUUfhdgR/UkAeW2QHgeP+hWrXs7jQ==
+  dependencies:
+    string-width "^2.1.1"
+    strip-ansi "^4.0.0"
+    wrap-ansi "^2.0.0"
+
 cliui@^5.0.0:
   version "5.0.0"
   resolved "https://registry.npmjs.org/cliui/-/cliui-5.0.0.tgz#deefcfdb2e800784aa34f46fa08e06851c7bbbc5"
@@ -1964,20 +867,6 @@ cliui@^5.0.0:
     strip-ansi "^5.2.0"
     wrap-ansi "^5.1.0"
 
-clone-deep@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.npmjs.org/clone-deep/-/clone-deep-4.0.1.tgz#c19fd9bdbbf85942b4fd979c84dcf7d5f07c2387"
-  integrity sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==
-  dependencies:
-    is-plain-object "^2.0.4"
-    kind-of "^6.0.2"
-    shallow-clone "^3.0.0"
-
-clone@^1.0.2:
-  version "1.0.4"
-  resolved "https://registry.npmjs.org/clone/-/clone-1.0.4.tgz#da309cc263df15994c688ca902179ca3c7cd7c7e"
-  integrity sha1-2jCcwmPfFZlMaIypAheco8fNfH4=
-
 clone@^2.0.0:
   version "2.1.2"
   resolved "https://registry.npmjs.org/clone/-/clone-2.1.2.tgz#1b7f4b9f591f1e8f83670401600345a02887435f"
@@ -1990,7 +879,7 @@ co@^4.6.0:
 
 code-point-at@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz#0d070b4d043a5bea33a2f1a40e2edb3d9a4ccf77"
+  resolved "https://registry.yarnpkg.com/code-point-at/-/code-point-at-1.1.0.tgz#0d070b4d043a5bea33a2f1a40e2edb3d9a4ccf77"
   integrity sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=
 
 coffee-script@~1.12.7:
@@ -2018,14 +907,6 @@ color-name@1.1.3:
   resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz#a7d0558bd89c42f795dd42328f740831ca53bc25"
   integrity sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=
 
-columnify@^1.5.4:
-  version "1.5.4"
-  resolved "https://registry.npmjs.org/columnify/-/columnify-1.5.4.tgz#4737ddf1c7b69a8a7c340570782e947eec8e78bb"
-  integrity sha1-Rzfd8ce2mop8NAVweC6UfuyOeLs=
-  dependencies:
-    strip-ansi "^3.0.0"
-    wcwidth "^1.0.0"
-
 combined-stream@^1.0.5, combined-stream@^1.0.6, combined-stream@~1.0.5, combined-stream@~1.0.6:
   version "1.0.8"
   resolved "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz#c3d45a8b34fd730631a110a8a2520682b31d5a7f"
@@ -2033,19 +914,6 @@ combined-stream@^1.0.5, combined-stream@^1.0.6, combined-stream@~1.0.5, combined
   dependencies:
     delayed-stream "~1.0.0"
 
-commander@~2.20.3:
-  version "2.20.3"
-  resolved "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33"
-  integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==
-
-compare-func@^1.3.1:
-  version "1.3.2"
-  resolved "https://registry.npmjs.org/compare-func/-/compare-func-1.3.2.tgz#99dd0ba457e1f9bc722b12c08ec33eeab31fa648"
-  integrity sha1-md0LpFfh+bxyKxLAjsM+6rMfpkg=
-  dependencies:
-    array-ify "^1.0.0"
-    dot-prop "^3.0.0"
-
 component-emitter@^1.2.1:
   version "1.3.0"
   resolved "https://registry.npmjs.org/component-emitter/-/component-emitter-1.3.0.tgz#16e4070fba8ae29b679f2215853ee181ab2eabc0"
@@ -2056,7 +924,7 @@ concat-map@0.0.1:
   resolved "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
   integrity sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=
 
-concat-stream@^1.4.6, concat-stream@^1.4.7, concat-stream@^1.5.0:
+concat-stream@^1.4.6, concat-stream@^1.4.7:
   version "1.6.2"
   resolved "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz#904bdf194cd3122fc675c77fc4ac3d4ff0fd1a34"
   integrity sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==
@@ -2066,29 +934,6 @@ concat-stream@^1.4.6, concat-stream@^1.4.7, concat-stream@^1.5.0:
     readable-stream "^2.2.2"
     typedarray "^0.0.6"
 
-concat-stream@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/concat-stream/-/concat-stream-2.0.0.tgz#414cf5af790a48c60ab9be4527d56d5e41133cb1"
-  integrity sha512-MWufYdFw53ccGjCA+Ol7XJYpAlW6/prSMzuPOTRnJGcGzuhLn4Scrz7qf6o8bROZ514ltazcIFJZevcfbo0x7A==
-  dependencies:
-    buffer-from "^1.0.0"
-    inherits "^2.0.3"
-    readable-stream "^3.0.2"
-    typedarray "^0.0.6"
-
-config-chain@^1.1.11:
-  version "1.1.12"
-  resolved "https://registry.npmjs.org/config-chain/-/config-chain-1.1.12.tgz#0fde8d091200eb5e808caf25fe618c02f48e4efa"
-  integrity sha512-a1eOIcu8+7lUInge4Rpf/n4Krkf3Dd9lqhljRzII1/Zno/kRtUWnznPO3jOKBmTEktkt3fkxisUcivoj0ebzoA==
-  dependencies:
-    ini "^1.3.4"
-    proto-list "~1.2.1"
-
-console-control-strings@^1.0.0, console-control-strings@~1.1.0:
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz#3d7cf4464db6446ea644bf4b39507f9851008e8e"
-  integrity sha1-PXz0Rk22RG6mRL9LOVB/mFEAjo4=
-
 constantinople@^4.0.1:
   version "4.0.1"
   resolved "https://registry.npmjs.org/constantinople/-/constantinople-4.0.1.tgz#0def113fa0e4dc8de83331a5cf79c8b325213151"
@@ -2097,89 +942,6 @@ constantinople@^4.0.1:
     "@babel/parser" "^7.6.0"
     "@babel/types" "^7.6.1"
 
-conventional-changelog-angular@^5.0.3:
-  version "5.0.6"
-  resolved "https://registry.npmjs.org/conventional-changelog-angular/-/conventional-changelog-angular-5.0.6.tgz#269540c624553aded809c29a3508fdc2b544c059"
-  integrity sha512-QDEmLa+7qdhVIv8sFZfVxU1VSyVvnXPsxq8Vam49mKUcO1Z8VTLEJk9uI21uiJUsnmm0I4Hrsdc9TgkOQo9WSA==
-  dependencies:
-    compare-func "^1.3.1"
-    q "^1.5.1"
-
-conventional-changelog-core@^3.1.6:
-  version "3.2.3"
-  resolved "https://registry.npmjs.org/conventional-changelog-core/-/conventional-changelog-core-3.2.3.tgz#b31410856f431c847086a7dcb4d2ca184a7d88fb"
-  integrity sha512-LMMX1JlxPIq/Ez5aYAYS5CpuwbOk6QFp8O4HLAcZxe3vxoCtABkhfjetk8IYdRB9CDQGwJFLR3Dr55Za6XKgUQ==
-  dependencies:
-    conventional-changelog-writer "^4.0.6"
-    conventional-commits-parser "^3.0.3"
-    dateformat "^3.0.0"
-    get-pkg-repo "^1.0.0"
-    git-raw-commits "2.0.0"
-    git-remote-origin-url "^2.0.0"
-    git-semver-tags "^2.0.3"
-    lodash "^4.2.1"
-    normalize-package-data "^2.3.5"
-    q "^1.5.1"
-    read-pkg "^3.0.0"
-    read-pkg-up "^3.0.0"
-    through2 "^3.0.0"
-
-conventional-changelog-preset-loader@^2.1.1:
-  version "2.3.0"
-  resolved "https://registry.npmjs.org/conventional-changelog-preset-loader/-/conventional-changelog-preset-loader-2.3.0.tgz#580fa8ab02cef22c24294d25e52d7ccd247a9a6a"
-  integrity sha512-/rHb32J2EJnEXeK4NpDgMaAVTFZS3o1ExmjKMtYVgIC4MQn0vkNSbYpdGRotkfGGRWiqk3Ri3FBkiZGbAfIfOQ==
-
-conventional-changelog-writer@^4.0.6:
-  version "4.0.11"
-  resolved "https://registry.npmjs.org/conventional-changelog-writer/-/conventional-changelog-writer-4.0.11.tgz#9f56d2122d20c96eb48baae0bf1deffaed1edba4"
-  integrity sha512-g81GQOR392I+57Cw3IyP1f+f42ME6aEkbR+L7v1FBBWolB0xkjKTeCWVguzRrp6UiT1O6gBpJbEy2eq7AnV1rw==
-  dependencies:
-    compare-func "^1.3.1"
-    conventional-commits-filter "^2.0.2"
-    dateformat "^3.0.0"
-    handlebars "^4.4.0"
-    json-stringify-safe "^5.0.1"
-    lodash "^4.17.15"
-    meow "^5.0.0"
-    semver "^6.0.0"
-    split "^1.0.0"
-    through2 "^3.0.0"
-
-conventional-commits-filter@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.npmjs.org/conventional-commits-filter/-/conventional-commits-filter-2.0.2.tgz#f122f89fbcd5bb81e2af2fcac0254d062d1039c1"
-  integrity sha512-WpGKsMeXfs21m1zIw4s9H5sys2+9JccTzpN6toXtxhpw2VNF2JUXwIakthKBy+LN4DvJm+TzWhxOMWOs1OFCFQ==
-  dependencies:
-    lodash.ismatch "^4.4.0"
-    modify-values "^1.0.0"
-
-conventional-commits-parser@^3.0.3:
-  version "3.0.8"
-  resolved "https://registry.npmjs.org/conventional-commits-parser/-/conventional-commits-parser-3.0.8.tgz#23310a9bda6c93c874224375e72b09fb275fe710"
-  integrity sha512-YcBSGkZbYp7d+Cr3NWUeXbPDFUN6g3SaSIzOybi8bjHL5IJ5225OSCxJJ4LgziyEJ7AaJtE9L2/EU6H7Nt/DDQ==
-  dependencies:
-    JSONStream "^1.0.4"
-    is-text-path "^1.0.1"
-    lodash "^4.17.15"
-    meow "^5.0.0"
-    split2 "^2.0.0"
-    through2 "^3.0.0"
-    trim-off-newlines "^1.0.0"
-
-conventional-recommended-bump@^5.0.0:
-  version "5.0.1"
-  resolved "https://registry.npmjs.org/conventional-recommended-bump/-/conventional-recommended-bump-5.0.1.tgz#5af63903947b6e089e77767601cb592cabb106ba"
-  integrity sha512-RVdt0elRcCxL90IrNP0fYCpq1uGt2MALko0eyeQ+zQuDVWtMGAy9ng6yYn3kax42lCj9+XBxQ8ZN6S9bdKxDhQ==
-  dependencies:
-    concat-stream "^2.0.0"
-    conventional-changelog-preset-loader "^2.1.1"
-    conventional-commits-filter "^2.0.2"
-    conventional-commits-parser "^3.0.3"
-    git-raw-commits "2.0.0"
-    git-semver-tags "^2.0.3"
-    meow "^4.0.0"
-    q "^1.5.1"
-
 convert-source-map@^1.4.0, convert-source-map@^1.7.0:
   version "1.7.0"
   resolved "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.7.0.tgz#17a2cb882d7f77d3490585e2ce6c524424a3a442"
@@ -2187,18 +949,6 @@ convert-source-map@^1.4.0, convert-source-map@^1.7.0:
   dependencies:
     safe-buffer "~5.1.1"
 
-copy-concurrently@^1.0.0:
-  version "1.0.5"
-  resolved "https://registry.npmjs.org/copy-concurrently/-/copy-concurrently-1.0.5.tgz#92297398cae34937fcafd6ec8139c18051f0b5e0"
-  integrity sha512-f2domd9fsVDFtaFcbaRZuYXwtdmnzqbADSwhSWYxYB/Q8zsdUUFMXVRwXGDMWmbEzAn1kdRrtI1T/KTFOL4X2A==
-  dependencies:
-    aproba "^1.1.1"
-    fs-write-stream-atomic "^1.0.8"
-    iferr "^0.1.5"
-    mkdirp "^0.5.1"
-    rimraf "^2.5.4"
-    run-queue "^1.0.0"
-
 copy-descriptor@^0.1.0:
   version "0.1.1"
   resolved "https://registry.npmjs.org/copy-descriptor/-/copy-descriptor-0.1.1.tgz#676f6eb3c39997c2ee1ac3a924fd6124748f578d"
@@ -2214,16 +964,6 @@ core-util-is@1.0.2, core-util-is@~1.0.0:
   resolved "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7"
   integrity sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=
 
-cosmiconfig@^5.1.0:
-  version "5.2.1"
-  resolved "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-5.2.1.tgz#040f726809c591e77a17c0a3626ca45b4f168b1a"
-  integrity sha512-H65gsXo1SKjf8zmrJ67eJk8aIRKV5ff2D4uKZIBZShbhGSpEmsQOPW/SKMKYhSTrqR7ufy6RP69rPogdaPh/kA==
-  dependencies:
-    import-fresh "^2.0.0"
-    is-directory "^0.3.1"
-    js-yaml "^3.13.1"
-    parse-json "^4.0.0"
-
 coveralls@3.0.9:
   version "3.0.9"
   resolved "https://registry.npmjs.org/coveralls/-/coveralls-3.0.9.tgz#8cfc5a5525f84884e2948a0bf0f1c0e90aac0420"
@@ -2270,25 +1010,6 @@ cssstyle@^1.0.0:
   dependencies:
     cssom "0.3.x"
 
-currently-unhandled@^0.4.1:
-  version "0.4.1"
-  resolved "https://registry.npmjs.org/currently-unhandled/-/currently-unhandled-0.4.1.tgz#988df33feab191ef799a61369dd76c17adf957ea"
-  integrity sha1-mI3zP+qxke95mmE2nddsF635V+o=
-  dependencies:
-    array-find-index "^1.0.1"
-
-cyclist@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/cyclist/-/cyclist-1.0.1.tgz#596e9698fd0c80e12038c2b82d6eb1b35b6224d9"
-  integrity sha1-WW6WmP0MgOEgOMK4LW6xs1tiJNk=
-
-dargs@^4.0.1:
-  version "4.1.0"
-  resolved "https://registry.npmjs.org/dargs/-/dargs-4.1.0.tgz#03a9dbb4b5c2f139bf14ae53f0b8a2a6a86f4e17"
-  integrity sha1-A6nbtLXC8Tm/FK5T8LiipqhvThc=
-  dependencies:
-    number-is-nan "^1.0.0"
-
 dashdash@^1.12.0:
   version "1.14.1"
   resolved "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz#853cfa0f7cbe2fed5de20326b8dd581035f6e2f0"
@@ -2305,11 +1026,6 @@ data-urls@^1.0.0:
     whatwg-mimetype "^2.2.0"
     whatwg-url "^7.0.0"
 
-dateformat@^3.0.0:
-  version "3.0.3"
-  resolved "https://registry.npmjs.org/dateformat/-/dateformat-3.0.3.tgz#a6e37499a4d9a9cf85ef5872044d62901c9889ae"
-  integrity sha512-jyCETtSl3VMZMWeRo7iY1FL19ges1t55hMo5yaam4Jrsm5EPL89UQkoQRyiI+Yf4k8r2ZpdngkV8hr1lIdjb3Q==
-
 debug@*, debug@^4.1.0, debug@^4.1.1:
   version "4.1.1"
   resolved "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz#3b72260255109c6b589cee050f1d516139664791"
@@ -2317,13 +1033,6 @@ debug@*, debug@^4.1.0, debug@^4.1.1:
   dependencies:
     ms "^2.1.1"
 
-debug@3.1.0:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz#5bb5a0672628b64149566ba16819e61518c67261"
-  integrity sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==
-  dependencies:
-    ms "2.0.0"
-
 debug@^2.2.0, debug@^2.3.3:
   version "2.6.9"
   resolved "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f"
@@ -2331,27 +1040,7 @@ debug@^2.2.0, debug@^2.3.3:
   dependencies:
     ms "2.0.0"
 
-debug@^3.1.0:
-  version "3.2.6"
-  resolved "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz#e83d17de16d8a7efb7717edbe5fb10135eee629b"
-  integrity sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==
-  dependencies:
-    ms "^2.1.1"
-
-debuglog@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/debuglog/-/debuglog-1.0.1.tgz#aa24ffb9ac3df9a2351837cfb2d279360cd78492"
-  integrity sha1-qiT/uaw9+aI1GDfPstJ5NgzXhJI=
-
-decamelize-keys@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/decamelize-keys/-/decamelize-keys-1.1.0.tgz#d171a87933252807eb3cb61dc1c1445d078df2d9"
-  integrity sha1-0XGoeTMlKAfrPLYdwcFEXQeN8tk=
-  dependencies:
-    decamelize "^1.1.0"
-    map-obj "^1.0.0"
-
-decamelize@^1.0.0, decamelize@^1.1.0, decamelize@^1.1.2, decamelize@^1.2.0:
+decamelize@^1.0.0, decamelize@^1.1.1, decamelize@^1.2.0:
   version "1.2.0"
   resolved "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290"
   integrity sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=
@@ -2361,23 +1050,11 @@ decode-uri-component@^0.2.0:
   resolved "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.0.tgz#eb3913333458775cb84cd1a1fae062106bb87545"
   integrity sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=
 
-dedent@^0.7.0:
-  version "0.7.0"
-  resolved "https://registry.npmjs.org/dedent/-/dedent-0.7.0.tgz#2495ddbaf6eb874abb0e1be9df22d2e5a544326c"
-  integrity sha1-JJXduvbrh0q7Dhvp3yLS5aVEMmw=
-
 deep-is@~0.1.3:
   version "0.1.3"
   resolved "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz#b369d6fb5dbc13eecf524f91b070feedc357cf34"
   integrity sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=
 
-defaults@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/defaults/-/defaults-1.0.3.tgz#c656051e9817d9ff08ed881477f3fe4019f3ef7d"
-  integrity sha1-xlYFHpgX2f8I7YgUd/P+QBnz730=
-  dependencies:
-    clone "^1.0.2"
-
 define-properties@^1.1.2, define-properties@^1.1.3:
   version "1.1.3"
   resolved "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz#cf88da6cbee26fe6db7094f61d870cbd84cee9f1"
@@ -2412,46 +1089,16 @@ delayed-stream@~1.0.0:
   resolved "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619"
   integrity sha1-3zrhmayt+31ECqrgsp4icrJOxhk=
 
-delegates@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz#84c6e159b81904fdca59a0ef44cd870d31250f9a"
-  integrity sha1-hMbhWbgZBP3KWaDvRM2HDTElD5o=
-
-deprecation@^2.0.0, deprecation@^2.3.1:
-  version "2.3.1"
-  resolved "https://registry.npmjs.org/deprecation/-/deprecation-2.3.1.tgz#6368cbdb40abf3373b525ac87e4a260c3a700919"
-  integrity sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ==
-
-detect-indent@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/detect-indent/-/detect-indent-5.0.0.tgz#3871cc0a6a002e8c3e5b3cf7f336264675f06b9d"
-  integrity sha1-OHHMCmoALow+Wzz38zYmRnXwa50=
-
 detect-newline@^2.1.0:
   version "2.1.0"
   resolved "https://registry.npmjs.org/detect-newline/-/detect-newline-2.1.0.tgz#f41f1c10be4b00e87b5f13da680759f2c5bfd3e2"
   integrity sha1-9B8cEL5LAOh7XxPaaAdZ8sW/0+I=
 
-dezalgo@^1.0.0:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/dezalgo/-/dezalgo-1.0.3.tgz#7f742de066fc748bc8db820569dddce49bf0d456"
-  integrity sha1-f3Qt4Gb8dIvI24IFad3c5Jvw1FY=
-  dependencies:
-    asap "^2.0.0"
-    wrappy "1"
-
 diff-sequences@^24.9.0:
   version "24.9.0"
   resolved "https://registry.npmjs.org/diff-sequences/-/diff-sequences-24.9.0.tgz#5715d6244e2aa65f48bba0bc972db0b0b11e95b5"
   integrity sha512-Dj6Wk3tWyTE+Fo1rW8v0Xhwk80um6yFYKbuAxc9c3EZxIHFDYwbi34Uk42u1CdnIiVorvt4RmlSDjIPyzGC2ew==
 
-dir-glob@^2.2.2:
-  version "2.2.2"
-  resolved "https://registry.npmjs.org/dir-glob/-/dir-glob-2.2.2.tgz#fa09f0694153c8918b18ba0deafae94769fc50c4"
-  integrity sha512-f9LBi5QWzIW3I6e//uxZoLBlUt9kcp66qo0sSCxL6YZKc75R1c4MFCoe/LaZiBGmgujvQdxc5Bn3QhfyvK5Hsw==
-  dependencies:
-    path-type "^3.0.0"
-
 doctypes@^1.1.0:
   version "1.1.0"
   resolved "https://registry.npmjs.org/doctypes/-/doctypes-1.1.0.tgz#ea80b106a87538774e8a3a4a5afe293de489e0a9"
@@ -2464,35 +1111,6 @@ domexception@^1.0.1:
   dependencies:
     webidl-conversions "^4.0.2"
 
-dot-prop@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/dot-prop/-/dot-prop-3.0.0.tgz#1b708af094a49c9a0e7dbcad790aba539dac1177"
-  integrity sha1-G3CK8JSknJoOfbyteQq6U52sEXc=
-  dependencies:
-    is-obj "^1.0.0"
-
-dot-prop@^4.2.0:
-  version "4.2.0"
-  resolved "https://registry.npmjs.org/dot-prop/-/dot-prop-4.2.0.tgz#1f19e0c2e1aa0e32797c49799f2837ac6af69c57"
-  integrity sha512-tUMXrxlExSW6U2EXiiKGSBVdYgtV8qlHL+C10TsW4PURY/ic+eaysnSkwB4kA/mBlCyy/IKDJ+Lc3wbWeaXtuQ==
-  dependencies:
-    is-obj "^1.0.0"
-
-duplexer@^0.1.1:
-  version "0.1.1"
-  resolved "https://registry.npmjs.org/duplexer/-/duplexer-0.1.1.tgz#ace6ff808c1ce66b57d1ebf97977acb02334cfc1"
-  integrity sha1-rOb/gIwc5mtX0ev5eXessCM0z8E=
-
-duplexify@^3.4.2, duplexify@^3.6.0:
-  version "3.7.1"
-  resolved "https://registry.npmjs.org/duplexify/-/duplexify-3.7.1.tgz#2a4df5317f6ccfd91f86d6fd25d8d8a103b88309"
-  integrity sha512-07z8uv2wMyS51kKhD1KsdXJg5WQ6t93RneqRxUHnskXVtlYYkLqM0gqStQZ3pj073g687jPCHrqNfCzawLYh5g==
-  dependencies:
-    end-of-stream "^1.0.0"
-    inherits "^2.0.1"
-    readable-stream "^2.0.0"
-    stream-shift "^1.0.0"
-
 ecc-jsbn@~0.1.1:
   version "0.1.2"
   resolved "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz#3a83a904e54353287874c564b7549386849a98c9"
@@ -2506,14 +1124,7 @@ emoji-regex@^7.0.1:
   resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz#933a04052860c85e83c122479c4748a8e4c72156"
   integrity sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==
 
-encoding@^0.1.11:
-  version "0.1.12"
-  resolved "https://registry.npmjs.org/encoding/-/encoding-0.1.12.tgz#538b66f3ee62cd1ab51ec323829d1f9480c74beb"
-  integrity sha1-U4tm8+5izRq1HsMjgp0flIDHS+s=
-  dependencies:
-    iconv-lite "~0.4.13"
-
-end-of-stream@^1.0.0, end-of-stream@^1.1.0:
+end-of-stream@^1.1.0:
   version "1.4.4"
   resolved "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz#5ae64a5f45057baf3626ec14da0ca5e4b2431eb0"
   integrity sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==
@@ -2525,21 +1136,6 @@ entities@~1.1.1:
   resolved "https://registry.npmjs.org/entities/-/entities-1.1.2.tgz#bdfa735299664dfafd34529ed4f8522a275fea56"
   integrity sha512-f2LZMYl1Fzu7YSBKg+RoROelpOaNrcGmE9AZubeDfrCEia483oW4MI4VyFd5VNHIgQ/7qm1I0wUHK1eJnn2y2w==
 
-env-paths@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.npmjs.org/env-paths/-/env-paths-2.2.0.tgz#cdca557dc009152917d6166e2febe1f039685e43"
-  integrity sha512-6u0VYSCo/OW6IoD5WCLLy9JUGARbamfSavcNXry/eu8aHVFei6CD3Sw+VGX5alea1i9pgPHW0mbu6Xj0uBh7gA==
-
-envinfo@^7.3.1:
-  version "7.5.0"
-  resolved "https://registry.npmjs.org/envinfo/-/envinfo-7.5.0.tgz#91410bb6db262fb4f1409bd506e9ff57e91023f4"
-  integrity sha512-jDgnJaF/Btomk+m3PZDTTCb5XIIIX3zYItnCRfF73zVgvinLoRomuhi75Y4su0PtQxWz4v66XnLLckyvyJTOIQ==
-
-err-code@^1.0.0:
-  version "1.1.2"
-  resolved "https://registry.npmjs.org/err-code/-/err-code-1.1.2.tgz#06e0116d3028f6aef4806849eb0ea6a748ae6960"
-  integrity sha1-BuARbTAo9q70gGhJ6w6mp0iuaWA=
-
 errno@^0.1.1:
   version "0.1.7"
   resolved "https://registry.npmjs.org/errno/-/errno-0.1.7.tgz#4684d71779ad39af177e3f007996f7c67c852618"
@@ -2547,7 +1143,7 @@ errno@^0.1.1:
   dependencies:
     prr "~1.0.1"
 
-error-ex@^1.2.0, error-ex@^1.3.1:
+error-ex@^1.3.1:
   version "1.3.2"
   resolved "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz#b4ac40648107fdcdcfae242f428bea8a14d4f1bf"
   integrity sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==
@@ -2580,18 +1176,6 @@ es-to-primitive@^1.2.1:
     is-date-object "^1.0.1"
     is-symbol "^1.0.2"
 
-es6-promise@^4.0.3:
-  version "4.2.8"
-  resolved "https://registry.npmjs.org/es6-promise/-/es6-promise-4.2.8.tgz#4eb21594c972bc40553d276e510539143db53e0a"
-  integrity sha512-HJDGx5daxeIvxdBxvG2cb9g4tEvwIk3i8+nhX0yGrYmZUzbkdg8QbDevheDB8gd0//uPj4c1EQua8Q+MViT0/w==
-
-es6-promisify@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/es6-promisify/-/es6-promisify-5.0.0.tgz#5109d62f3e56ea967c4b63505aef08291c8a5203"
-  integrity sha1-UQnWLz5W6pZ8S2NQWu8IKRyKUgM=
-  dependencies:
-    es6-promise "^4.0.3"
-
 escape-string-regexp@^1.0.5:
   version "1.0.5"
   resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
@@ -2624,11 +1208,6 @@ esutils@^2.0.2:
   resolved "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64"
   integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
 
-eventemitter3@^3.1.0:
-  version "3.1.2"
-  resolved "https://registry.npmjs.org/eventemitter3/-/eventemitter3-3.1.2.tgz#2d3d48f9c346698fce83a85d7d664e98535df6e7"
-  integrity sha512-tvtQIeLVHjDkJYnzf2dgVMxfuSGJeM/7UCG17TT4EumTfNtF+0nebF/4zWOIkCreAbtNqhGEboB6BWrwqNaw4Q==
-
 exec-sh@^0.3.2:
   version "0.3.4"
   resolved "https://registry.npmjs.org/exec-sh/-/exec-sh-0.3.4.tgz#3a018ceb526cc6f6df2bb504b2bfe8e3a4934ec5"
@@ -2697,15 +1276,6 @@ extend@~3.0.0, extend@~3.0.2:
   resolved "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz#f8b1136b4071fbd8eb140aff858b1019ec2915fa"
   integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==
 
-external-editor@^3.0.3:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/external-editor/-/external-editor-3.1.0.tgz#cb03f740befae03ea4d283caed2741a83f335495"
-  integrity sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==
-  dependencies:
-    chardet "^0.7.0"
-    iconv-lite "^0.4.24"
-    tmp "^0.0.33"
-
 extglob@^2.0.4:
   version "2.0.4"
   resolved "https://registry.npmjs.org/extglob/-/extglob-2.0.4.tgz#ad00fe4dc612a9232e8718711dc5cb5ab0285543"
@@ -2735,18 +1305,6 @@ fast-deep-equal@^3.1.1:
   resolved "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.1.tgz#545145077c501491e33b15ec408c294376e94ae4"
   integrity sha512-8UEa58QDLauDNfpbrX55Q9jrGHThw2ZMdOky5Gl1CDtVeJDPVrG4Jxx1N8jw2gkWaff5UUuX1KJd+9zGe2B+ZA==
 
-fast-glob@^2.2.6:
-  version "2.2.7"
-  resolved "https://registry.npmjs.org/fast-glob/-/fast-glob-2.2.7.tgz#6953857c3afa475fff92ee6015d52da70a4cd39d"
-  integrity sha512-g1KuQwHOZAmOZMuBtHdxDtju+T2RT8jgCC9aANsbpdiDDTSnjgfuVsIBNKbUeJI3oKMRExcfNDtJl4OhbffMsw==
-  dependencies:
-    "@mrmlnc/readdir-enhanced" "^2.2.1"
-    "@nodelib/fs.stat" "^1.1.2"
-    glob-parent "^3.1.0"
-    is-glob "^4.0.0"
-    merge2 "^1.2.3"
-    micromatch "^3.1.10"
-
 fast-json-stable-stringify@^2.0.0:
   version "2.1.0"
   resolved "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633"
@@ -2764,18 +1322,6 @@ fb-watchman@^2.0.0:
   dependencies:
     bser "2.1.1"
 
-figgy-pudding@^3.4.1, figgy-pudding@^3.5.1:
-  version "3.5.1"
-  resolved "https://registry.npmjs.org/figgy-pudding/-/figgy-pudding-3.5.1.tgz#862470112901c727a0e495a80744bd5baa1d6790"
-  integrity sha512-vNKxJHTEKNThjfrdJwHc7brvM6eVevuO5nTj6ez8ZQ1qbXTvGthucRF7S4vf2cr71QVnT70V34v0S1DyQsti0w==
-
-figures@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/figures/-/figures-2.0.0.tgz#3ab1a2d2a62c8bfb431a0c94cb797a2fce27c962"
-  integrity sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=
-  dependencies:
-    escape-string-regexp "^1.0.5"
-
 file-uri-to-path@1.0.0:
   version "1.0.0"
   resolved "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz#553a7b8446ff6f684359c445f1e37a05dacc33dd"
@@ -2791,17 +1337,9 @@ fill-range@^4.0.0:
     repeat-string "^1.6.1"
     to-regex-range "^2.1.0"
 
-find-up@^1.0.0:
-  version "1.1.2"
-  resolved "https://registry.npmjs.org/find-up/-/find-up-1.1.2.tgz#6b2e9822b1a2ce0a60ab64d610eccad53cb24d0f"
-  integrity sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=
-  dependencies:
-    path-exists "^2.0.0"
-    pinkie-promise "^2.0.0"
-
-find-up@^2.0.0:
+find-up@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz#45d1b7e506c717ddd482775a2b77920a3c0c57a7"
+  resolved "https://registry.yarnpkg.com/find-up/-/find-up-2.1.0.tgz#45d1b7e506c717ddd482775a2b77920a3c0c57a7"
   integrity sha1-RdG35QbHF93UgndaK3eSCjwMV6c=
   dependencies:
     locate-path "^2.0.0"
@@ -2813,14 +1351,6 @@ find-up@^3.0.0:
   dependencies:
     locate-path "^3.0.0"
 
-flush-write-stream@^1.0.0:
-  version "1.1.1"
-  resolved "https://registry.npmjs.org/flush-write-stream/-/flush-write-stream-1.1.1.tgz#8dd7d873a1babc207d94ead0c2e0e44276ebf2e8"
-  integrity sha512-3Z4XhFZ3992uIq0XOqb9AreonueSYphE6oYbpt5+3u06JWklbsPkNv3ZKkP9Bz/r+1MWCaMoSQ28P85+1Yc77w==
-  dependencies:
-    inherits "^2.0.3"
-    readable-stream "^2.3.6"
-
 for-in@^1.0.2:
   version "1.0.2"
   resolved "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz#81068d295a8142ec0ac726c6e2200c30fb6d5e80"
@@ -2856,40 +1386,6 @@ fragment-cache@^0.2.1:
   dependencies:
     map-cache "^0.2.2"
 
-from2@^2.1.0:
-  version "2.3.0"
-  resolved "https://registry.npmjs.org/from2/-/from2-2.3.0.tgz#8bfb5502bde4a4d36cfdeea007fcca21d7e382af"
-  integrity sha1-i/tVAr3kpNNs/e6gB/zKIdfjgq8=
-  dependencies:
-    inherits "^2.0.1"
-    readable-stream "^2.0.0"
-
-fs-extra@^8.1.0:
-  version "8.1.0"
-  resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz#49d43c45a88cd9677668cb7be1b46efdb8d2e1c0"
-  integrity sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==
-  dependencies:
-    graceful-fs "^4.2.0"
-    jsonfile "^4.0.0"
-    universalify "^0.1.0"
-
-fs-minipass@^1.2.5:
-  version "1.2.7"
-  resolved "https://registry.npmjs.org/fs-minipass/-/fs-minipass-1.2.7.tgz#ccff8570841e7fe4265693da88936c55aed7f7c7"
-  integrity sha512-GWSSJGFy4e9GUeCcbIkED+bgAoFyj7XF1mV8rma3QW4NIqX9Kyx79N/PF61H5udOV3aY1IaMLs6pGbH71nlCTA==
-  dependencies:
-    minipass "^2.6.0"
-
-fs-write-stream-atomic@^1.0.8:
-  version "1.0.10"
-  resolved "https://registry.npmjs.org/fs-write-stream-atomic/-/fs-write-stream-atomic-1.0.10.tgz#b47df53493ef911df75731e70a9ded0189db40c9"
-  integrity sha1-tH31NJPvkR33VzHnCp3tAYnbQMk=
-  dependencies:
-    graceful-fs "^4.1.2"
-    iferr "^0.1.5"
-    imurmurhash "^0.1.4"
-    readable-stream "1 || 2"
-
 fs.realpath@^1.0.0:
   version "1.0.0"
   resolved "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
@@ -2918,51 +1414,21 @@ function-bind@^1.1.1:
   resolved "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"
   integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==
 
-gauge@~2.7.3:
-  version "2.7.4"
-  resolved "https://registry.npmjs.org/gauge/-/gauge-2.7.4.tgz#2c03405c7538c39d7eb37b317022e325fb018bf7"
-  integrity sha1-LANAXHU4w51+s3sxcCLjJfsBi/c=
-  dependencies:
-    aproba "^1.0.3"
-    console-control-strings "^1.0.0"
-    has-unicode "^2.0.0"
-    object-assign "^4.1.0"
-    signal-exit "^3.0.0"
-    string-width "^1.0.1"
-    strip-ansi "^3.0.1"
-    wide-align "^1.1.0"
-
-genfun@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/genfun/-/genfun-5.0.0.tgz#9dd9710a06900a5c4a5bf57aca5da4e52fe76537"
-  integrity sha512-KGDOARWVga7+rnB3z9Sd2Letx515owfk0hSxHGuqjANb1M+x2bGZGqHLiozPsYMdM2OubeMni/Hpwmjq6qIUhA==
-
 gensync@^1.0.0-beta.1:
   version "1.0.0-beta.1"
   resolved "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.1.tgz#58f4361ff987e5ff6e1e7a210827aa371eaac269"
   integrity sha512-r8EC6NO1sngH/zdD9fiRDLdcgnbayXah+mLgManTaIZJqEC1MZstmnox8KpnI2/fxQwrp5OpCOYWLp4rBl4Jcg==
 
+get-caller-file@^1.0.1:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-1.0.3.tgz#f978fa4c90d1dfe7ff2d6beda2a515e713bdcf4a"
+  integrity sha512-3t6rVToeoZfYSGd8YoLFR2DJkiQrIiUrGcjvFX2mDw3bn6k2OtwHN0TNCLbBO+w8qTvimhDkv+LSscbJY1vE6w==
+
 get-caller-file@^2.0.1:
   version "2.0.5"
   resolved "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e"
   integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==
 
-get-pkg-repo@^1.0.0:
-  version "1.4.0"
-  resolved "https://registry.npmjs.org/get-pkg-repo/-/get-pkg-repo-1.4.0.tgz#c73b489c06d80cc5536c2c853f9e05232056972d"
-  integrity sha1-xztInAbYDMVTbCyFP54FIyBWly0=
-  dependencies:
-    hosted-git-info "^2.1.4"
-    meow "^3.3.0"
-    normalize-package-data "^2.3.0"
-    parse-github-repo-url "^1.3.0"
-    through2 "^2.0.0"
-
-get-port@^4.2.0:
-  version "4.2.0"
-  resolved "https://registry.npmjs.org/get-port/-/get-port-4.2.0.tgz#e37368b1e863b7629c43c5a323625f95cf24b119"
-  integrity sha512-/b3jarXkH8KJoOMQc3uVGHASwGLPq3gSFJ7tgJm2diza+bydJPTGOibin2steecKeOylE8oY2JERlVWkAJO6yw==
-
 get-repo@^1.0.0:
   version "1.0.0"
   resolved "https://registry.npmjs.org/get-repo/-/get-repo-1.0.0.tgz#b14624bba917b677397d00feed98dd316a21b140"
@@ -2974,12 +1440,7 @@ get-repo@^1.0.0:
     promise "^6.0.1"
     tar "^1.0.3"
 
-get-stdin@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.npmjs.org/get-stdin/-/get-stdin-4.0.1.tgz#b968c6b0a04384324902e8bf1a5df32579a450fe"
-  integrity sha1-uWjGsKBDhDJJAui/Gl3zJXmkUP4=
-
-get-stream@^4.0.0, get-stream@^4.1.0:
+get-stream@^4.0.0:
   version "4.1.0"
   resolved "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz#c1b255575f3dc21d59bfc79cd3d2b46b1c3a54b5"
   integrity sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==
@@ -2998,75 +1459,6 @@ getpass@^0.1.1:
   dependencies:
     assert-plus "^1.0.0"
 
-git-raw-commits@2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/git-raw-commits/-/git-raw-commits-2.0.0.tgz#d92addf74440c14bcc5c83ecce3fb7f8a79118b5"
-  integrity sha512-w4jFEJFgKXMQJ0H0ikBk2S+4KP2VEjhCvLCNqbNRQC8BgGWgLKNCO7a9K9LI+TVT7Gfoloje502sEnctibffgg==
-  dependencies:
-    dargs "^4.0.1"
-    lodash.template "^4.0.2"
-    meow "^4.0.0"
-    split2 "^2.0.0"
-    through2 "^2.0.0"
-
-git-remote-origin-url@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/git-remote-origin-url/-/git-remote-origin-url-2.0.0.tgz#5282659dae2107145a11126112ad3216ec5fa65f"
-  integrity sha1-UoJlna4hBxRaERJhEq0yFuxfpl8=
-  dependencies:
-    gitconfiglocal "^1.0.0"
-    pify "^2.3.0"
-
-git-semver-tags@^2.0.3:
-  version "2.0.3"
-  resolved "https://registry.npmjs.org/git-semver-tags/-/git-semver-tags-2.0.3.tgz#48988a718acf593800f99622a952a77c405bfa34"
-  integrity sha512-tj4FD4ww2RX2ae//jSrXZzrocla9db5h0V7ikPl1P/WwoZar9epdUhwR7XHXSgc+ZkNq72BEEerqQuicoEQfzA==
-  dependencies:
-    meow "^4.0.0"
-    semver "^6.0.0"
-
-git-up@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.npmjs.org/git-up/-/git-up-4.0.1.tgz#cb2ef086653640e721d2042fe3104857d89007c0"
-  integrity sha512-LFTZZrBlrCrGCG07/dm1aCjjpL1z9L3+5aEeI9SBhAqSc+kiA9Or1bgZhQFNppJX6h/f5McrvJt1mQXTFm6Qrw==
-  dependencies:
-    is-ssh "^1.3.0"
-    parse-url "^5.0.0"
-
-git-url-parse@^11.1.2:
-  version "11.1.2"
-  resolved "https://registry.npmjs.org/git-url-parse/-/git-url-parse-11.1.2.tgz#aff1a897c36cc93699270587bea3dbcbbb95de67"
-  integrity sha512-gZeLVGY8QVKMIkckncX+iCq2/L8PlwncvDFKiWkBn9EtCfYDbliRTTp6qzyQ1VMdITUfq7293zDzfpjdiGASSQ==
-  dependencies:
-    git-up "^4.0.0"
-
-gitconfiglocal@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/gitconfiglocal/-/gitconfiglocal-1.0.0.tgz#41d045f3851a5ea88f03f24ca1c6178114464b9b"
-  integrity sha1-QdBF84UaXqiPA/JMocYXgRRGS5s=
-  dependencies:
-    ini "^1.3.2"
-
-glob-parent@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-3.1.0.tgz#9e6af6299d8d3bd2bd40430832bd113df906c5ae"
-  integrity sha1-nmr2KZ2NO9K9QEMIMr0RPfkGxa4=
-  dependencies:
-    is-glob "^3.1.0"
-    path-dirname "^1.0.0"
-
-glob-parent@^5.0.0:
-  version "5.1.0"
-  resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.0.tgz#5f4c1d1e748d30cd73ad2944b3577a81b081e8c2"
-  integrity sha512-qjtRgnIVmOfnKUE3NJAQEdk+lKrxfw8t5ke7SXtfMTHcjsBfOfWXCQfdb30zfDoZQ2IRSIiidmjtbHZPZ++Ihw==
-  dependencies:
-    is-glob "^4.0.1"
-
-glob-to-regexp@^0.3.0:
-  version "0.3.0"
-  resolved "https://registry.npmjs.org/glob-to-regexp/-/glob-to-regexp-0.3.0.tgz#8c5a1494d2066c570cc3bfe4496175acc4d502ab"
-  integrity sha1-jFoUlNIGbFcMw7/kSWF1rMTVAqs=
-
 glob@7.0.x:
   version "7.0.6"
   resolved "https://registry.npmjs.org/glob/-/glob-7.0.6.tgz#211bafaf49e525b8cd93260d14ab136152b3f57a"
@@ -3079,7 +1471,7 @@ glob@7.0.x:
     once "^1.3.0"
     path-is-absolute "^1.0.0"
 
-glob@^7.1.1, glob@^7.1.2, glob@^7.1.3, glob@^7.1.4:
+glob@^7.1.1, glob@^7.1.2, glob@^7.1.3:
   version "7.1.6"
   resolved "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz#141f33b81a7c2492e125594307480c46679278a6"
   integrity sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==
@@ -3096,21 +1488,7 @@ globals@^11.1.0:
   resolved "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e"
   integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==
 
-globby@^9.2.0:
-  version "9.2.0"
-  resolved "https://registry.npmjs.org/globby/-/globby-9.2.0.tgz#fd029a706c703d29bdd170f4b6db3a3f7a7cb63d"
-  integrity sha512-ollPHROa5mcxDEkwg6bPt3QbEf4pDQSNtd6JPL1YvOvAo/7/0VAm9TccUeoTmarjPw4pfUthSCqcyfNB1I3ZSg==
-  dependencies:
-    "@types/glob" "^7.1.1"
-    array-union "^1.0.2"
-    dir-glob "^2.2.2"
-    fast-glob "^2.2.6"
-    glob "^7.1.3"
-    ignore "^4.0.3"
-    pify "^4.0.1"
-    slash "^2.0.0"
-
-graceful-fs@^4.1.11, graceful-fs@^4.1.15, graceful-fs@^4.1.2, graceful-fs@^4.1.6, graceful-fs@^4.2.0, graceful-fs@^4.2.2:
+graceful-fs@^4.1.11, graceful-fs@^4.1.15, graceful-fs@^4.1.2:
   version "4.2.3"
   resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.3.tgz#4a12ff1b60376ef09862c2093edd908328be8423"
   integrity sha512-a30VEBm4PEdx1dRB7MFK7BejejvCvBronbLjht+sHuGYj8PHs7M/5Z+rt5lw551vZ7yfTCj4Vuyy3mSJytDWRQ==
@@ -3120,17 +1498,6 @@ growly@^1.3.0:
   resolved "https://registry.npmjs.org/growly/-/growly-1.3.0.tgz#f10748cbe76af964b7c96c93c6bcc28af120c081"
   integrity sha1-8QdIy+dq+WS3yWyTxrzCivEgwIE=
 
-handlebars@^4.4.0:
-  version "4.7.3"
-  resolved "https://registry.npmjs.org/handlebars/-/handlebars-4.7.3.tgz#8ece2797826886cf8082d1726ff21d2a022550ee"
-  integrity sha512-SRGwSYuNfx8DwHD/6InAPzD6RgeruWLT+B8e8a7gGs8FWgHzlExpTFMEq2IA6QpAfOClpKHy6+8IqTjeBCu6Kg==
-  dependencies:
-    neo-async "^2.6.0"
-    optimist "^0.6.1"
-    source-map "^0.6.1"
-  optionalDependencies:
-    uglify-js "^3.1.4"
-
 har-schema@^1.0.5:
   version "1.0.5"
   resolved "https://registry.npmjs.org/har-schema/-/har-schema-1.0.5.tgz#d263135f43307c02c602afc8fe95970c0151369e"
@@ -3167,11 +1534,6 @@ has-symbols@^1.0.0, has-symbols@^1.0.1:
   resolved "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.1.tgz#9f5214758a44196c406d9bd76cebf81ec2dd31e8"
   integrity sha512-PLcsoqu++dmEIZB+6totNFKq/7Do+Z0u4oT0zKOJNl3lYK6vGwwu2hjHs+68OEZbTjiUE9bgOABXbP/GvrS0Kg==
 
-has-unicode@^2.0.0, has-unicode@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz#e0e6fe6a28cf51138855e086d1691e771de2a8b9"
-  integrity sha1-4Ob+aijPUROIVeCG0Wkedx3iqLk=
-
 has-value@^0.3.1:
   version "0.3.1"
   resolved "https://registry.npmjs.org/has-value/-/has-value-0.3.1.tgz#7b1f58bada62ca827ec0a2078025654845995e1f"
@@ -3225,7 +1587,7 @@ hoek@2.x.x:
   resolved "https://registry.npmjs.org/hoek/-/hoek-2.16.3.tgz#20bb7403d3cea398e91dc4710a8ff1b8274a25ed"
   integrity sha1-ILt0A9POo5jpHcRxCo/xuCdKJe0=
 
-hosted-git-info@^2.1.4, hosted-git-info@^2.7.1:
+hosted-git-info@^2.1.4:
   version "2.8.8"
   resolved "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.8.tgz#7539bd4bc1e0e0a895815a2e0262420b12858488"
   integrity sha512-f/wzC2QaWBs7t9IYqB4T3sR1xviIViXJRJTWBlx2Gf3g0Xi5vI7Yy4koXQ1c9OYDGHN9sBy1DQ2AB8fqZBWhUg==
@@ -3250,19 +1612,6 @@ http-basic@^1.1.0:
     concat-stream "^1.4.6"
     http-response-object "^1.0.0"
 
-http-cache-semantics@^3.8.1:
-  version "3.8.1"
-  resolved "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-3.8.1.tgz#39b0e16add9b605bf0a9ef3d9daaf4843b4cacd2"
-  integrity sha512-5ai2iksyV8ZXmnZhHH4rWPoxxistEexSi5936zIQ1bnNTW5VnA85B6P/VpXiRM017IgRvb2kKo1a//y+0wSp3w==
-
-http-proxy-agent@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-2.1.0.tgz#e4821beef5b2142a2026bd73926fe537631c5405"
-  integrity sha512-qwHbBLV7WviBl0rQsOzH6o5lwyOIvwp/BdFnvVxXORldu5TmjFfjzBcWUWS5kWAZhmv+JtiDhSuQCp4sBfbIgg==
-  dependencies:
-    agent-base "4"
-    debug "3.1.0"
-
 http-response-object@^1.0.0:
   version "1.1.0"
   resolved "https://registry.npmjs.org/http-response-object/-/http-response-object-1.1.0.tgz#a7c4e75aae82f3bb4904e4f43f615673b4d518c3"
@@ -3286,58 +1635,18 @@ http-signature@~1.2.0:
     jsprim "^1.2.2"
     sshpk "^1.7.0"
 
-https-proxy-agent@^2.2.3:
-  version "2.2.4"
-  resolved "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-2.2.4.tgz#4ee7a737abd92678a293d9b34a1af4d0d08c787b"
-  integrity sha512-OmvfoQ53WLjtA9HeYP9RNrWMJzzAz1JGaSFr1nijg0PVR1JaD/xbJq1mdEIIlxGpXp9eSe/O2LgU9DJmTPd0Eg==
-  dependencies:
-    agent-base "^4.3.0"
-    debug "^3.1.0"
-
-humanize-ms@^1.2.1:
-  version "1.2.1"
-  resolved "https://registry.npmjs.org/humanize-ms/-/humanize-ms-1.2.1.tgz#c46e3159a293f6b896da29316d8b6fe8bb79bbed"
-  integrity sha1-xG4xWaKT9riW2ikxbYtv6Lt5u+0=
-  dependencies:
-    ms "^2.0.0"
-
-iconv-lite@0.4.24, iconv-lite@^0.4.24, iconv-lite@~0.4.13:
+iconv-lite@0.4.24:
   version "0.4.24"
   resolved "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b"
   integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==
   dependencies:
     safer-buffer ">= 2.1.2 < 3"
 
-iferr@^0.1.5:
-  version "0.1.5"
-  resolved "https://registry.npmjs.org/iferr/-/iferr-0.1.5.tgz#c60eed69e6d8fdb6b3104a1fcbca1c192dc5b501"
-  integrity sha1-xg7taebY/bazEEofy8ocGS3FtQE=
-
-ignore-walk@^3.0.1:
-  version "3.0.3"
-  resolved "https://registry.npmjs.org/ignore-walk/-/ignore-walk-3.0.3.tgz#017e2447184bfeade7c238e4aefdd1e8f95b1e37"
-  integrity sha512-m7o6xuOaT1aqheYHKf8W6J5pYH85ZI9w077erOzLje3JsB1gkafkAhHHY19dqjulgIZHFm32Cp5uNZgcQqdJKw==
-  dependencies:
-    minimatch "^3.0.4"
-
-ignore@^4.0.3:
-  version "4.0.6"
-  resolved "https://registry.npmjs.org/ignore/-/ignore-4.0.6.tgz#750e3db5862087b4737ebac8207ffd1ef27b25fc"
-  integrity sha512-cyFDKrqc/YdcWFniJhzI42+AzS+gNwmUzOSFcRCQYwySuBBBy/KjuxWLZ/FHEH6Moq1NizMOBWyTcv8O4OZIMg==
-
 image-size@~0.5.0:
   version "0.5.5"
   resolved "https://registry.npmjs.org/image-size/-/image-size-0.5.5.tgz#09dfd4ab9d20e29eb1c3e80b8990378df9e3cb9c"
   integrity sha1-Cd/Uq50g4p6xw+gLiZA3jfnjy5w=
 
-import-fresh@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/import-fresh/-/import-fresh-2.0.0.tgz#d81355c15612d386c61f9ddd3922d4304822a546"
-  integrity sha1-2BNVwVYS04bGH53dOSLUMEgipUY=
-  dependencies:
-    caller-path "^2.0.0"
-    resolve-from "^3.0.0"
-
 import-local@^2.0.0:
   version "2.0.0"
   resolved "https://registry.npmjs.org/import-local/-/import-local-2.0.0.tgz#55070be38a5993cf18ef6db7e961f5bee5c5a09d"
@@ -3351,23 +1660,6 @@ imurmurhash@^0.1.4:
   resolved "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea"
   integrity sha1-khi5srkoojixPcT7a21XbyMUU+o=
 
-indent-string@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/indent-string/-/indent-string-2.1.0.tgz#8e2d48348742121b4a8218b7a137e9a52049dc80"
-  integrity sha1-ji1INIdCEhtKghi3oTfppSBJ3IA=
-  dependencies:
-    repeating "^2.0.0"
-
-indent-string@^3.0.0:
-  version "3.2.0"
-  resolved "https://registry.npmjs.org/indent-string/-/indent-string-3.2.0.tgz#4a5fd6d27cc332f37e5419a504dbb837105c9289"
-  integrity sha1-Sl/W0nzDMvN+VBmlBNu4NxBckok=
-
-infer-owner@^1.0.3, infer-owner@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.npmjs.org/infer-owner/-/infer-owner-1.0.4.tgz#c4cefcaa8e51051c2a40ba2ce8a3d27295af9467"
-  integrity sha512-IClj+Xz94+d7irH5qRyfJonOdfTzuDaifE6ZPWfx0N0+/ATZCbuTPq2prFl526urkQd90WyUKIh1DfBQ2hMz9A==
-
 inflight@^1.0.4:
   version "1.0.6"
   resolved "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
@@ -3376,48 +1668,10 @@ inflight@^1.0.4:
     once "^1.3.0"
     wrappy "1"
 
-inherits@2, inherits@^2.0.1, inherits@^2.0.3, inherits@~2.0.0, inherits@~2.0.3:
-  version "2.0.4"
-  resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
-  integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
-
-ini@^1.3.2, ini@^1.3.4:
-  version "1.3.5"
-  resolved "https://registry.npmjs.org/ini/-/ini-1.3.5.tgz#eee25f56db1c9ec6085e0c22778083f596abf927"
-  integrity sha512-RZY5huIKCMRWDUqZlEi72f/lmXKMvuszcMBduliQ3nnWbx9X/ZBQO7DijMEYS9EhHBb2qacRUMtC7svLwe0lcw==
-
-init-package-json@^1.10.3:
-  version "1.10.3"
-  resolved "https://registry.npmjs.org/init-package-json/-/init-package-json-1.10.3.tgz#45ffe2f610a8ca134f2bd1db5637b235070f6cbe"
-  integrity sha512-zKSiXKhQveNteyhcj1CoOP8tqp1QuxPIPBl8Bid99DGLFqA1p87M6lNgfjJHSBoWJJlidGOv5rWjyYKEB3g2Jw==
-  dependencies:
-    glob "^7.1.1"
-    npm-package-arg "^4.0.0 || ^5.0.0 || ^6.0.0"
-    promzard "^0.3.0"
-    read "~1.0.1"
-    read-package-json "1 || 2"
-    semver "2.x || 3.x || 4 || 5"
-    validate-npm-package-license "^3.0.1"
-    validate-npm-package-name "^3.0.0"
-
-inquirer@^6.2.0:
-  version "6.5.2"
-  resolved "https://registry.npmjs.org/inquirer/-/inquirer-6.5.2.tgz#ad50942375d036d327ff528c08bd5fab089928ca"
-  integrity sha512-cntlB5ghuB0iuO65Ovoi8ogLHiWGs/5yNrtUcKjFhSSiVeAIVpD7koaSU9RM8mpXw5YDi9RdYXGQMaOURB7ycQ==
-  dependencies:
-    ansi-escapes "^3.2.0"
-    chalk "^2.4.2"
-    cli-cursor "^2.1.0"
-    cli-width "^2.0.0"
-    external-editor "^3.0.3"
-    figures "^2.0.0"
-    lodash "^4.17.12"
-    mute-stream "0.0.7"
-    run-async "^2.2.0"
-    rxjs "^6.4.0"
-    string-width "^2.1.0"
-    strip-ansi "^5.1.0"
-    through "^2.3.6"
+inherits@2, inherits@^2.0.3, inherits@~2.0.0, inherits@~2.0.3:
+  version "2.0.4"
+  resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
+  integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
 
 invariant@^2.2.4:
   version "2.2.4"
@@ -3426,10 +1680,10 @@ invariant@^2.2.4:
   dependencies:
     loose-envify "^1.0.0"
 
-ip@1.1.5:
-  version "1.1.5"
-  resolved "https://registry.npmjs.org/ip/-/ip-1.1.5.tgz#bdded70114290828c0a039e72ef25f5aaec4354a"
-  integrity sha1-vd7XARQpCCjAoDnnLvJfWq7ENUo=
+invert-kv@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/invert-kv/-/invert-kv-2.0.0.tgz#7393f5afa59ec9ff5f67a27620d11c226e3eec02"
+  integrity sha512-wPVv/y/QQ/Uiirj/vh3oP+1Ww+AWehmi1g5fFWGPF6IpCBCDVrhgHRMvrLfdYcwDh3QJbGXDW4JAuzxElLSqKA==
 
 is-accessor-descriptor@^0.1.6:
   version "0.1.6"
@@ -3504,11 +1758,6 @@ is-descriptor@^1.0.0, is-descriptor@^1.0.2:
     is-data-descriptor "^1.0.0"
     kind-of "^6.0.2"
 
-is-directory@^0.3.1:
-  version "0.3.1"
-  resolved "https://registry.npmjs.org/is-directory/-/is-directory-0.3.1.tgz#61339b6f2475fc772fd9c9d83f5c8575dc154ae1"
-  integrity sha1-YTObbyR1/Hcv2cnYP1yFddwVSuE=
-
 is-expression@^3.0.0:
   version "3.0.0"
   resolved "https://registry.npmjs.org/is-expression/-/is-expression-3.0.0.tgz#39acaa6be7fd1f3471dc42c7416e61c24317ac9f"
@@ -3522,26 +1771,16 @@ is-extendable@^0.1.0, is-extendable@^0.1.1:
   resolved "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89"
   integrity sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=
 
-is-extendable@^1.0.0, is-extendable@^1.0.1:
+is-extendable@^1.0.1:
   version "1.0.1"
   resolved "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz#a7470f9e426733d81bd81e1155264e3a3507cab4"
   integrity sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==
   dependencies:
     is-plain-object "^2.0.4"
 
-is-extglob@^2.1.0, is-extglob@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2"
-  integrity sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=
-
-is-finite@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/is-finite/-/is-finite-1.1.0.tgz#904135c77fb42c0641d6aa1bcdbc4daa8da082f3"
-  integrity sha512-cdyMtqX/BOqqNBBiKlIVkytNHm49MtMlYyn1zxzvJKWmFMlGzm+ry5BBfYyeY9YmNKbRSo/o7OX9w9ale0wg3w==
-
 is-fullwidth-code-point@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz#ef9e31386f031a7f0d643af82fde50c457ef00cb"
+  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz#ef9e31386f031a7f0d643af82fde50c457ef00cb"
   integrity sha1-754xOG8DGn8NZDr4L95QxFfvAMs=
   dependencies:
     number-is-nan "^1.0.0"
@@ -3556,20 +1795,6 @@ is-generator-fn@^2.0.0:
   resolved "https://registry.npmjs.org/is-generator-fn/-/is-generator-fn-2.1.0.tgz#7d140adc389aaf3011a8f2a2a4cfa6faadffb118"
   integrity sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==
 
-is-glob@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/is-glob/-/is-glob-3.1.0.tgz#7ba5ae24217804ac70707b96922567486cc3e84a"
-  integrity sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=
-  dependencies:
-    is-extglob "^2.1.0"
-
-is-glob@^4.0.0, is-glob@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.npmjs.org/is-glob/-/is-glob-4.0.1.tgz#7567dbe9f2f5e2467bc77ab83c4a29482407a5dc"
-  integrity sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==
-  dependencies:
-    is-extglob "^2.1.1"
-
 is-number@^3.0.0:
   version "3.0.0"
   resolved "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz#24fd6201a4782cf50561c810276afc7d12d71195"
@@ -3577,16 +1802,6 @@ is-number@^3.0.0:
   dependencies:
     kind-of "^3.0.2"
 
-is-obj@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/is-obj/-/is-obj-1.0.1.tgz#3e4729ac1f5fde025cd7d83a896dab9f4f67db0f"
-  integrity sha1-PkcprB9f3gJc19g6iW2rn09n2w8=
-
-is-plain-obj@^1.0.0, is-plain-obj@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-1.1.0.tgz#71a50c8429dfca773c92a390a4a03b39fcd51d3e"
-  integrity sha1-caUMhCnfync8kqOQpKA7OfzVHT4=
-
 is-plain-object@^2.0.3, is-plain-object@^2.0.4:
   version "2.0.4"
   resolved "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz#2c163b3fafb1b606d9d17928f05c2a1c38e07677"
@@ -3594,14 +1809,7 @@ is-plain-object@^2.0.3, is-plain-object@^2.0.4:
   dependencies:
     isobject "^3.0.1"
 
-is-plain-object@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/is-plain-object/-/is-plain-object-3.0.0.tgz#47bfc5da1b5d50d64110806c199359482e75a928"
-  integrity sha512-tZIpofR+P05k8Aocp7UI/2UTa9lTJSebCXpFFoR9aibpokDj/uXBsJ8luUu0tTVYKkMU6URDUuOfJZ7koewXvg==
-  dependencies:
-    isobject "^4.0.0"
-
-is-promise@^2.0.0, is-promise@^2.1.0:
+is-promise@^2.0.0:
   version "2.1.0"
   resolved "https://registry.npmjs.org/is-promise/-/is-promise-2.1.0.tgz#79a2a9ece7f096e80f36d2b2f3bc16c1ff4bf3fa"
   integrity sha1-eaKp7OfwlugPNtKy87wWwf9L8/o=
@@ -3613,13 +1821,6 @@ is-regex@^1.0.3, is-regex@^1.0.5:
   dependencies:
     has "^1.0.3"
 
-is-ssh@^1.3.0:
-  version "1.3.1"
-  resolved "https://registry.npmjs.org/is-ssh/-/is-ssh-1.3.1.tgz#f349a8cadd24e65298037a522cf7520f2e81a0f3"
-  integrity sha512-0eRIASHZt1E68/ixClI8bp2YK2wmBPVWEismTs6M+M099jKgrzl/3E976zIbImSIob48N2/XGe9y7ZiYdImSlg==
-  dependencies:
-    protocols "^1.1.0"
-
 is-stream@^1.1.0:
   version "1.1.0"
   resolved "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz#12d4a3dd4e68e0b79ceb8dbc84173ae80d91ca44"
@@ -3632,24 +1833,12 @@ is-symbol@^1.0.2:
   dependencies:
     has-symbols "^1.0.1"
 
-is-text-path@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/is-text-path/-/is-text-path-1.0.1.tgz#4e1aa0fb51bfbcb3e92688001397202c1775b66e"
-  integrity sha1-Thqg+1G/vLPpJogAE5cgLBd1tm4=
-  dependencies:
-    text-extensions "^1.0.0"
-
 is-typedarray@~1.0.0:
   version "1.0.0"
   resolved "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a"
   integrity sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=
 
-is-utf8@^0.2.0:
-  version "0.2.1"
-  resolved "https://registry.npmjs.org/is-utf8/-/is-utf8-0.2.1.tgz#4b0da1442104d1b336340e80797e865cf39f7d72"
-  integrity sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=
-
-is-windows@^1.0.0, is-windows@^1.0.2:
+is-windows@^1.0.2:
   version "1.0.2"
   resolved "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz#d1850eb9791ecd18e6182ce12a30f396634bb19d"
   integrity sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==
@@ -3681,11 +1870,6 @@ isobject@^3.0.0, isobject@^3.0.1:
   resolved "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz#4e431e92b11a9731636aa1f9c8d1ccbcfdab78df"
   integrity sha1-TkMekrEalzFjaqH5yNHMvP2reN8=
 
-isobject@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/isobject/-/isobject-4.0.0.tgz#3f1c9155e73b192022a80819bacd0343711697b0"
-  integrity sha512-S/2fF5wH8SJA/kmwr6HYhK/RI/OkhD84k8ntalo0iJjZikgq1XFvR5M8NPT1x5F7fBwCG3qHfnzeP/Vh/ZxCUA==
-
 isstream@~0.1.2:
   version "0.1.2"
   resolved "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz#47e63f7af55afa6f92e1500e690eb8b8529c099a"
@@ -4150,7 +2334,7 @@ jsesc@^2.5.1:
   resolved "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz#80564d2e483dacf6e8ef209650a67df3f0c283a4"
   integrity sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==
 
-json-parse-better-errors@^1.0.0, json-parse-better-errors@^1.0.1:
+json-parse-better-errors@^1.0.1:
   version "1.0.2"
   resolved "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz#bb867cfb3450e69107c131d1c514bab3dc8bcaa9"
   integrity sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==
@@ -4172,7 +2356,7 @@ json-stable-stringify@^1.0.1:
   dependencies:
     jsonify "~0.0.0"
 
-json-stringify-safe@^5.0.1, json-stringify-safe@~5.0.1:
+json-stringify-safe@~5.0.1:
   version "5.0.1"
   resolved "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz#1296a2d58fd45f19a0f6ce01d65701e2c735b6eb"
   integrity sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=
@@ -4184,23 +2368,11 @@ json5@^2.1.0:
   dependencies:
     minimist "^1.2.5"
 
-jsonfile@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz#8771aae0799b64076b76640fca058f9c10e33ecb"
-  integrity sha1-h3Gq4HmbZAdrdmQPygWPnBDjPss=
-  optionalDependencies:
-    graceful-fs "^4.1.6"
-
 jsonify@~0.0.0:
   version "0.0.0"
   resolved "https://registry.npmjs.org/jsonify/-/jsonify-0.0.0.tgz#2c74b6ee41d93ca51b7b5aaee8f503631d252a73"
   integrity sha1-LHS27kHZPKUbe1qu6PUDYx0lKnM=
 
-jsonparse@^1.2.0:
-  version "1.3.1"
-  resolved "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz#3f4dae4a91fac315f71062f8521cc239f1366280"
-  integrity sha1-P02uSpH6wxX3EGL4UhzCOfE2YoA=
-
 jsprim@^1.2.2:
   version "1.4.1"
   resolved "https://registry.npmjs.org/jsprim/-/jsprim-1.4.1.tgz#313e66bc1e5cc06e438bc1b7499c2e5c56acb6a2"
@@ -4233,7 +2405,7 @@ jstransformer-less@^2.1.0, jstransformer-less@^2.3.0:
     less-plugin-inline-urls "^1.1.0"
     less-plugin-npm-import "^2.0.0"
 
-jstransformer-markdown-it@2.0.0, jstransformer-markdown-it@^2.0.0:
+jstransformer-markdown-it@^2.0.0:
   version "2.0.0"
   resolved "https://registry.npmjs.org/jstransformer-markdown-it/-/jstransformer-markdown-it-2.0.0.tgz#8b44aedbc9465dc935d280be90339b671c16ceb8"
   integrity sha1-i0Su28lGXck10oC+kDObZxwWzrg=
@@ -4302,6 +2474,13 @@ lazy-cache@^1.0.3:
   resolved "https://registry.npmjs.org/lazy-cache/-/lazy-cache-1.0.4.tgz#a1d78fc3a50474cb80845d3b3b6e1da49a446e8e"
   integrity sha1-odePw6UEdMuAhF07O24dpJpEbo4=
 
+lcid@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/lcid/-/lcid-2.0.0.tgz#6ef5d2df60e52f82eb228a4c373e8d1f397253cf"
+  integrity sha512-avPEb8P8EGnwXKClwsNUgryVjllcRqtMYa49NTsbQagYuT1DcXnl1915oxWjoyGrXR6zH/Y0Zc96xWsPcoDKeA==
+  dependencies:
+    invert-kv "^2.0.0"
+
 lcov-parse@^1.0.0:
   version "1.0.0"
   resolved "https://registry.npmjs.org/lcov-parse/-/lcov-parse-1.0.0.tgz#eb0d46b54111ebc561acb4c408ef9363bdc8f7e0"
@@ -4312,30 +2491,6 @@ left-pad@^1.3.0:
   resolved "https://registry.npmjs.org/left-pad/-/left-pad-1.3.0.tgz#5b8a3a7765dfe001261dde915589e782f8c94d1e"
   integrity sha512-XI5MPzVNApjAyhQzphX8BkmKsKUxD4LdyK24iZeQGinBN9yTQT3bFlCBy/aVx2HrNcqQGsdot8ghrjyrvMCoEA==
 
-lerna@3.20.2:
-  version "3.20.2"
-  resolved "https://registry.npmjs.org/lerna/-/lerna-3.20.2.tgz#abf84e73055fe84ee21b46e64baf37b496c24864"
-  integrity sha512-bjdL7hPLpU3Y8CBnw/1ys3ynQMUjiK6l9iDWnEGwFtDy48Xh5JboR9ZJwmKGCz9A/sarVVIGwf1tlRNKUG9etA==
-  dependencies:
-    "@lerna/add" "3.20.0"
-    "@lerna/bootstrap" "3.20.0"
-    "@lerna/changed" "3.20.0"
-    "@lerna/clean" "3.20.0"
-    "@lerna/cli" "3.18.5"
-    "@lerna/create" "3.18.5"
-    "@lerna/diff" "3.18.5"
-    "@lerna/exec" "3.20.0"
-    "@lerna/import" "3.18.5"
-    "@lerna/info" "3.20.0"
-    "@lerna/init" "3.18.5"
-    "@lerna/link" "3.18.5"
-    "@lerna/list" "3.20.0"
-    "@lerna/publish" "3.20.2"
-    "@lerna/run" "3.20.0"
-    "@lerna/version" "3.20.2"
-    import-local "^2.0.0"
-    npmlog "^4.1.2"
-
 less-plugin-inline-urls@^1.1.0:
   version "1.2.0"
   resolved "https://registry.npmjs.org/less-plugin-inline-urls/-/less-plugin-inline-urls-1.2.0.tgz#5ddab07a0c2571f1a2855cf929ddc9efc1e38acc"
@@ -4388,17 +2543,6 @@ linkify-it@^2.0.0:
   dependencies:
     uc.micro "^1.0.1"
 
-load-json-file@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/load-json-file/-/load-json-file-1.1.0.tgz#956905708d58b4bab4c2261b04f59f31c99374c0"
-  integrity sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA=
-  dependencies:
-    graceful-fs "^4.1.2"
-    parse-json "^2.2.0"
-    pify "^2.0.0"
-    pinkie-promise "^2.0.0"
-    strip-bom "^2.0.0"
-
 load-json-file@^4.0.0:
   version "4.0.0"
   resolved "https://registry.npmjs.org/load-json-file/-/load-json-file-4.0.0.tgz#2f5f45ab91e33216234fd53adab668eb4ec0993b"
@@ -4409,20 +2553,9 @@ load-json-file@^4.0.0:
     pify "^3.0.0"
     strip-bom "^3.0.0"
 
-load-json-file@^5.3.0:
-  version "5.3.0"
-  resolved "https://registry.npmjs.org/load-json-file/-/load-json-file-5.3.0.tgz#4d3c1e01fa1c03ea78a60ac7af932c9ce53403f3"
-  integrity sha512-cJGP40Jc/VXUsp8/OrnyKyTZ1y6v/dphm3bioS+RrKXjK2BB6wHUd6JptZEFDGgGahMT+InnZO5i1Ei9mpC8Bw==
-  dependencies:
-    graceful-fs "^4.1.15"
-    parse-json "^4.0.0"
-    pify "^4.0.1"
-    strip-bom "^3.0.0"
-    type-fest "^0.3.0"
-
 locate-path@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz#2b568b265eec944c6d9c0de9c3dbbbca0354cd8e"
+  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-2.0.0.tgz#2b568b265eec944c6d9c0de9c3dbbbca0354cd8e"
   integrity sha1-K1aLJl7slExtnA3pw9u7ygNUzY4=
   dependencies:
     p-locate "^2.0.0"
@@ -4436,62 +2569,17 @@ locate-path@^3.0.0:
     p-locate "^3.0.0"
     path-exists "^3.0.0"
 
-lodash._reinterpolate@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/lodash._reinterpolate/-/lodash._reinterpolate-3.0.0.tgz#0ccf2d89166af03b3663c796538b75ac6e114d9d"
-  integrity sha1-DM8tiRZq8Ds2Y8eWU4t1rG4RTZ0=
-
 lodash.clone@^4.5.0:
   version "4.5.0"
   resolved "https://registry.npmjs.org/lodash.clone/-/lodash.clone-4.5.0.tgz#195870450f5a13192478df4bc3d23d2dea1907b6"
   integrity sha1-GVhwRQ9aExkkeN9Lw9I9LeoZB7Y=
 
-lodash.clonedeep@^4.5.0:
-  version "4.5.0"
-  resolved "https://registry.npmjs.org/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz#e23f3f9c4f8fbdde872529c1071857a086e5ccef"
-  integrity sha1-4j8/nE+Pvd6HJSnBBxhXoIblzO8=
-
-lodash.get@^4.4.2:
-  version "4.4.2"
-  resolved "https://registry.npmjs.org/lodash.get/-/lodash.get-4.4.2.tgz#2d177f652fa31e939b4438d5341499dfa3825e99"
-  integrity sha1-LRd/ZS+jHpObRDjVNBSZ36OCXpk=
-
-lodash.ismatch@^4.4.0:
-  version "4.4.0"
-  resolved "https://registry.npmjs.org/lodash.ismatch/-/lodash.ismatch-4.4.0.tgz#756cb5150ca3ba6f11085a78849645f188f85f37"
-  integrity sha1-dWy1FQyjum8RCFp4hJZF8Yj4Xzc=
-
-lodash.set@^4.3.2:
-  version "4.3.2"
-  resolved "https://registry.npmjs.org/lodash.set/-/lodash.set-4.3.2.tgz#d8757b1da807dde24816b0d6a84bea1a76230b23"
-  integrity sha1-2HV7HagH3eJIFrDWqEvqGnYjCyM=
-
 lodash.sortby@^4.7.0:
   version "4.7.0"
   resolved "https://registry.npmjs.org/lodash.sortby/-/lodash.sortby-4.7.0.tgz#edd14c824e2cc9c1e0b0a1b42bb5210516a42438"
   integrity sha1-7dFMgk4sycHgsKG0K7UhBRakJDg=
 
-lodash.template@^4.0.2, lodash.template@^4.5.0:
-  version "4.5.0"
-  resolved "https://registry.npmjs.org/lodash.template/-/lodash.template-4.5.0.tgz#f976195cf3f347d0d5f52483569fe8031ccce8ab"
-  integrity sha512-84vYFxIkmidUiFxidA/KjjH9pAycqW+h980j7Fuz5qxRtO9pgB7MDFTdys1N7A5mcucRiDyEq4fusljItR1T/A==
-  dependencies:
-    lodash._reinterpolate "^3.0.0"
-    lodash.templatesettings "^4.0.0"
-
-lodash.templatesettings@^4.0.0:
-  version "4.2.0"
-  resolved "https://registry.npmjs.org/lodash.templatesettings/-/lodash.templatesettings-4.2.0.tgz#e481310f049d3cf6d47e912ad09313b154f0fb33"
-  integrity sha512-stgLz+i3Aa9mZgnjr/O+v9ruKZsPsndy7qPZOchbqk2cnTU1ZaldKK+v7m54WoKIyxiuMZTKT2H81F8BeAc3ZQ==
-  dependencies:
-    lodash._reinterpolate "^3.0.0"
-
-lodash.uniq@^4.5.0:
-  version "4.5.0"
-  resolved "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz#d0225373aeb652adc1bc82e4945339a842754773"
-  integrity sha1-0CJTc662Uq3BvILklFM5qEJ1R3M=
-
-lodash@^4.17.12, lodash@^4.17.13, lodash@^4.17.15, lodash@^4.17.4, lodash@^4.2.1:
+lodash@^4.17.13, lodash@^4.17.15, lodash@^4.17.4:
   version "4.17.15"
   resolved "https://registry.npmjs.org/lodash/-/lodash-4.17.15.tgz#b447f6670a0455bbfeedd11392eff330ea097548"
   integrity sha512-8xOcRHvCjnocdS5cpwXQXVzmmh5e5+saE2QGoeQmbKmRS6J3VQppPOIt0MnmE+4xlZoumy0GPG0D0MVIQbNA1A==
@@ -4513,33 +2601,6 @@ loose-envify@^1.0.0:
   dependencies:
     js-tokens "^3.0.0 || ^4.0.0"
 
-loud-rejection@^1.0.0:
-  version "1.6.0"
-  resolved "https://registry.npmjs.org/loud-rejection/-/loud-rejection-1.6.0.tgz#5b46f80147edee578870f086d04821cf998e551f"
-  integrity sha1-W0b4AUft7leIcPCG0Eghz5mOVR8=
-  dependencies:
-    currently-unhandled "^0.4.1"
-    signal-exit "^3.0.0"
-
-lru-cache@^5.1.1:
-  version "5.1.1"
-  resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz#1da27e6710271947695daf6848e847f01d84b920"
-  integrity sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==
-  dependencies:
-    yallist "^3.0.2"
-
-macos-release@^2.2.0:
-  version "2.3.0"
-  resolved "https://registry.npmjs.org/macos-release/-/macos-release-2.3.0.tgz#eb1930b036c0800adebccd5f17bc4c12de8bb71f"
-  integrity sha512-OHhSbtcviqMPt7yfw5ef5aghS2jzFVKEFyCJndQt2YpSQ9qRVSEv2axSJI1paVThEu+FFGs584h/1YhxjVqajA==
-
-make-dir@^1.0.0:
-  version "1.3.0"
-  resolved "https://registry.npmjs.org/make-dir/-/make-dir-1.3.0.tgz#79c1033b80515bd6d24ec9933e860ca75ee27f0c"
-  integrity sha512-2w31R7SJtieJJnQtGc7RVL2StM2vGYVfqUOvUDxH6bC6aJTxPxTF0GnIgCyu7tjockiUWAYQRbxa7vKn34s5sQ==
-  dependencies:
-    pify "^3.0.0"
-
 make-dir@^2.1.0:
   version "2.1.0"
   resolved "https://registry.npmjs.org/make-dir/-/make-dir-2.1.0.tgz#5f0310e18b8be898cc07009295a30ae41e91e6f5"
@@ -4548,23 +2609,6 @@ make-dir@^2.1.0:
     pify "^4.0.1"
     semver "^5.6.0"
 
-make-fetch-happen@^5.0.0:
-  version "5.0.2"
-  resolved "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-5.0.2.tgz#aa8387104f2687edca01c8687ee45013d02d19bd"
-  integrity sha512-07JHC0r1ykIoruKO8ifMXu+xEU8qOXDFETylktdug6vJDACnP+HKevOu3PXyNPzFyTSlz8vrBYlBO1JZRe8Cag==
-  dependencies:
-    agentkeepalive "^3.4.1"
-    cacache "^12.0.0"
-    http-cache-semantics "^3.8.1"
-    http-proxy-agent "^2.1.0"
-    https-proxy-agent "^2.2.3"
-    lru-cache "^5.1.1"
-    mississippi "^3.0.0"
-    node-fetch-npm "^2.0.2"
-    promise-retry "^1.1.1"
-    socks-proxy-agent "^4.0.0"
-    ssri "^6.0.0"
-
 makeerror@1.0.x:
   version "1.0.11"
   resolved "https://registry.npmjs.org/makeerror/-/makeerror-1.0.11.tgz#e01a5c9109f2af79660e4e8b9587790184f5a96c"
@@ -4572,21 +2616,18 @@ makeerror@1.0.x:
   dependencies:
     tmpl "1.0.x"
 
+map-age-cleaner@^0.1.1:
+  version "0.1.3"
+  resolved "https://registry.yarnpkg.com/map-age-cleaner/-/map-age-cleaner-0.1.3.tgz#7d583a7306434c055fe474b0f45078e6e1b4b92a"
+  integrity sha512-bJzx6nMoP6PDLPBFmg7+xRKeFZvFboMrGlxmNj9ClvX53KrmvM5bXFXEWjbz4cz1AFn+jWJ9z/DJSz7hrs0w3w==
+  dependencies:
+    p-defer "^1.0.0"
+
 map-cache@^0.2.2:
   version "0.2.2"
   resolved "https://registry.npmjs.org/map-cache/-/map-cache-0.2.2.tgz#c32abd0bd6525d9b051645bb4f26ac5dc98a0dbf"
   integrity sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8=
 
-map-obj@^1.0.0, map-obj@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/map-obj/-/map-obj-1.0.1.tgz#d933ceb9205d82bdcf4886f6742bdc2b4dea146d"
-  integrity sha1-2TPOuSBdgr3PSIb2dCvcK03qFG0=
-
-map-obj@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/map-obj/-/map-obj-2.0.0.tgz#a65cd29087a92598b8791257a523e021222ac1f9"
-  integrity sha1-plzSkIepJZi4eRJXpSPgISIqwfk=
-
 map-visit@^1.0.0:
   version "1.0.0"
   resolved "https://registry.npmjs.org/map-visit/-/map-visit-1.0.0.tgz#ecdca8f13144e660f1b5bd41f12f3479d98dfb8f"
@@ -4610,62 +2651,20 @@ mdurl@^1.0.1:
   resolved "https://registry.npmjs.org/mdurl/-/mdurl-1.0.1.tgz#fe85b2ec75a59037f2adfec100fd6c601761152e"
   integrity sha1-/oWy7HWlkDfyrf7BAP1sYBdhFS4=
 
-meow@^3.3.0:
-  version "3.7.0"
-  resolved "https://registry.npmjs.org/meow/-/meow-3.7.0.tgz#72cb668b425228290abbfa856892587308a801fb"
-  integrity sha1-cstmi0JSKCkKu/qFaJJYcwioAfs=
-  dependencies:
-    camelcase-keys "^2.0.0"
-    decamelize "^1.1.2"
-    loud-rejection "^1.0.0"
-    map-obj "^1.0.1"
-    minimist "^1.1.3"
-    normalize-package-data "^2.3.4"
-    object-assign "^4.0.1"
-    read-pkg-up "^1.0.1"
-    redent "^1.0.0"
-    trim-newlines "^1.0.0"
-
-meow@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.npmjs.org/meow/-/meow-4.0.1.tgz#d48598f6f4b1472f35bf6317a95945ace347f975"
-  integrity sha512-xcSBHD5Z86zaOc+781KrupuHAzeGXSLtiAOmBsiLDiPSaYSB6hdew2ng9EBAnZ62jagG9MHAOdxpDi/lWBFJ/A==
-  dependencies:
-    camelcase-keys "^4.0.0"
-    decamelize-keys "^1.0.0"
-    loud-rejection "^1.0.0"
-    minimist "^1.1.3"
-    minimist-options "^3.0.1"
-    normalize-package-data "^2.3.4"
-    read-pkg-up "^3.0.0"
-    redent "^2.0.0"
-    trim-newlines "^2.0.0"
-
-meow@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/meow/-/meow-5.0.0.tgz#dfc73d63a9afc714a5e371760eb5c88b91078aa4"
-  integrity sha512-CbTqYU17ABaLefO8vCU153ZZlprKYWDljcndKKDCFcYQITzWCXZAVk4QMFZPgvzrnUQ3uItnIE/LoUOwrT15Ig==
-  dependencies:
-    camelcase-keys "^4.0.0"
-    decamelize-keys "^1.0.0"
-    loud-rejection "^1.0.0"
-    minimist-options "^3.0.1"
-    normalize-package-data "^2.3.4"
-    read-pkg-up "^3.0.0"
-    redent "^2.0.0"
-    trim-newlines "^2.0.0"
-    yargs-parser "^10.0.0"
+mem@^4.0.0:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/mem/-/mem-4.3.0.tgz#461af497bc4ae09608cdb2e60eefb69bff744178"
+  integrity sha512-qX2bG48pTqYRVmDB37rn/6PT7LcR8T7oAX3bf99u1Tt1nzxYfxkgqDwUwolPlXweM0XzBOBFzSx4kfp7KP1s/w==
+  dependencies:
+    map-age-cleaner "^0.1.1"
+    mimic-fn "^2.0.0"
+    p-is-promise "^2.0.0"
 
 merge-stream@^2.0.0:
   version "2.0.0"
   resolved "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60"
   integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==
 
-merge2@^1.2.3:
-  version "1.3.0"
-  resolved "https://registry.npmjs.org/merge2/-/merge2-1.3.0.tgz#5b366ee83b2f1582c48f87e47cf1a9352103ca81"
-  integrity sha512-2j4DAdlBOkiSZIsaXk4mTE3sRS02yBHAtfy127xRV3bQUFqXkjHCHLW6Scv7DwNRbIWNHH8zpnz9zMaKXIdvYw==
-
 merge@^1.2.0:
   version "1.2.1"
   resolved "https://registry.npmjs.org/merge/-/merge-1.2.1.tgz#38bebf80c3220a8a487b6fcfb3941bb11720c145"
@@ -4707,10 +2706,10 @@ mime@^1.2.11:
   resolved "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz#32cd9e5c64553bd58d19a568af452acff04981b1"
   integrity sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==
 
-mimic-fn@^1.0.0:
-  version "1.2.0"
-  resolved "https://registry.npmjs.org/mimic-fn/-/mimic-fn-1.2.0.tgz#820c86a39334640e99516928bd03fca88057d022"
-  integrity sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==
+mimic-fn@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b"
+  integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==
 
 minimatch@^3.0.2, minimatch@^3.0.4:
   version "3.0.4"
@@ -4719,60 +2718,16 @@ minimatch@^3.0.2, minimatch@^3.0.4:
   dependencies:
     brace-expansion "^1.1.7"
 
-minimist-options@^3.0.1:
-  version "3.0.2"
-  resolved "https://registry.npmjs.org/minimist-options/-/minimist-options-3.0.2.tgz#fba4c8191339e13ecf4d61beb03f070103f3d954"
-  integrity sha512-FyBrT/d0d4+uiZRbqznPXqw3IpZZG3gl3wKWiX784FycUKVwBt0uLBFkQrtE4tZOrgo78nZp2jnKz3L65T5LdQ==
-  dependencies:
-    arrify "^1.0.1"
-    is-plain-obj "^1.1.0"
-
 minimist@0.0.8:
   version "0.0.8"
   resolved "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz#857fcabfc3397d2625b8228262e86aa7a011b05d"
   integrity sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=
 
-minimist@^1.1.1, minimist@^1.1.3, minimist@^1.2.0, minimist@^1.2.5:
+minimist@^1.1.1, minimist@^1.2.0, minimist@^1.2.5:
   version "1.2.5"
   resolved "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz#67d66014b66a6a8aaa0c083c5fd58df4e4e97602"
   integrity sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==
 
-minimist@~0.0.1:
-  version "0.0.10"
-  resolved "https://registry.npmjs.org/minimist/-/minimist-0.0.10.tgz#de3f98543dbf96082be48ad1a0c7cda836301dcf"
-  integrity sha1-3j+YVD2/lggr5IrRoMfNqDYwHc8=
-
-minipass@^2.3.5, minipass@^2.6.0, minipass@^2.8.6, minipass@^2.9.0:
-  version "2.9.0"
-  resolved "https://registry.npmjs.org/minipass/-/minipass-2.9.0.tgz#e713762e7d3e32fed803115cf93e04bca9fcc9a6"
-  integrity sha512-wxfUjg9WebH+CUDX/CdbRlh5SmfZiy/hpkxaRI16Y9W56Pa75sWgd/rvFilSgrauD9NyFymP/+JFV3KwzIsJeg==
-  dependencies:
-    safe-buffer "^5.1.2"
-    yallist "^3.0.0"
-
-minizlib@^1.2.1:
-  version "1.3.3"
-  resolved "https://registry.npmjs.org/minizlib/-/minizlib-1.3.3.tgz#2290de96818a34c29551c8a8d301216bd65a861d"
-  integrity sha512-6ZYMOEnmVsdCeTJVE0W9ZD+pVnE8h9Hma/iOwwRDsdQoePpoX56/8B6z3P9VNwppJuBKNRuFDRNRqRWexT9G9Q==
-  dependencies:
-    minipass "^2.9.0"
-
-mississippi@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/mississippi/-/mississippi-3.0.0.tgz#ea0a3291f97e0b5e8776b363d5f0a12d94c67022"
-  integrity sha512-x471SsVjUtBRtcvd4BzKE9kFC+/2TeWgKCgw0bZcw1b9l2X3QX5vCWgF+KaZaYm87Ss//rHnWryupDrgLvmSkA==
-  dependencies:
-    concat-stream "^1.5.0"
-    duplexify "^3.4.2"
-    end-of-stream "^1.1.0"
-    flush-write-stream "^1.0.0"
-    from2 "^2.1.0"
-    parallel-transform "^1.1.0"
-    pump "^3.0.0"
-    pumpify "^1.3.3"
-    stream-each "^1.1.0"
-    through2 "^2.0.0"
-
 mixin-deep@^1.2.0:
   version "1.3.2"
   resolved "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.2.tgz#1120b43dc359a785dce65b55b82e257ccf479566"
@@ -4781,84 +2736,23 @@ mixin-deep@^1.2.0:
     for-in "^1.0.2"
     is-extendable "^1.0.1"
 
-mixin-object@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/mixin-object/-/mixin-object-3.0.0.tgz#55091196c9cf744f4c7956fb7021da38c736c440"
-  integrity sha512-RsUqTd3DyF9+UPqhLzJIWwGm4ZGIPYOu6WcQhQuBqqVBGhc6LOC8LrFk9KD7PvVwmqri45IJT88WLrNNrMWjxg==
-  dependencies:
-    for-in "^1.0.2"
-    is-extendable "^1.0.0"
-
-mkdirp-promise@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.npmjs.org/mkdirp-promise/-/mkdirp-promise-5.0.1.tgz#e9b8f68e552c68a9c1713b84883f7a1dd039b8a1"
-  integrity sha1-6bj2jlUsaKnBcTuEiD96HdA5uKE=
-  dependencies:
-    mkdirp "*"
-
-mkdirp@*, mkdirp@0.5.1, mkdirp@0.5.x, "mkdirp@>=0.5 0", mkdirp@^0.5.0, mkdirp@^0.5.1:
+mkdirp@0.5.x, "mkdirp@>=0.5 0", mkdirp@^0.5.0, mkdirp@^0.5.1:
   version "0.5.1"
   resolved "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz#30057438eac6cf7f8c4767f38648d6697d75c903"
   integrity sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=
   dependencies:
     minimist "0.0.8"
 
-modify-values@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/modify-values/-/modify-values-1.0.1.tgz#b3939fa605546474e3e3e3c63d64bd43b4ee6022"
-  integrity sha512-xV2bxeN6F7oYjZWTe/YPAy6MN2M+sL4u/Rlm2AHCIVGfo2p1yGmBHQ6vHehl4bRTZBdHu3TSkWdYgkwpYzAGSw==
-
-move-concurrently@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/move-concurrently/-/move-concurrently-1.0.1.tgz#be2c005fda32e0b29af1f05d7c4b33214c701f92"
-  integrity sha1-viwAX9oy4LKa8fBdfEszIUxwH5I=
-  dependencies:
-    aproba "^1.1.1"
-    copy-concurrently "^1.0.0"
-    fs-write-stream-atomic "^1.0.8"
-    mkdirp "^0.5.1"
-    rimraf "^2.5.4"
-    run-queue "^1.0.3"
-
 ms@2.0.0:
   version "2.0.0"
   resolved "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8"
   integrity sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=
 
-ms@^2.0.0, ms@^2.1.1:
+ms@^2.1.1:
   version "2.1.2"
   resolved "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009"
   integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
 
-multimatch@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/multimatch/-/multimatch-3.0.0.tgz#0e2534cc6bc238d9ab67e1b9cd5fcd85a6dbf70b"
-  integrity sha512-22foS/gqQfANZ3o+W7ST2x25ueHDVNWl/b9OlGcLpy/iKxjCpvcNCM51YCenUi7Mt/jAjjqv8JwZRs8YP5sRjA==
-  dependencies:
-    array-differ "^2.0.3"
-    array-union "^1.0.2"
-    arrify "^1.0.1"
-    minimatch "^3.0.4"
-
-mute-stream@0.0.7:
-  version "0.0.7"
-  resolved "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.7.tgz#3075ce93bc21b8fab43e1bc4da7e8115ed1e7bab"
-  integrity sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=
-
-mute-stream@~0.0.4:
-  version "0.0.8"
-  resolved "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.8.tgz#1630c42b2251ff81e2a283de96a5497ea92e5e0d"
-  integrity sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA==
-
-mz@^2.5.0:
-  version "2.7.0"
-  resolved "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz#95008057a56cafadc2bc63dde7f9ff6955948e32"
-  integrity sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==
-  dependencies:
-    any-promise "^1.0.0"
-    object-assign "^4.0.1"
-    thenify-all "^1.0.0"
-
 nan@^2.12.1:
   version "2.14.0"
   resolved "https://registry.npmjs.org/nan/-/nan-2.14.0.tgz#7818f722027b2459a86f0295d434d1fc2336c52c"
@@ -4886,47 +2780,11 @@ natural-compare@^1.4.0:
   resolved "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7"
   integrity sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=
 
-neo-async@^2.6.0:
-  version "2.6.1"
-  resolved "https://registry.npmjs.org/neo-async/-/neo-async-2.6.1.tgz#ac27ada66167fa8849a6addd837f6b189ad2081c"
-  integrity sha512-iyam8fBuCUpWeKPGpaNMetEocMt364qkCsfL9JuhjXX6dRnguRVOfk2GZaDpPjcOKiiXCPINZC1GczQ7iTq3Zw==
-
 nice-try@^1.0.4:
   version "1.0.5"
   resolved "https://registry.npmjs.org/nice-try/-/nice-try-1.0.5.tgz#a3378a7696ce7d223e88fc9b764bd7ef1089e366"
   integrity sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==
 
-node-fetch-npm@^2.0.2:
-  version "2.0.3"
-  resolved "https://registry.npmjs.org/node-fetch-npm/-/node-fetch-npm-2.0.3.tgz#efae4aacb0500444e449a51fc1467397775ebc38"
-  integrity sha512-DgwoKEsqLnFZtk3ap7GWBHcHwnUhsNmQqEDcdjfQ8GofLEFJ081NAd4Uin3R7RFZBWVJCwHISw1oaEqPgSLloA==
-  dependencies:
-    encoding "^0.1.11"
-    json-parse-better-errors "^1.0.0"
-    safe-buffer "^5.1.1"
-
-node-fetch@^2.3.0, node-fetch@^2.5.0:
-  version "2.6.0"
-  resolved "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.0.tgz#e633456386d4aa55863f676a7ab0daa8fdecb0fd"
-  integrity sha512-8dG4H5ujfvFiqDmVu9fQ5bOHUC15JMjMY/Zumv26oOvvVJjM67KF8koCWIabKQ1GJIa9r2mMZscBq/TbdOcmNA==
-
-node-gyp@^5.0.2:
-  version "5.1.0"
-  resolved "https://registry.npmjs.org/node-gyp/-/node-gyp-5.1.0.tgz#8e31260a7af4a2e2f994b0673d4e0b3866156332"
-  integrity sha512-OUTryc5bt/P8zVgNUmC6xdXiDJxLMAW8cF5tLQOT9E5sOQj+UeQxnnPy74K3CLCa/SOjjBlbuzDLR8ANwA+wmw==
-  dependencies:
-    env-paths "^2.2.0"
-    glob "^7.1.4"
-    graceful-fs "^4.2.2"
-    mkdirp "^0.5.1"
-    nopt "^4.0.1"
-    npmlog "^4.1.2"
-    request "^2.88.0"
-    rimraf "^2.6.3"
-    semver "^5.7.1"
-    tar "^4.4.12"
-    which "^1.3.1"
-
 node-int64@^0.4.0:
   version "0.4.0"
   resolved "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz#87a9065cdb355d3182d8f94ce11188b825c68a3b"
@@ -4948,15 +2806,7 @@ node-notifier@^5.4.2:
     shellwords "^0.1.1"
     which "^1.3.0"
 
-nopt@^4.0.1:
-  version "4.0.3"
-  resolved "https://registry.npmjs.org/nopt/-/nopt-4.0.3.tgz#a375cad9d02fd921278d954c2254d5aa57e15e48"
-  integrity sha512-CvaGwVMztSMJLOeXPrez7fyfObdZqNUK1cPAEzLHrTybIua9pMdmmPR5YwtfNftIOMv3DPUhFaxsZMNTQO20Kg==
-  dependencies:
-    abbrev "1"
-    osenv "^0.1.4"
-
-normalize-package-data@^2.0.0, normalize-package-data@^2.3.0, normalize-package-data@^2.3.2, normalize-package-data@^2.3.4, normalize-package-data@^2.3.5, normalize-package-data@^2.4.0, normalize-package-data@^2.5.0:
+normalize-package-data@^2.3.2:
   version "2.5.0"
   resolved "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz#e66db1838b200c1dfc233225d12cb36520e234a8"
   integrity sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==
@@ -4973,65 +2823,6 @@ normalize-path@^2.1.1:
   dependencies:
     remove-trailing-separator "^1.0.1"
 
-normalize-url@^3.3.0:
-  version "3.3.0"
-  resolved "https://registry.npmjs.org/normalize-url/-/normalize-url-3.3.0.tgz#b2e1c4dc4f7c6d57743df733a4f5978d18650559"
-  integrity sha512-U+JJi7duF1o+u2pynbp2zXDW2/PADgC30f0GsHZtRh+HOcXHnw137TrNlyxxRvWW5fjKd3bcLHPxofWuCjaeZg==
-
-npm-bundled@^1.0.1:
-  version "1.1.1"
-  resolved "https://registry.npmjs.org/npm-bundled/-/npm-bundled-1.1.1.tgz#1edd570865a94cdb1bc8220775e29466c9fb234b"
-  integrity sha512-gqkfgGePhTpAEgUsGEgcq1rqPXA+tv/aVBlgEzfXwA1yiUJF7xtEt3CtVwOjNYQOVknDk0F20w58Fnm3EtG0fA==
-  dependencies:
-    npm-normalize-package-bin "^1.0.1"
-
-npm-lifecycle@^3.1.2:
-  version "3.1.4"
-  resolved "https://registry.npmjs.org/npm-lifecycle/-/npm-lifecycle-3.1.4.tgz#de6975c7d8df65f5150db110b57cce498b0b604c"
-  integrity sha512-tgs1PaucZwkxECGKhC/stbEgFyc3TGh2TJcg2CDr6jbvQRdteHNhmMeljRzpe4wgFAXQADoy1cSqqi7mtiAa5A==
-  dependencies:
-    byline "^5.0.0"
-    graceful-fs "^4.1.15"
-    node-gyp "^5.0.2"
-    resolve-from "^4.0.0"
-    slide "^1.1.6"
-    uid-number "0.0.6"
-    umask "^1.1.0"
-    which "^1.3.1"
-
-npm-normalize-package-bin@^1.0.0, npm-normalize-package-bin@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/npm-normalize-package-bin/-/npm-normalize-package-bin-1.0.1.tgz#6e79a41f23fd235c0623218228da7d9c23b8f6e2"
-  integrity sha512-EPfafl6JL5/rU+ot6P3gRSCpPDW5VmIzX959Ob1+ySFUuuYHWHekXpwdUZcKP5C+DS4GEtdJluwBjnsNDl+fSA==
-
-"npm-package-arg@^4.0.0 || ^5.0.0 || ^6.0.0", npm-package-arg@^6.0.0, npm-package-arg@^6.1.0:
-  version "6.1.1"
-  resolved "https://registry.npmjs.org/npm-package-arg/-/npm-package-arg-6.1.1.tgz#02168cb0a49a2b75bf988a28698de7b529df5cb7"
-  integrity sha512-qBpssaL3IOZWi5vEKUKW0cO7kzLeT+EQO9W8RsLOZf76KF9E/K9+wH0C7t06HXPpaH8WH5xF1MExLuCwbTqRUg==
-  dependencies:
-    hosted-git-info "^2.7.1"
-    osenv "^0.1.5"
-    semver "^5.6.0"
-    validate-npm-package-name "^3.0.0"
-
-npm-packlist@^1.4.4:
-  version "1.4.8"
-  resolved "https://registry.npmjs.org/npm-packlist/-/npm-packlist-1.4.8.tgz#56ee6cc135b9f98ad3d51c1c95da22bbb9b2ef3e"
-  integrity sha512-5+AZgwru5IevF5ZdnFglB5wNlHG1AOOuw28WhUq8/8emhBmLv6jX5by4WJCh7lW0uSYZYS6DXqIsyZVIXRZU9A==
-  dependencies:
-    ignore-walk "^3.0.1"
-    npm-bundled "^1.0.1"
-    npm-normalize-package-bin "^1.0.1"
-
-npm-pick-manifest@^3.0.0:
-  version "3.0.2"
-  resolved "https://registry.npmjs.org/npm-pick-manifest/-/npm-pick-manifest-3.0.2.tgz#f4d9e5fd4be2153e5f4e5f9b7be8dc419a99abb7"
-  integrity sha512-wNprTNg+X5nf+tDi+hbjdHhM4bX+mKqv6XmPh7B5eG+QY9VARfQPfCEH013H5GqfNj6ee8Ij2fg8yk0mzps1Vw==
-  dependencies:
-    figgy-pudding "^3.5.1"
-    npm-package-arg "^6.0.0"
-    semver "^5.4.1"
-
 npm-run-path@^2.0.0:
   version "2.0.2"
   resolved "https://registry.npmjs.org/npm-run-path/-/npm-run-path-2.0.2.tgz#35a9232dfa35d7067b4cb2ddf2357b1871536c5f"
@@ -5039,19 +2830,9 @@ npm-run-path@^2.0.0:
   dependencies:
     path-key "^2.0.0"
 
-npmlog@^4.1.2:
-  version "4.1.2"
-  resolved "https://registry.npmjs.org/npmlog/-/npmlog-4.1.2.tgz#08a7f2a8bf734604779a9efa4ad5cc717abb954b"
-  integrity sha512-2uUqazuKlTaSI/dC8AzicUck7+IrEaOnN/e0jd3Xtt1KcGpwx30v50mL7oPyr/h9bL3E4aZccVwpwP+5W9Vjkg==
-  dependencies:
-    are-we-there-yet "~1.1.2"
-    console-control-strings "~1.1.0"
-    gauge "~2.7.3"
-    set-blocking "~2.0.0"
-
 number-is-nan@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz#097b602b53422a522c1afb8790318336941a011d"
+  resolved "https://registry.yarnpkg.com/number-is-nan/-/number-is-nan-1.0.1.tgz#097b602b53422a522c1afb8790318336941a011d"
   integrity sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=
 
 nwsapi@^2.0.7:
@@ -5069,7 +2850,7 @@ oauth-sign@~0.9.0:
   resolved "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.9.0.tgz#47a7b016baa68b5fa0ecf3dee08a85c679ac6455"
   integrity sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==
 
-object-assign@^4.0.1, object-assign@^4.1.0, object-assign@^4.1.1:
+object-assign@^4.0.1, object-assign@^4.1.1:
   version "4.1.1"
   resolved "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
   integrity sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=
@@ -5110,7 +2891,7 @@ object.assign@^4.1.0:
     has-symbols "^1.0.0"
     object-keys "^1.0.11"
 
-object.getownpropertydescriptors@^2.0.3, object.getownpropertydescriptors@^2.1.0:
+object.getownpropertydescriptors@^2.1.0:
   version "2.1.0"
   resolved "https://registry.npmjs.org/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.1.0.tgz#369bf1f9592d8ab89d712dced5cb81c7c5352649"
   integrity sha512-Z53Oah9A3TdLoblT7VKJaTDdXdT+lQO+cNpKVnya5JDe9uLvzu1YyY1yFDFrcxrlRgWrEFH0jJtD/IbuwjcEVg==
@@ -5125,11 +2906,6 @@ object.pick@^1.3.0:
   dependencies:
     isobject "^3.0.1"
 
-octokit-pagination-methods@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/octokit-pagination-methods/-/octokit-pagination-methods-1.1.0.tgz#cf472edc9d551055f9ef73f6e42b4dbb4c80bea4"
-  integrity sha512-fZ4qZdQ2nxJvtcasX7Ghl+WlWS/d9IgnBIwFZXVNNZUmzpno91SX5bc5vuxiuKoCtK78XxGGNuSCrDC7xYB3OQ==
-
 once@^1.3.0, once@^1.3.1, once@^1.4.0:
   version "1.4.0"
   resolved "https://registry.npmjs.org/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
@@ -5137,21 +2913,6 @@ once@^1.3.0, once@^1.3.1, once@^1.4.0:
   dependencies:
     wrappy "1"
 
-onetime@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.npmjs.org/onetime/-/onetime-2.0.1.tgz#067428230fd67443b2794b22bba528b6867962d4"
-  integrity sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=
-  dependencies:
-    mimic-fn "^1.0.0"
-
-optimist@^0.6.1:
-  version "0.6.1"
-  resolved "https://registry.npmjs.org/optimist/-/optimist-0.6.1.tgz#da3ea74686fa21a19a111c326e90eb15a0196686"
-  integrity sha1-2j6nRob6IaGaERwybpDrFaAZZoY=
-  dependencies:
-    minimist "~0.0.1"
-    wordwrap "~0.0.2"
-
 optionator@^0.8.1:
   version "0.8.3"
   resolved "https://registry.npmjs.org/optionator/-/optionator-0.8.3.tgz#84fa1d036fe9d3c7e21d99884b601167ec8fb495"
@@ -5164,31 +2925,19 @@ optionator@^0.8.1:
     type-check "~0.3.2"
     word-wrap "~1.2.3"
 
-os-homedir@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/os-homedir/-/os-homedir-1.0.2.tgz#ffbc4988336e0e833de0c168c7ef152121aa7fb3"
-  integrity sha1-/7xJiDNuDoM94MFox+8VISGqf7M=
-
-os-name@^3.1.0:
+os-locale@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.npmjs.org/os-name/-/os-name-3.1.0.tgz#dec19d966296e1cd62d701a5a66ee1ddeae70801"
-  integrity sha512-h8L+8aNjNcMpo/mAIBPn5PXCM16iyPGjHNWo6U1YO8sJTMHtEtyczI6QJnLoplswm6goopQkqc7OAnjhWcugVg==
+  resolved "https://registry.yarnpkg.com/os-locale/-/os-locale-3.1.0.tgz#a802a6ee17f24c10483ab9935719cef4ed16bf1a"
+  integrity sha512-Z8l3R4wYWM40/52Z+S265okfFj8Kt2cC2MKY+xNi3kFs+XGI7WXu/I309QQQYbRW4ijiZ+yxs9pqEhJh0DqW3Q==
   dependencies:
-    macos-release "^2.2.0"
-    windows-release "^3.1.0"
-
-os-tmpdir@^1.0.0, os-tmpdir@~1.0.2:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274"
-  integrity sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=
+    execa "^1.0.0"
+    lcid "^2.0.0"
+    mem "^4.0.0"
 
-osenv@^0.1.4, osenv@^0.1.5:
-  version "0.1.5"
-  resolved "https://registry.npmjs.org/osenv/-/osenv-0.1.5.tgz#85cdfafaeb28e8677f416e287592b5f3f49ea410"
-  integrity sha512-0CWcCECdMVc2Rw3U5w9ZjqX6ga6ubk1xDVKxtBQPK7wis/0F2r9T6k4ydGYhecl7YUBxBVxhL5oisPsNxAPe2g==
-  dependencies:
-    os-homedir "^1.0.0"
-    os-tmpdir "^1.0.0"
+p-defer@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/p-defer/-/p-defer-1.0.0.tgz#9f6eb182f6c9aa8cd743004a7d4f96b196b0fb0c"
+  integrity sha1-n26xgvbJqozXQwBKfU+WsZaw+ww=
 
 p-each-series@^1.0.0:
   version "1.0.0"
@@ -5202,9 +2951,14 @@ p-finally@^1.0.0:
   resolved "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz#3fbcfb15b899a44123b34b6dcc18b724336a2cae"
   integrity sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=
 
+p-is-promise@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/p-is-promise/-/p-is-promise-2.1.0.tgz#918cebaea248a62cf7ffab8e3bca8c5f882fc42e"
+  integrity sha512-Y3W0wlRPK8ZMRbNq97l4M5otioeA5lm1z7bkNkxCka8HSPjR0xRWmpCmc9utiaLP9Jb1eD8BgeIxTW4AIF45Pg==
+
 p-limit@^1.1.0:
   version "1.3.0"
-  resolved "https://registry.npmjs.org/p-limit/-/p-limit-1.3.0.tgz#b86bd5f0c25690911c7590fcbfc2010d54b3ccb8"
+  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-1.3.0.tgz#b86bd5f0c25690911c7590fcbfc2010d54b3ccb8"
   integrity sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==
   dependencies:
     p-try "^1.0.0"
@@ -5218,7 +2972,7 @@ p-limit@^2.0.0:
 
 p-locate@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/p-locate/-/p-locate-2.0.0.tgz#20a0103b222a70c8fd39cc2e580680f3dde5ec43"
+  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-2.0.0.tgz#20a0103b222a70c8fd39cc2e580680f3dde5ec43"
   integrity sha1-IKAQOyIqcMj9OcwuWAaA893l7EM=
   dependencies:
     p-limit "^1.1.0"
@@ -5230,30 +2984,6 @@ p-locate@^3.0.0:
   dependencies:
     p-limit "^2.0.0"
 
-p-map-series@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/p-map-series/-/p-map-series-1.0.0.tgz#bf98fe575705658a9e1351befb85ae4c1f07bdca"
-  integrity sha1-v5j+V1cFZYqeE1G++4WuTB8Hvco=
-  dependencies:
-    p-reduce "^1.0.0"
-
-p-map@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/p-map/-/p-map-2.1.0.tgz#310928feef9c9ecc65b68b17693018a665cea175"
-  integrity sha512-y3b8Kpd8OAN444hxfBbFfj1FY/RjtTd8tzYwhUqNYXx0fXx2iX4maP4Qr6qhIKbQXI02wTLAda4fYUbDagTUFw==
-
-p-pipe@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.npmjs.org/p-pipe/-/p-pipe-1.2.0.tgz#4b1a11399a11520a67790ee5a0c1d5881d6befe9"
-  integrity sha1-SxoROZoRUgpneQ7loMHViB1r7+k=
-
-p-queue@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/p-queue/-/p-queue-4.0.0.tgz#ed0eee8798927ed6f2c2f5f5b77fdb2061a5d346"
-  integrity sha512-3cRXXn3/O0o3+eVmUroJPSj/esxoEFIm0ZOno/T+NzG/VZgPOqQ8WKmlNqubSEpZmCIngEy34unkHGg83ZIBmg==
-  dependencies:
-    eventemitter3 "^3.1.0"
-
 p-reduce@^1.0.0:
   version "1.0.0"
   resolved "https://registry.npmjs.org/p-reduce/-/p-reduce-1.0.0.tgz#18c2b0dd936a4690a529f8231f58a0fdb6a47dfa"
@@ -5261,7 +2991,7 @@ p-reduce@^1.0.0:
 
 p-try@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/p-try/-/p-try-1.0.0.tgz#cbc79cdbaf8fd4228e13f621f2b1a237c1b207b3"
+  resolved "https://registry.yarnpkg.com/p-try/-/p-try-1.0.0.tgz#cbc79cdbaf8fd4228e13f621f2b1a237c1b207b3"
   integrity sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M=
 
 p-try@^2.0.0:
@@ -5269,34 +2999,6 @@ p-try@^2.0.0:
   resolved "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6"
   integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==
 
-p-waterfall@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/p-waterfall/-/p-waterfall-1.0.0.tgz#7ed94b3ceb3332782353af6aae11aa9fc235bb00"
-  integrity sha1-ftlLPOszMngjU69qrhGqn8I1uwA=
-  dependencies:
-    p-reduce "^1.0.0"
-
-parallel-transform@^1.1.0:
-  version "1.2.0"
-  resolved "https://registry.npmjs.org/parallel-transform/-/parallel-transform-1.2.0.tgz#9049ca37d6cb2182c3b1d2c720be94d14a5814fc"
-  integrity sha512-P2vSmIu38uIlvdcU7fDkyrxj33gTUy/ABO5ZUbGowxNCopBq/OoD42bP4UmMrJoPyk4Uqf0mu3mtWBhHCZD8yg==
-  dependencies:
-    cyclist "^1.0.1"
-    inherits "^2.0.3"
-    readable-stream "^2.1.5"
-
-parse-github-repo-url@^1.3.0:
-  version "1.4.1"
-  resolved "https://registry.npmjs.org/parse-github-repo-url/-/parse-github-repo-url-1.4.1.tgz#9e7d8bb252a6cb6ba42595060b7bf6df3dbc1f50"
-  integrity sha1-nn2LslKmy2ukJZUGC3v23z28H1A=
-
-parse-json@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.npmjs.org/parse-json/-/parse-json-2.2.0.tgz#f480f40434ef80741f8469099f8dea18f55a4dc9"
-  integrity sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=
-  dependencies:
-    error-ex "^1.2.0"
-
 parse-json@^4.0.0:
   version "4.0.0"
   resolved "https://registry.npmjs.org/parse-json/-/parse-json-4.0.0.tgz#be35f5425be1f7f6c747184f98a788cb99477ee0"
@@ -5305,24 +3007,6 @@ parse-json@^4.0.0:
     error-ex "^1.3.1"
     json-parse-better-errors "^1.0.1"
 
-parse-path@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.npmjs.org/parse-path/-/parse-path-4.0.1.tgz#0ec769704949778cb3b8eda5e994c32073a1adff"
-  integrity sha512-d7yhga0Oc+PwNXDvQ0Jv1BuWkLVPXcAoQ/WREgd6vNNoKYaW52KI+RdOFjI63wjkmps9yUE8VS4veP+AgpQ/hA==
-  dependencies:
-    is-ssh "^1.3.0"
-    protocols "^1.4.0"
-
-parse-url@^5.0.0:
-  version "5.0.1"
-  resolved "https://registry.npmjs.org/parse-url/-/parse-url-5.0.1.tgz#99c4084fc11be14141efa41b3d117a96fcb9527f"
-  integrity sha512-flNUPP27r3vJpROi0/R3/2efgKkyXqnXwyP1KQ2U0SfFRgdizOdWfvrrvJg1LuOoxs7GQhmxJlq23IpQ/BkByg==
-  dependencies:
-    is-ssh "^1.3.0"
-    normalize-url "^3.3.0"
-    parse-path "^4.0.0"
-    protocols "^1.4.0"
-
 parse5@4.0.0:
   version "4.0.0"
   resolved "https://registry.npmjs.org/parse5/-/parse5-4.0.0.tgz#6d78656e3da8d78b4ec0b906f7c08ef1dfe3f608"
@@ -5333,18 +3017,6 @@ pascalcase@^0.1.1:
   resolved "https://registry.npmjs.org/pascalcase/-/pascalcase-0.1.1.tgz#b363e55e8006ca6fe21784d2db22bd15d7917f14"
   integrity sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ=
 
-path-dirname@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/path-dirname/-/path-dirname-1.0.2.tgz#cc33d24d525e099a5388c0336c6e32b9160609e0"
-  integrity sha1-zDPSTVJeCZpTiMAzbG4yuRYGCeA=
-
-path-exists@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/path-exists/-/path-exists-2.1.0.tgz#0feb6c64f0fc518d9a754dd5efb62c7022761f4b"
-  integrity sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=
-  dependencies:
-    pinkie-promise "^2.0.0"
-
 path-exists@^3.0.0:
   version "3.0.0"
   resolved "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz#ce0ebeaa5f78cb18925ea7d810d7b59b010fd515"
@@ -5365,15 +3037,6 @@ path-parse@^1.0.6:
   resolved "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz#d62dbb5679405d72c4737ec58600e9ddcf06d24c"
   integrity sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==
 
-path-type@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/path-type/-/path-type-1.1.0.tgz#59c44f7ee491da704da415da5a4070ba4f8fe441"
-  integrity sha1-WcRPfuSR2nBNpBXaWkBwuk+P5EE=
-  dependencies:
-    graceful-fs "^4.1.2"
-    pify "^2.0.0"
-    pinkie-promise "^2.0.0"
-
 path-type@^3.0.0:
   version "3.0.0"
   resolved "https://registry.npmjs.org/path-type/-/path-type-3.0.0.tgz#cef31dc8e0a1a3bb0d105c0cd97cf3bf47f4e36f"
@@ -5391,11 +3054,6 @@ performance-now@^2.1.0:
   resolved "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz#6309f4e0e5fa913ec1c69307ae364b4b377c9e7b"
   integrity sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=
 
-pify@^2.0.0, pify@^2.3.0:
-  version "2.3.0"
-  resolved "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c"
-  integrity sha1-7RQaasBDqEnqWISY59yosVMw6Qw=
-
 pify@^3.0.0:
   version "3.0.0"
   resolved "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz#e5a4acd2c101fdf3d9a4d07f0dbc4db49dd28176"
@@ -5406,18 +3064,6 @@ pify@^4.0.1:
   resolved "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz#4b2cd25c50d598735c50292224fd8c6df41e3231"
   integrity sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==
 
-pinkie-promise@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.npmjs.org/pinkie-promise/-/pinkie-promise-2.0.1.tgz#2135d6dfa7a358c069ac9b178776288228450ffa"
-  integrity sha1-ITXW36ejWMBprJsXh3YogihFD/o=
-  dependencies:
-    pinkie "^2.0.0"
-
-pinkie@^2.0.0:
-  version "2.0.4"
-  resolved "https://registry.npmjs.org/pinkie/-/pinkie-2.0.4.tgz#72556b80cfa0d48a974e80e77248e80ed4f7f870"
-  integrity sha1-clVrgM+g1IqXToDnckjoDtT3+HA=
-
 pirates@^4.0.1:
   version "4.0.1"
   resolved "https://registry.npmjs.org/pirates/-/pirates-4.0.1.tgz#643a92caf894566f91b2b986d2c66950a8e2fb87"
@@ -5467,19 +3113,6 @@ process-nextick-args@~2.0.0:
   resolved "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2"
   integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==
 
-promise-inflight@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/promise-inflight/-/promise-inflight-1.0.1.tgz#98472870bf228132fcbdd868129bad12c3c029e3"
-  integrity sha1-mEcocL8igTL8vdhoEputEsPAKeM=
-
-promise-retry@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.npmjs.org/promise-retry/-/promise-retry-1.1.1.tgz#6739e968e3051da20ce6497fb2b50f6911df3d6d"
-  integrity sha1-ZznpaOMFHaIM5kl/srUPaRHfPW0=
-  dependencies:
-    err-code "^1.0.0"
-    retry "^0.10.0"
-
 promise@^6.0.0, promise@^6.0.1:
   version "6.1.0"
   resolved "https://registry.npmjs.org/promise/-/promise-6.1.0.tgz#2ce729f6b94b45c26891ad0602c5c90e04c6eef6"
@@ -5501,37 +3134,13 @@ promise@~7.0.1:
   dependencies:
     asap "~2.0.3"
 
-prompts@^2.0.1:
-  version "2.3.1"
-  resolved "https://registry.npmjs.org/prompts/-/prompts-2.3.1.tgz#b63a9ce2809f106fa9ae1277c275b167af46ea05"
-  integrity sha512-qIP2lQyCwYbdzcqHIUi2HAxiWixhoM9OdLCWf8txXsapC/X9YdsCoeyRIXE/GP+Q0J37Q7+XN/MFqbUa7IzXNA==
-  dependencies:
-    kleur "^3.0.3"
-    sisteransi "^1.0.4"
-
-promzard@^0.3.0:
-  version "0.3.0"
-  resolved "https://registry.npmjs.org/promzard/-/promzard-0.3.0.tgz#26a5d6ee8c7dee4cb12208305acfb93ba382a9ee"
-  integrity sha1-JqXW7ox97kyxIggwWs+5O6OCqe4=
-  dependencies:
-    read "1"
-
-proto-list@~1.2.1:
-  version "1.2.4"
-  resolved "https://registry.npmjs.org/proto-list/-/proto-list-1.2.4.tgz#212d5bfe1318306a420f6402b8e26ff39647a849"
-  integrity sha1-IS1b/hMYMGpCD2QCuOJv85ZHqEk=
-
-protocols@^1.1.0, protocols@^1.4.0:
-  version "1.4.7"
-  resolved "https://registry.npmjs.org/protocols/-/protocols-1.4.7.tgz#95f788a4f0e979b291ffefcf5636ad113d037d32"
-  integrity sha512-Fx65lf9/YDn3hUX08XUc0J8rSux36rEsyiv21ZGUC1mOyeM3lTRpZLcrm8aAolzS4itwVfm7TAPyxC2E5zd6xg==
-
-protoduck@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.npmjs.org/protoduck/-/protoduck-5.0.1.tgz#03c3659ca18007b69a50fd82a7ebcc516261151f"
-  integrity sha512-WxoCeDCoCBY55BMvj4cAEjdVUFGRWed9ZxPlqTKYyw1nDDTQ4pqmnIMAGfJlg7Dx35uB/M+PHJPTmGOvaCaPTg==
+prompts@^2.0.1:
+  version "2.3.1"
+  resolved "https://registry.npmjs.org/prompts/-/prompts-2.3.1.tgz#b63a9ce2809f106fa9ae1277c275b167af46ea05"
+  integrity sha512-qIP2lQyCwYbdzcqHIUi2HAxiWixhoM9OdLCWf8txXsapC/X9YdsCoeyRIXE/GP+Q0J37Q7+XN/MFqbUa7IzXNA==
   dependencies:
-    genfun "^5.0.0"
+    kleur "^3.0.3"
+    sisteransi "^1.0.4"
 
 prr@~1.0.1:
   version "1.0.1"
@@ -5543,14 +3152,6 @@ psl@^1.1.28:
   resolved "https://registry.npmjs.org/psl/-/psl-1.7.0.tgz#f1c4c47a8ef97167dea5d6bbf4816d736e884a3c"
   integrity sha512-5NsSEDv8zY70ScRnOTn7bK7eanl2MvFrOrS/R6x+dBt5g1ghnj9Zv90kO8GwT8gxcu2ANyFprnFYB85IogIJOQ==
 
-pump@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.npmjs.org/pump/-/pump-2.0.1.tgz#12399add6e4cf7526d973cbc8b5ce2e2908b3909"
-  integrity sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==
-  dependencies:
-    end-of-stream "^1.1.0"
-    once "^1.3.1"
-
 pump@^3.0.0:
   version "3.0.0"
   resolved "https://registry.npmjs.org/pump/-/pump-3.0.0.tgz#b4a2116815bde2f4e1ea602354e8c75565107a64"
@@ -5559,15 +3160,6 @@ pump@^3.0.0:
     end-of-stream "^1.1.0"
     once "^1.3.1"
 
-pumpify@^1.3.3:
-  version "1.5.1"
-  resolved "https://registry.npmjs.org/pumpify/-/pumpify-1.5.1.tgz#36513be246ab27570b1a374a5ce278bfd74370ce"
-  integrity sha512-oClZI37HvuUJJxSKKrC17bZ9Cu0ZYhEAGPsPUy9KlMUmv9dKX2o77RUmq7f3XjIxbwyGwYzbzQ1L2Ks8sIradQ==
-  dependencies:
-    duplexify "^3.6.0"
-    inherits "^2.0.3"
-    pump "^2.0.0"
-
 punycode@^1.4.1:
   version "1.4.1"
   resolved "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz#c0d5a63b2718800ad8e1eb0fa5269c84dd41845e"
@@ -5578,11 +3170,6 @@ punycode@^2.1.0, punycode@^2.1.1:
   resolved "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz#b58b010ac40c22c5657616c8d2c2c02c7bf479ec"
   integrity sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==
 
-q@^1.5.1:
-  version "1.5.1"
-  resolved "https://registry.npmjs.org/q/-/q-1.5.1.tgz#7e32f75b41381291d04611f1bf14109ac00651d7"
-  integrity sha1-fjL3W0E4EpHQRhHxvxQQmsAGUdc=
-
 qs@~6.4.0:
   version "6.4.0"
   resolved "https://registry.npmjs.org/qs/-/qs-6.4.0.tgz#13e26d28ad6b0ffaa91312cd3bf708ed351e7233"
@@ -5593,60 +3180,11 @@ qs@~6.5.2:
   resolved "https://registry.npmjs.org/qs/-/qs-6.5.2.tgz#cb3ae806e8740444584ef154ce8ee98d403f3e36"
   integrity sha512-N5ZAX4/LxJmF+7wN74pUD6qAh9/wnvdQcjq9TZjevvXzSUo7bfmw91saqMjzGS2xq91/odN2dW/WOl7qQHNDGA==
 
-quick-lru@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/quick-lru/-/quick-lru-1.1.0.tgz#4360b17c61136ad38078397ff11416e186dcfbb8"
-  integrity sha1-Q2CxfGETatOAeDl/8RQW4Ybc+7g=
-
 react-is@^16.8.4:
   version "16.13.0"
   resolved "https://registry.npmjs.org/react-is/-/react-is-16.13.0.tgz#0f37c3613c34fe6b37cd7f763a0d6293ab15c527"
   integrity sha512-GFMtL0vHkiBv9HluwNZTggSn/sCyEt9n02aM0dSAjGGyqyNlAyftYm4phPxdvCigG15JreC5biwxCgTAJZ7yAA==
 
-read-cmd-shim@^1.0.1:
-  version "1.0.5"
-  resolved "https://registry.npmjs.org/read-cmd-shim/-/read-cmd-shim-1.0.5.tgz#87e43eba50098ba5a32d0ceb583ab8e43b961c16"
-  integrity sha512-v5yCqQ/7okKoZZkBQUAfTsQ3sVJtXdNfbPnI5cceppoxEVLYA3k+VtV2omkeo8MS94JCy4fSiUwlRBAwCVRPUA==
-  dependencies:
-    graceful-fs "^4.1.2"
-
-"read-package-json@1 || 2", read-package-json@^2.0.0, read-package-json@^2.0.13:
-  version "2.1.1"
-  resolved "https://registry.npmjs.org/read-package-json/-/read-package-json-2.1.1.tgz#16aa66c59e7d4dad6288f179dd9295fd59bb98f1"
-  integrity sha512-dAiqGtVc/q5doFz6096CcnXhpYk0ZN8dEKVkGLU0CsASt8SrgF6SF7OTKAYubfvFhWaqofl+Y8HK19GR8jwW+A==
-  dependencies:
-    glob "^7.1.1"
-    json-parse-better-errors "^1.0.1"
-    normalize-package-data "^2.0.0"
-    npm-normalize-package-bin "^1.0.0"
-  optionalDependencies:
-    graceful-fs "^4.1.2"
-
-read-package-tree@^5.1.6:
-  version "5.3.1"
-  resolved "https://registry.npmjs.org/read-package-tree/-/read-package-tree-5.3.1.tgz#a32cb64c7f31eb8a6f31ef06f9cedf74068fe636"
-  integrity sha512-mLUDsD5JVtlZxjSlPPx1RETkNjjvQYuweKwNVt1Sn8kP5Jh44pvYuUHCp6xSVDZWbNxVxG5lyZJ921aJH61sTw==
-  dependencies:
-    read-package-json "^2.0.0"
-    readdir-scoped-modules "^1.0.0"
-    util-promisify "^2.1.0"
-
-read-pkg-up@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-1.0.1.tgz#9d63c13276c065918d57f002a57f40a1b643fb02"
-  integrity sha1-nWPBMnbAZZGNV/ACpX9AobZD+wI=
-  dependencies:
-    find-up "^1.0.0"
-    read-pkg "^1.0.0"
-
-read-pkg-up@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-3.0.0.tgz#3ed496685dba0f8fe118d0691dc51f4a1ff96f07"
-  integrity sha1-PtSWaF26D4/hGNBpHcUfSh/5bwc=
-  dependencies:
-    find-up "^2.0.0"
-    read-pkg "^3.0.0"
-
 read-pkg-up@^4.0.0:
   version "4.0.0"
   resolved "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-4.0.0.tgz#1b221c6088ba7799601c808f91161c66e58f8978"
@@ -5655,15 +3193,6 @@ read-pkg-up@^4.0.0:
     find-up "^3.0.0"
     read-pkg "^3.0.0"
 
-read-pkg@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/read-pkg/-/read-pkg-1.1.0.tgz#f5ffaa5ecd29cb31c0474bca7d756b6bb29e3f28"
-  integrity sha1-9f+qXs0pyzHAR0vKfXVra7KePyg=
-  dependencies:
-    load-json-file "^1.0.0"
-    normalize-package-data "^2.3.2"
-    path-type "^1.0.0"
-
 read-pkg@^3.0.0:
   version "3.0.0"
   resolved "https://registry.npmjs.org/read-pkg/-/read-pkg-3.0.0.tgz#9cbc686978fee65d16c00e2b19c237fcf6e38389"
@@ -5673,14 +3202,7 @@ read-pkg@^3.0.0:
     normalize-package-data "^2.3.2"
     path-type "^3.0.0"
 
-read@1, read@~1.0.1:
-  version "1.0.7"
-  resolved "https://registry.npmjs.org/read/-/read-1.0.7.tgz#b3da19bd052431a97671d44a42634adf710b40c4"
-  integrity sha1-s9oZvQUkMal2cdRKQmNK33ELQMQ=
-  dependencies:
-    mute-stream "~0.0.4"
-
-"readable-stream@1 || 2", readable-stream@^2.0.0, readable-stream@^2.0.6, readable-stream@^2.1.5, readable-stream@^2.2.2, readable-stream@^2.3.6, readable-stream@~2.3.6:
+readable-stream@^2.2.2:
   version "2.3.7"
   resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz#1eca1cf711aef814c04f62252a36a62f6cb23b57"
   integrity sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==
@@ -5693,25 +3215,6 @@ read@1, read@~1.0.1:
     string_decoder "~1.1.1"
     util-deprecate "~1.0.1"
 
-"readable-stream@2 || 3", readable-stream@^3.0.2:
-  version "3.6.0"
-  resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz#337bbda3adc0706bd3e024426a286d4b4b2c9198"
-  integrity sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==
-  dependencies:
-    inherits "^2.0.3"
-    string_decoder "^1.1.1"
-    util-deprecate "^1.0.1"
-
-readdir-scoped-modules@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/readdir-scoped-modules/-/readdir-scoped-modules-1.1.0.tgz#8d45407b4f870a0dcaebc0e28670d18e74514309"
-  integrity sha512-asaikDeqAQg7JifRsZn1NJZXo9E+VwlyCfbkZhwyISinqk5zNS6266HS5kah6P0SaQKGF6SkNnZVHUzHFYxYDw==
-  dependencies:
-    debuglog "^1.0.1"
-    dezalgo "^1.0.0"
-    graceful-fs "^4.1.2"
-    once "^1.3.0"
-
 realpath-native@^1.1.0:
   version "1.1.0"
   resolved "https://registry.npmjs.org/realpath-native/-/realpath-native-1.1.0.tgz#2003294fea23fb0672f2476ebe22fcf498a2d65c"
@@ -5719,22 +3222,6 @@ realpath-native@^1.1.0:
   dependencies:
     util.promisify "^1.0.0"
 
-redent@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/redent/-/redent-1.0.0.tgz#cf916ab1fd5f1f16dfb20822dd6ec7f730c2afde"
-  integrity sha1-z5Fqsf1fHxbfsggi3W7H9zDCr94=
-  dependencies:
-    indent-string "^2.1.0"
-    strip-indent "^1.0.1"
-
-redent@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/redent/-/redent-2.0.0.tgz#c1b2007b42d57eb1389079b3c8333639d5e1ccaa"
-  integrity sha1-wbIAe0LVfrE4kHmzyDM2OdXhzKo=
-  dependencies:
-    indent-string "^3.0.0"
-    strip-indent "^2.0.0"
-
 regenerator-runtime@^0.11.0:
   version "0.11.1"
   resolved "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz#be05ad7f9bf7d22e056f9726cee5017fbf19e2e9"
@@ -5763,13 +3250,6 @@ repeat-string@^1.5.2, repeat-string@^1.6.1:
   resolved "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637"
   integrity sha1-jcrkcOHIirwtYA//Sndihtp15jc=
 
-repeating@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.npmjs.org/repeating/-/repeating-2.0.1.tgz#5214c53a926d3552707527fbab415dbc08d06dda"
-  integrity sha1-UhTFOpJtNVJwdSf7q0FdvAjQbdo=
-  dependencies:
-    is-finite "^1.0.0"
-
 request-promise-core@1.1.3:
   version "1.1.3"
   resolved "https://registry.npmjs.org/request-promise-core/-/request-promise-core-1.1.3.tgz#e9a3c081b51380dfea677336061fea879a829ee9"
@@ -5845,6 +3325,11 @@ require-directory@^2.1.1:
   resolved "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42"
   integrity sha1-jGStX9MNqxyXbiNE/+f3kqam30I=
 
+require-main-filename@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/require-main-filename/-/require-main-filename-1.0.1.tgz#97f717b69d48784f5f526a6c5aa8ffdda055a4d1"
+  integrity sha1-l/cXtp1IeE9fUmpsWqj/3aBVpNE=
+
 require-main-filename@^2.0.0:
   version "2.0.0"
   resolved "https://registry.npmjs.org/require-main-filename/-/require-main-filename-2.0.0.tgz#d0b329ecc7cc0f61649f62215be69af54aa8989b"
@@ -5862,11 +3347,6 @@ resolve-from@^3.0.0:
   resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-3.0.0.tgz#b22c7af7d9d6881bc8b6e653335eebcb0a188748"
   integrity sha1-six699nWiBvItuZTM17rywoYh0g=
 
-resolve-from@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6"
-  integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==
-
 resolve-url@^0.2.1:
   version "0.2.1"
   resolved "https://registry.npmjs.org/resolve-url/-/resolve-url-0.2.1.tgz#2c637fe77c893afd2a663fe21aa9080068e2052a"
@@ -5884,24 +3364,11 @@ resolve@^1.10.0, resolve@^1.15.1, resolve@^1.3.2:
   dependencies:
     path-parse "^1.0.6"
 
-restore-cursor@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/restore-cursor/-/restore-cursor-2.0.0.tgz#9f7ee287f82fd326d4fd162923d62129eee0dfaf"
-  integrity sha1-n37ih/gv0ybU/RYpI9YhKe7g368=
-  dependencies:
-    onetime "^2.0.0"
-    signal-exit "^3.0.2"
-
 ret@~0.1.10:
   version "0.1.15"
   resolved "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz#b8a4825d5bdb1fc3f6f53c2bc33f81388681c7bc"
   integrity sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==
 
-retry@^0.10.0:
-  version "0.10.1"
-  resolved "https://registry.npmjs.org/retry/-/retry-0.10.1.tgz#e76388d217992c252750241d3d3956fed98d8ff4"
-  integrity sha1-52OI0heZLCUnUCQdPTlW/tmNj/Q=
-
 right-align@^0.1.1:
   version "0.1.3"
   resolved "https://registry.npmjs.org/right-align/-/right-align-0.1.3.tgz#61339b722fe6a3515689210d24e14c96148613ef"
@@ -5909,7 +3376,7 @@ right-align@^0.1.1:
   dependencies:
     align-text "^0.1.1"
 
-rimraf@2, rimraf@^2.5.4, rimraf@^2.6.2, rimraf@^2.6.3:
+rimraf@2, rimraf@^2.5.4, rimraf@^2.6.3:
   version "2.7.1"
   resolved "https://registry.npmjs.org/rimraf/-/rimraf-2.7.1.tgz#35797f13a7fdadc566142c29d4f07ccad483e3ec"
   integrity sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==
@@ -5928,28 +3395,7 @@ rsvp@^4.8.4:
   resolved "https://registry.npmjs.org/rsvp/-/rsvp-4.8.5.tgz#c8f155311d167f68f21e168df71ec5b083113734"
   integrity sha512-nfMOlASu9OnRJo1mbEk2cz0D56a1MBNrJ7orjRZQG10XDyuvwksKbuXNp6qa+kbn839HwjwhBzhFmdsaEAfauA==
 
-run-async@^2.2.0:
-  version "2.4.0"
-  resolved "https://registry.npmjs.org/run-async/-/run-async-2.4.0.tgz#e59054a5b86876cfae07f431d18cbaddc594f1e8"
-  integrity sha512-xJTbh/d7Lm7SBhc1tNvTpeCHaEzoyxPrqNlvSdMfBTYwaY++UJFyXUOxAtsRUXjlqOfj8luNaR9vjCh4KeV+pg==
-  dependencies:
-    is-promise "^2.1.0"
-
-run-queue@^1.0.0, run-queue@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/run-queue/-/run-queue-1.0.3.tgz#e848396f057d223f24386924618e25694161ec47"
-  integrity sha1-6Eg5bwV9Ij8kOGkkYY4laUFh7Ec=
-  dependencies:
-    aproba "^1.1.1"
-
-rxjs@^6.4.0:
-  version "6.5.4"
-  resolved "https://registry.npmjs.org/rxjs/-/rxjs-6.5.4.tgz#e0777fe0d184cec7872df147f303572d414e211c"
-  integrity sha512-naMQXcgEo3csAEGvw/NydRA0fuS2nDZJiw1YUWFKU7aPPAPGZEsD4Iimit96qwCieH6y614MCLYwdkrWx7z/7Q==
-  dependencies:
-    tslib "^1.9.0"
-
-safe-buffer@^5.0.1, safe-buffer@^5.1.1, safe-buffer@^5.1.2, safe-buffer@^5.2.0, safe-buffer@~5.2.0:
+safe-buffer@^5.0.1, safe-buffer@^5.1.2:
   version "5.2.0"
   resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.0.tgz#b74daec49b1148f88c64b68d49b1e815c1f2f519"
   integrity sha512-fZEwUGbVl7kouZs1jCdMLdt95hdIv0ZeHg6L7qPeciMZhZ+/gdesW4wgTARkrFWEpspjEATAzUGPG8N2jJiwbg==
@@ -5996,7 +3442,7 @@ sax@^1.2.4:
   resolved "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz#2816234e2378bddc4e5354fab5caa895df7100d9"
   integrity sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==
 
-"semver@2 || 3 || 4 || 5", "semver@2.x || 3.x || 4 || 5", semver@^5.4.1, semver@^5.5.0, semver@^5.5.1, semver@^5.6.0, semver@^5.7.0, semver@^5.7.1:
+"semver@2 || 3 || 4 || 5", semver@^5.4.1, semver@^5.5.0, semver@^5.6.0:
   version "5.7.1"
   resolved "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz#a954f931aeba508d307bbf069eff0c01c96116f7"
   integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==
@@ -6006,7 +3452,7 @@ semver@^6.0.0, semver@^6.2.0:
   resolved "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d"
   integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==
 
-set-blocking@^2.0.0, set-blocking@~2.0.0:
+set-blocking@^2.0.0:
   version "2.0.0"
   resolved "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz#045f9782d011ae9a6803ddd382b24392b3d890f7"
   integrity sha1-BF+XgtARrppoA93TgrJDkrPYkPc=
@@ -6021,15 +3467,6 @@ set-value@^2.0.0, set-value@^2.0.1:
     is-plain-object "^2.0.3"
     split-string "^3.0.1"
 
-shallow-clone@2.0.0, shallow-clone@^3.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/shallow-clone/-/shallow-clone-2.0.0.tgz#5d0f491e313686b2f53660b8859ca33684f18d20"
-  integrity sha512-M0ikAzIEgiQqFG8gkkuM+sOiVVNSza7VjcvP+WfB8HvYccIFDKt0YIwlx0bbLsD4eiya8ARd0rznCbES9fXMqA==
-  dependencies:
-    is-extendable "^1.0.1"
-    kind-of "^6.0.0"
-    mixin-object "^3.0.0"
-
 shebang-command@^1.2.0:
   version "1.2.0"
   resolved "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz#44aac65b695b03398968c39f363fee5deafdf1ea"
@@ -6062,16 +3499,6 @@ slash@^2.0.0:
   resolved "https://registry.npmjs.org/slash/-/slash-2.0.0.tgz#de552851a1759df3a8f206535442f5ec4ddeab44"
   integrity sha512-ZYKh3Wh2z1PpEXWr0MpSBZ0V6mZHAQfYevttO11c51CaWjGTaadiKZ+wVt1PbMlDV5qhMFslpZCemhwOK7C89A==
 
-slide@^1.1.6:
-  version "1.1.6"
-  resolved "https://registry.npmjs.org/slide/-/slide-1.1.6.tgz#56eb027d65b4d2dce6cb2e2d32c4d4afc9e1d707"
-  integrity sha1-VusCfWW00tzmyy4tMsTUr8nh1wc=
-
-smart-buffer@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.1.0.tgz#91605c25d91652f4661ea69ccf45f1b331ca21ba"
-  integrity sha512-iVICrxOzCynf/SNaBQCw34eM9jROU/s5rzIhpOvzhzuYHfJR/DhZfDkXiZSgKXfgv26HT3Yni3AV/DGw0cGnnw==
-
 snapdragon-node@^2.0.1:
   version "2.1.1"
   resolved "https://registry.npmjs.org/snapdragon-node/-/snapdragon-node-2.1.1.tgz#6c175f86ff14bdb0724563e8f3c1b021a286853b"
@@ -6109,29 +3536,6 @@ sntp@1.x.x:
   dependencies:
     hoek "2.x.x"
 
-socks-proxy-agent@^4.0.0:
-  version "4.0.2"
-  resolved "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-4.0.2.tgz#3c8991f3145b2799e70e11bd5fbc8b1963116386"
-  integrity sha512-NT6syHhI9LmuEMSK6Kd2V7gNv5KFZoLE7V5udWmn0de+3Mkj3UMA/AJPLyeNUVmElCurSHtUdM3ETpR3z770Wg==
-  dependencies:
-    agent-base "~4.2.1"
-    socks "~2.3.2"
-
-socks@~2.3.2:
-  version "2.3.3"
-  resolved "https://registry.npmjs.org/socks/-/socks-2.3.3.tgz#01129f0a5d534d2b897712ed8aceab7ee65d78e3"
-  integrity sha512-o5t52PCNtVdiOvzMry7wU4aOqYWL0PeCXRWBEiJow4/i/wr+wpsJQ9awEu1EonLIqsfGd5qSgDdxEOvCdmBEpA==
-  dependencies:
-    ip "1.1.5"
-    smart-buffer "^4.1.0"
-
-sort-keys@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/sort-keys/-/sort-keys-2.0.0.tgz#658535584861ec97d730d6cf41822e1f56684128"
-  integrity sha1-ZYU1WEhh7JfXMNbPQYIuH1ZoQSg=
-  dependencies:
-    is-plain-obj "^1.0.0"
-
 source-map-resolve@^0.5.0:
   version "0.5.3"
   resolved "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.3.tgz#190866bece7553e1f8f267a2ee82c606b5509a1a"
@@ -6206,16 +3610,9 @@ split-string@^3.0.1, split-string@^3.0.2:
   dependencies:
     extend-shallow "^3.0.0"
 
-split2@^2.0.0:
-  version "2.2.0"
-  resolved "https://registry.npmjs.org/split2/-/split2-2.2.0.tgz#186b2575bcf83e85b7d18465756238ee4ee42493"
-  integrity sha512-RAb22TG39LhI31MbreBgIuKiIKhVsawfTgEGqKHTK87aG+ul/PB8Sqoi3I7kVdRWiCfrKxK3uo4/YUkpNvhPbw==
-  dependencies:
-    through2 "^2.0.2"
-
-split@^1.0.0:
+split@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/split/-/split-1.0.1.tgz#605bd9be303aa59fb35f9229fbea0ddec9ea07d9"
+  resolved "https://registry.yarnpkg.com/split/-/split-1.0.1.tgz#605bd9be303aa59fb35f9229fbea0ddec9ea07d9"
   integrity sha512-mTyOoPbrivtXnwnIxZRFYRrPNtEFKlpB2fvjSnCQUiAA6qAZzqwna5envK4uk6OIeP17CsdF3rSBGYVBsU0Tkg==
   dependencies:
     through "2"
@@ -6240,13 +3637,6 @@ sshpk@^1.7.0:
     safer-buffer "^2.0.2"
     tweetnacl "~0.14.0"
 
-ssri@^6.0.0, ssri@^6.0.1:
-  version "6.0.1"
-  resolved "https://registry.npmjs.org/ssri/-/ssri-6.0.1.tgz#2a3c41b28dd45b62b63676ecb74001265ae9edd8"
-  integrity sha512-3Wge10hNcT1Kur4PDFwEieXSCMCJs/7WvSACcrMYrNp+b8kDL1/0wJch5Ni2WrtwEa2IO8OsVfeKIciKCDx/QA==
-  dependencies:
-    figgy-pudding "^3.5.1"
-
 stack-utils@^1.0.1:
   version "1.0.2"
   resolved "https://registry.npmjs.org/stack-utils/-/stack-utils-1.0.2.tgz#33eba3897788558bebfc2db059dc158ec36cebb8"
@@ -6265,19 +3655,6 @@ stealthy-require@^1.1.1:
   resolved "https://registry.npmjs.org/stealthy-require/-/stealthy-require-1.1.1.tgz#35b09875b4ff49f26a777e509b3090a3226bf24b"
   integrity sha1-NbCYdbT/SfJqd35QmzCQoyJr8ks=
 
-stream-each@^1.1.0:
-  version "1.2.3"
-  resolved "https://registry.npmjs.org/stream-each/-/stream-each-1.2.3.tgz#ebe27a0c389b04fbcc233642952e10731afa9bae"
-  integrity sha512-vlMC2f8I2u/bZGqkdfLQW/13Zihpej/7PmSiMQsbYddxuTsJp8vRe2x2FvVExZg7FaOds43ROAuFJwPR4MTZLw==
-  dependencies:
-    end-of-stream "^1.1.0"
-    stream-shift "^1.0.0"
-
-stream-shift@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.1.tgz#d7088281559ab2778424279b0877da3c392d5a3d"
-  integrity sha512-AiisoFqQ0vbGcZgQPY1cdP2I76glaVA/RauYR4G4thNFgkTqr90yXTo4LYX60Jl+sIlPNHHdGSwo01AvbKUSVQ==
-
 string-length@^2.0.0:
   version "2.0.0"
   resolved "https://registry.npmjs.org/string-length/-/string-length-2.0.0.tgz#d40dbb686a3ace960c1cffca562bf2c45f8363ed"
@@ -6288,16 +3665,16 @@ string-length@^2.0.0:
 
 string-width@^1.0.1:
   version "1.0.2"
-  resolved "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz#118bdf5b8cdc51a2a7e70d211e07e2b0b9b107d3"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-1.0.2.tgz#118bdf5b8cdc51a2a7e70d211e07e2b0b9b107d3"
   integrity sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=
   dependencies:
     code-point-at "^1.0.0"
     is-fullwidth-code-point "^1.0.0"
     strip-ansi "^3.0.0"
 
-"string-width@^1.0.2 || 2", string-width@^2.1.0:
+string-width@^2.0.0, string-width@^2.1.1:
   version "2.1.1"
-  resolved "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz#ab93f27a8dc13d28cac815c462143a6d9012ae9e"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-2.1.1.tgz#ab93f27a8dc13d28cac815c462143a6d9012ae9e"
   integrity sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==
   dependencies:
     is-fullwidth-code-point "^2.0.0"
@@ -6328,13 +3705,6 @@ string.prototype.trimright@^2.1.1:
     define-properties "^1.1.3"
     function-bind "^1.1.1"
 
-string_decoder@^1.1.1:
-  version "1.3.0"
-  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e"
-  integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==
-  dependencies:
-    safe-buffer "~5.2.0"
-
 string_decoder@~1.1.1:
   version "1.1.1"
   resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz#9cf1611ba62685d7030ae9e4ba34149c3af03fc8"
@@ -6349,7 +3719,7 @@ stringstream@~0.0.4:
 
 strip-ansi@^3.0.0, strip-ansi@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz#6a385fb8853d952d5ff05d0e8aaf94278dc63dcf"
+  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-3.0.1.tgz#6a385fb8853d952d5ff05d0e8aaf94278dc63dcf"
   integrity sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=
   dependencies:
     ansi-regex "^2.0.0"
@@ -6368,13 +3738,6 @@ strip-ansi@^5.0.0, strip-ansi@^5.1.0, strip-ansi@^5.2.0:
   dependencies:
     ansi-regex "^4.1.0"
 
-strip-bom@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/strip-bom/-/strip-bom-2.0.0.tgz#6219a85616520491f35788bdbf1447a99c7e6b0e"
-  integrity sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=
-  dependencies:
-    is-utf8 "^0.2.0"
-
 strip-bom@^3.0.0:
   version "3.0.0"
   resolved "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz#2334c18e9c759f7bdd56fdef7e9ae3d588e68ed3"
@@ -6385,28 +3748,7 @@ strip-eof@^1.0.0:
   resolved "https://registry.npmjs.org/strip-eof/-/strip-eof-1.0.0.tgz#bb43ff5598a6eb05d89b59fcd129c983313606bf"
   integrity sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=
 
-strip-indent@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/strip-indent/-/strip-indent-1.0.1.tgz#0c7962a6adefa7bbd4ac366460a638552ae1a0a2"
-  integrity sha1-DHlipq3vp7vUrDZkYKY4VSrhoKI=
-  dependencies:
-    get-stdin "^4.0.1"
-
-strip-indent@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/strip-indent/-/strip-indent-2.0.0.tgz#5ef8db295d01e6ed6cbf7aab96998d7822527b68"
-  integrity sha1-XvjbKV0B5u1sv3qrlpmNeCJSe2g=
-
-strong-log-transformer@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/strong-log-transformer/-/strong-log-transformer-2.1.0.tgz#0f5ed78d325e0421ac6f90f7f10e691d6ae3ae10"
-  integrity sha512-B3Hgul+z0L9a236FAUC9iZsL+nVHgoCJnqCbN588DjYxvGXaXaaFbfmQ/JhvKjZwsOukuR72XbHv71Qkug0HxA==
-  dependencies:
-    duplexer "^0.1.1"
-    minimist "^1.2.0"
-    through "^2.3.4"
-
-stylus@0.54.5, stylus@~0.54.5:
+stylus@~0.54.5:
   version "0.54.5"
   resolved "https://registry.npmjs.org/stylus/-/stylus-0.54.5.tgz#42b9560931ca7090ce8515a798ba9e6aa3d6dc79"
   integrity sha1-QrlWCTHKcJDOhRWnmLqeaqPW3Hk=
@@ -6446,36 +3788,6 @@ tar@^1.0.3:
     fstream "^1.0.2"
     inherits "2"
 
-tar@^4.4.10, tar@^4.4.12, tar@^4.4.8:
-  version "4.4.13"
-  resolved "https://registry.npmjs.org/tar/-/tar-4.4.13.tgz#43b364bc52888d555298637b10d60790254ab525"
-  integrity sha512-w2VwSrBoHa5BsSyH+KxEqeQBAllHhccyMFVHtGtdMpF4W7IRWfZjFiQceJPChOeTsSDVUpER2T8FA93pr0L+QA==
-  dependencies:
-    chownr "^1.1.1"
-    fs-minipass "^1.2.5"
-    minipass "^2.8.6"
-    minizlib "^1.2.1"
-    mkdirp "^0.5.0"
-    safe-buffer "^5.1.2"
-    yallist "^3.0.3"
-
-temp-dir@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/temp-dir/-/temp-dir-1.0.0.tgz#0a7c0ea26d3a39afa7e0ebea9c1fc0bc4daa011d"
-  integrity sha1-CnwOom06Oa+n4OvqnB/AvE2qAR0=
-
-temp-write@^3.4.0:
-  version "3.4.0"
-  resolved "https://registry.npmjs.org/temp-write/-/temp-write-3.4.0.tgz#8cff630fb7e9da05f047c74ce4ce4d685457d492"
-  integrity sha1-jP9jD7fp2gXwR8dM5M5NaFRX1JI=
-  dependencies:
-    graceful-fs "^4.1.2"
-    is-stream "^1.1.0"
-    make-dir "^1.0.0"
-    pify "^3.0.0"
-    temp-dir "^1.0.0"
-    uuid "^3.0.1"
-
 test-exclude@^5.2.3:
   version "5.2.3"
   resolved "https://registry.npmjs.org/test-exclude/-/test-exclude-5.2.3.tgz#c3d3e1e311eb7ee405e092dac10aefd09091eac0"
@@ -6486,57 +3798,16 @@ test-exclude@^5.2.3:
     read-pkg-up "^4.0.0"
     require-main-filename "^2.0.0"
 
-text-extensions@^1.0.0:
-  version "1.9.0"
-  resolved "https://registry.npmjs.org/text-extensions/-/text-extensions-1.9.0.tgz#1853e45fee39c945ce6f6c36b2d659b5aabc2a26"
-  integrity sha512-wiBrwC1EhBelW12Zy26JeOUkQ5mRu+5o8rpsJk5+2t+Y5vE7e842qtZDQ2g1NpX/29HdyFeJ4nSIhI47ENSxlQ==
-
-thenify-all@^1.0.0:
-  version "1.6.0"
-  resolved "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz#1a1918d402d8fc3f98fbf234db0bcc8cc10e9726"
-  integrity sha1-GhkY1ALY/D+Y+/I02wvMjMEOlyY=
-  dependencies:
-    thenify ">= 3.1.0 < 4"
-
-"thenify@>= 3.1.0 < 4":
-  version "3.3.0"
-  resolved "https://registry.npmjs.org/thenify/-/thenify-3.3.0.tgz#e69e38a1babe969b0108207978b9f62b88604839"
-  integrity sha1-5p44obq+lpsBCCB5eLn2K4hgSDk=
-  dependencies:
-    any-promise "^1.0.0"
-
-throat@^4.0.0:
+throat@^4.0.0, throat@^4.1.0:
   version "4.1.0"
   resolved "https://registry.npmjs.org/throat/-/throat-4.1.0.tgz#89037cbc92c56ab18926e6ba4cbb200e15672a6a"
   integrity sha1-iQN8vJLFarGJJua6TLsgDhVnKmo=
 
-through2@^2.0.0, through2@^2.0.2:
-  version "2.0.5"
-  resolved "https://registry.npmjs.org/through2/-/through2-2.0.5.tgz#01c1e39eb31d07cb7d03a96a70823260b23132cd"
-  integrity sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==
-  dependencies:
-    readable-stream "~2.3.6"
-    xtend "~4.0.1"
-
-through2@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.npmjs.org/through2/-/through2-3.0.1.tgz#39276e713c3302edf9e388dd9c812dd3b825bd5a"
-  integrity sha512-M96dvTalPT3YbYLaKaCuwu+j06D/8Jfib0o/PxbVt6Amhv3dUAtW6rTV1jPgJSBG83I/e04Y6xkVdVhSRhi0ww==
-  dependencies:
-    readable-stream "2 || 3"
-
-through@2, "through@>=2.2.7 <3", through@^2.3.4, through@^2.3.6:
+through@2:
   version "2.3.8"
-  resolved "https://registry.npmjs.org/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5"
+  resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5"
   integrity sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=
 
-tmp@^0.0.33:
-  version "0.0.33"
-  resolved "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz#6d34335889768d21b2bcda0aa277ced3b1bfadf9"
-  integrity sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==
-  dependencies:
-    os-tmpdir "~1.0.2"
-
 tmpl@1.0.x:
   version "1.0.4"
   resolved "https://registry.npmjs.org/tmpl/-/tmpl-1.0.4.tgz#23640dd7b42d00433911140820e5cf440e521dd1"
@@ -6604,26 +3875,6 @@ tr46@^1.0.1:
   dependencies:
     punycode "^2.1.0"
 
-trim-newlines@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/trim-newlines/-/trim-newlines-1.0.0.tgz#5887966bb582a4503a41eb524f7d35011815a613"
-  integrity sha1-WIeWa7WCpFA6QetST301ARgVphM=
-
-trim-newlines@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/trim-newlines/-/trim-newlines-2.0.0.tgz#b403d0b91be50c331dfc4b82eeceb22c3de16d20"
-  integrity sha1-tAPQuRvlDDMd/EuC7s6yLD3hbSA=
-
-trim-off-newlines@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/trim-off-newlines/-/trim-off-newlines-1.0.1.tgz#9f9ba9d9efa8764c387698bcbfeb2c848f11adb3"
-  integrity sha1-n5up2e+odkw4dpi8v+sshI8RrbM=
-
-tslib@^1.9.0:
-  version "1.11.1"
-  resolved "https://registry.npmjs.org/tslib/-/tslib-1.11.1.tgz#eb15d128827fbee2841549e171f45ed338ac7e35"
-  integrity sha512-aZW88SY8kQbU7gpV19lN24LtXh/yD4ZZg6qieAJDDg+YBsJcSmLGK9QpnUjAKVG/xefmvJGd1WUmfpT/g6AJGA==
-
 tunnel-agent@^0.6.0:
   version "0.6.0"
   resolved "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz#27a5dea06b36b04a0a9966774b290868f0fc40fd"
@@ -6643,11 +3894,6 @@ type-check@~0.3.2:
   dependencies:
     prelude-ls "~1.1.2"
 
-type-fest@^0.3.0:
-  version "0.3.1"
-  resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.3.1.tgz#63d00d204e059474fe5e1b7c011112bbd1dc29e1"
-  integrity sha512-cUGJnCdr4STbePCgqNFbpVNCepa+kAVohJs1sLhxzdH+gnEoOd8VhbYa7pD3zZYGiURWM2xzEII3fQcRizDkYQ==
-
 typedarray@^0.0.6:
   version "0.0.6"
   resolved "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777"
@@ -6668,14 +3914,6 @@ uglify-js@^2.6.1, uglify-js@^2.8.10:
   optionalDependencies:
     uglify-to-browserify "~1.0.0"
 
-uglify-js@^3.1.4:
-  version "3.8.0"
-  resolved "https://registry.npmjs.org/uglify-js/-/uglify-js-3.8.0.tgz#f3541ae97b2f048d7e7e3aa4f39fd8a1f5d7a805"
-  integrity sha512-ugNSTT8ierCsDHso2jkBHXYrU8Y5/fY2ZUprfrJUiD7YpuFvV4jODLFmb3h4btQjqr5Nh4TX4XtgDfCU1WdioQ==
-  dependencies:
-    commander "~2.20.3"
-    source-map "~0.6.1"
-
 "uglify-js@github:mishoo/UglifyJS2#1c15d0db456ce32f1b9b507aad97e5ee5c8285f7":
   version "2.7.3"
   resolved "https://codeload.github.com/mishoo/UglifyJS2/tar.gz/1c15d0db456ce32f1b9b507aad97e5ee5c8285f7"
@@ -6690,16 +3928,6 @@ uglify-to-browserify@~1.0.0:
   resolved "https://registry.npmjs.org/uglify-to-browserify/-/uglify-to-browserify-1.0.2.tgz#6e0924d6bda6b5afe349e39a6d632850a0f882b7"
   integrity sha1-bgkk1r2mta/jSeOabWMoUKD4grc=
 
-uid-number@0.0.6:
-  version "0.0.6"
-  resolved "https://registry.npmjs.org/uid-number/-/uid-number-0.0.6.tgz#0ea10e8035e8eb5b8e4449f06da1c730663baa81"
-  integrity sha1-DqEOgDXo61uOREnwbaHHMGY7qoE=
-
-umask@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/umask/-/umask-1.1.0.tgz#f29cebf01df517912bb58ff9c4e50fde8e33320d"
-  integrity sha1-8pzr8B31F5ErtY/5xOUP3o4zMg0=
-
 union-value@^1.0.0:
   version "1.0.1"
   resolved "https://registry.npmjs.org/union-value/-/union-value-1.0.1.tgz#0b6fe7b835aecda61c6ea4d4f02c14221e109847"
@@ -6710,39 +3938,6 @@ union-value@^1.0.0:
     is-extendable "^0.1.1"
     set-value "^2.0.1"
 
-unique-filename@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.npmjs.org/unique-filename/-/unique-filename-1.1.1.tgz#1d69769369ada0583103a1e6ae87681b56573230"
-  integrity sha512-Vmp0jIp2ln35UTXuryvjzkjGdRyf9b2lTXuSYUiPmzRcl3FDtYqAwOnTJkAngD9SWhnoJzDbTKwaOrZ+STtxNQ==
-  dependencies:
-    unique-slug "^2.0.0"
-
-unique-slug@^2.0.0:
-  version "2.0.2"
-  resolved "https://registry.npmjs.org/unique-slug/-/unique-slug-2.0.2.tgz#baabce91083fc64e945b0f3ad613e264f7cd4e6c"
-  integrity sha512-zoWr9ObaxALD3DOPfjPSqxt4fnZiWblxHIgeWqW8x7UqDzEtHEQLzji2cuJYQFCU6KmoJikOYAZlrTHHebjx2w==
-  dependencies:
-    imurmurhash "^0.1.4"
-
-universal-user-agent@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-4.0.1.tgz#fd8d6cb773a679a709e967ef8288a31fcc03e557"
-  integrity sha512-LnST3ebHwVL2aNe4mejI9IQh2HfZ1RLo8Io2HugSif8ekzD1TlWpHpColOB/eh8JHMLkGH3Akqf040I+4ylNxg==
-  dependencies:
-    os-name "^3.1.0"
-
-universal-user-agent@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-5.0.0.tgz#a3182aa758069bf0e79952570ca757de3579c1d9"
-  integrity sha512-B5TPtzZleXyPrUMKCpEHFmVhMN6EhmJYjG5PQna9s7mXeSqGTLap4OpqLl5FCEFUI3UBmllkETwKf/db66Y54Q==
-  dependencies:
-    os-name "^3.1.0"
-
-universalify@^0.1.0:
-  version "0.1.2"
-  resolved "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz#b646f69be3942dabcecc9d6639c80dc105efaa66"
-  integrity sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==
-
 unset-value@^1.0.0:
   version "1.0.0"
   resolved "https://registry.npmjs.org/unset-value/-/unset-value-1.0.0.tgz#8376873f7d2335179ffb1e6fc3a8ed0dfc8ab559"
@@ -6751,11 +3946,6 @@ unset-value@^1.0.0:
     has-value "^0.3.1"
     isobject "^3.0.0"
 
-upath@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.npmjs.org/upath/-/upath-1.2.0.tgz#8f66dbcd55a883acdae4408af8b035a5044c1894"
-  integrity sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==
-
 uri-js@^4.2.2:
   version "4.2.2"
   resolved "https://registry.npmjs.org/uri-js/-/uri-js-4.2.2.tgz#94c540e1ff772956e2299507c010aea6c8838eb0"
@@ -6773,18 +3963,11 @@ use@^3.1.0:
   resolved "https://registry.npmjs.org/use/-/use-3.1.1.tgz#d50c8cac79a19fbc20f2911f56eb973f4e10070f"
   integrity sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==
 
-util-deprecate@^1.0.1, util-deprecate@~1.0.1:
+util-deprecate@~1.0.1:
   version "1.0.2"
   resolved "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
   integrity sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=
 
-util-promisify@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/util-promisify/-/util-promisify-2.1.0.tgz#3c2236476c4d32c5ff3c47002add7c13b9a82a53"
-  integrity sha1-PCI2R2xNMsX/PEcAKt18E7moKlM=
-  dependencies:
-    object.getownpropertydescriptors "^2.0.3"
-
 util.promisify@^1.0.0:
   version "1.0.1"
   resolved "https://registry.npmjs.org/util.promisify/-/util.promisify-1.0.1.tgz#6baf7774b80eeb0f7520d8b81d07982a59abbaee"
@@ -6795,12 +3978,12 @@ util.promisify@^1.0.0:
     has-symbols "^1.0.1"
     object.getownpropertydescriptors "^2.1.0"
 
-uuid@^3.0.0, uuid@^3.0.1, uuid@^3.3.2:
+uuid@^3.0.0, uuid@^3.3.2:
   version "3.4.0"
   resolved "https://registry.npmjs.org/uuid/-/uuid-3.4.0.tgz#b23e4358afa8a202fe7a100af1f5f883f02007ee"
   integrity sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==
 
-validate-npm-package-license@^3.0.1, validate-npm-package-license@^3.0.3:
+validate-npm-package-license@^3.0.1:
   version "3.0.4"
   resolved "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz#fc91f6b9c7ba15c857f4cb2c5defeec39d4f410a"
   integrity sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==
@@ -6808,13 +3991,6 @@ validate-npm-package-license@^3.0.1, validate-npm-package-license@^3.0.3:
     spdx-correct "^3.0.0"
     spdx-expression-parse "^3.0.0"
 
-validate-npm-package-name@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/validate-npm-package-name/-/validate-npm-package-name-3.0.0.tgz#5fa912d81eb7d0c74afc140de7317f0ca7df437e"
-  integrity sha1-X6kS2B630MdK/BQN5zF/DKffQ34=
-  dependencies:
-    builtins "^1.0.3"
-
 verror@1.10.0:
   version "1.10.0"
   resolved "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz#3a105ca17053af55d6e270c1f8288682e18da400"
@@ -6843,13 +4019,6 @@ walker@^1.0.7, walker@~1.0.5:
   dependencies:
     makeerror "1.0.x"
 
-wcwidth@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/wcwidth/-/wcwidth-1.0.1.tgz#f0b0dcf915bc5ff1528afadb2c0e17b532da2fe8"
-  integrity sha1-8LDc+RW8X/FSivrbLA4XtTLaL+g=
-  dependencies:
-    defaults "^1.0.3"
-
 webidl-conversions@^4.0.2:
   version "4.0.2"
   resolved "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-4.0.2.tgz#a855980b1f0b6b359ba1d5d9fb39ae941faa63ad"
@@ -6890,32 +4059,18 @@ which-module@^2.0.0:
   resolved "https://registry.npmjs.org/which-module/-/which-module-2.0.0.tgz#d9ef07dce77b9902b8a3a8fa4b31c3e3f7e6e87a"
   integrity sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho=
 
-which@^1.2.9, which@^1.3.0, which@^1.3.1:
+which@^1.2.9, which@^1.3.0:
   version "1.3.1"
   resolved "https://registry.npmjs.org/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
   integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
   dependencies:
     isexe "^2.0.0"
 
-wide-align@^1.1.0:
-  version "1.1.3"
-  resolved "https://registry.npmjs.org/wide-align/-/wide-align-1.1.3.tgz#ae074e6bdc0c14a431e804e624549c633b000457"
-  integrity sha512-QGkOQc8XL6Bt5PwnsExKBPuMKBxnGxWWW3fU55Xt4feHozMUhdUMaBCk290qpm/wG5u/RSKzwdAC4i51YigihA==
-  dependencies:
-    string-width "^1.0.2 || 2"
-
 window-size@0.1.0:
   version "0.1.0"
   resolved "https://registry.npmjs.org/window-size/-/window-size-0.1.0.tgz#5438cd2ea93b202efa3a19fe8887aee7c94f9c9d"
   integrity sha1-VDjNLqk7IC76Ohn+iIeu58lPnJ0=
 
-windows-release@^3.1.0:
-  version "3.2.0"
-  resolved "https://registry.npmjs.org/windows-release/-/windows-release-3.2.0.tgz#8122dad5afc303d833422380680a79cdfa91785f"
-  integrity sha512-QTlz2hKLrdqukrsapKsINzqMgOUpQW268eJ0OaOpJN32h272waxR9fkB9VoWRtK7uKHG5EHJcTXQBD8XZVJkFA==
-  dependencies:
-    execa "^1.0.0"
-
 with@^6.0.0:
   version "6.0.0"
   resolved "https://registry.npmjs.org/with/-/with-6.0.0.tgz#00223660fa0d0aeb4776965e61f902410c4c9d86"
@@ -6936,10 +4091,13 @@ wordwrap@0.0.2:
   resolved "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.2.tgz#b79669bb42ecb409f83d583cad52ca17eaa1643f"
   integrity sha1-t5Zpu0LstAn4PVg8rVLKF+qhZD8=
 
-wordwrap@~0.0.2:
-  version "0.0.3"
-  resolved "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.3.tgz#a3d5da6cd5c0bc0008d37234bbaf1bed63059107"
-  integrity sha1-o9XabNXAvAAI03I0u68b7WMFkQc=
+wrap-ansi@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-2.1.0.tgz#d8fc3d284dd05794fe84973caecdd1cf824fdd85"
+  integrity sha1-2Pw9KE3QV5T+hJc8rs3Rz4JP3YU=
+  dependencies:
+    string-width "^1.0.1"
+    strip-ansi "^3.0.1"
 
 wrap-ansi@^5.1.0:
   version "5.1.0"
@@ -6964,47 +4122,6 @@ write-file-atomic@2.4.1:
     imurmurhash "^0.1.4"
     signal-exit "^3.0.2"
 
-write-file-atomic@^2.0.0, write-file-atomic@^2.3.0, write-file-atomic@^2.4.2:
-  version "2.4.3"
-  resolved "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-2.4.3.tgz#1fd2e9ae1df3e75b8d8c367443c692d4ca81f481"
-  integrity sha512-GaETH5wwsX+GcnzhPgKcKjJ6M2Cq3/iZp1WyY/X1CSqrW+jVNM9Y7D8EC2sM4ZG/V8wZlSniJnCKWPmBYAucRQ==
-  dependencies:
-    graceful-fs "^4.1.11"
-    imurmurhash "^0.1.4"
-    signal-exit "^3.0.2"
-
-write-json-file@^2.2.0:
-  version "2.3.0"
-  resolved "https://registry.npmjs.org/write-json-file/-/write-json-file-2.3.0.tgz#2b64c8a33004d54b8698c76d585a77ceb61da32f"
-  integrity sha1-K2TIozAE1UuGmMdtWFp3zrYdoy8=
-  dependencies:
-    detect-indent "^5.0.0"
-    graceful-fs "^4.1.2"
-    make-dir "^1.0.0"
-    pify "^3.0.0"
-    sort-keys "^2.0.0"
-    write-file-atomic "^2.0.0"
-
-write-json-file@^3.2.0:
-  version "3.2.0"
-  resolved "https://registry.npmjs.org/write-json-file/-/write-json-file-3.2.0.tgz#65bbdc9ecd8a1458e15952770ccbadfcff5fe62a"
-  integrity sha512-3xZqT7Byc2uORAatYiP3DHUUAVEkNOswEWNs9H5KXiicRTvzYzYqKjYc4G7p+8pltvAw641lVByKVtMpf+4sYQ==
-  dependencies:
-    detect-indent "^5.0.0"
-    graceful-fs "^4.1.15"
-    make-dir "^2.1.0"
-    pify "^4.0.1"
-    sort-keys "^2.0.0"
-    write-file-atomic "^2.4.2"
-
-write-pkg@^3.1.0:
-  version "3.2.0"
-  resolved "https://registry.npmjs.org/write-pkg/-/write-pkg-3.2.0.tgz#0e178fe97820d389a8928bc79535dbe68c2cff21"
-  integrity sha512-tX2ifZ0YqEFOF1wjRW2Pk93NLsj02+n1UP5RvO6rCs0K6R2g1padvf006cY74PQJKMGS2r42NK7FD0dG6Y6paw==
-  dependencies:
-    sort-keys "^2.0.0"
-    write-json-file "^2.2.0"
-
 ws@^5.2.0:
   version "5.2.2"
   resolved "https://registry.npmjs.org/ws/-/ws-5.2.2.tgz#dffef14866b8e8dc9133582514d1befaf96e980f"
@@ -7012,33 +4129,36 @@ ws@^5.2.0:
   dependencies:
     async-limiter "~1.0.0"
 
+wsrun@^5.2.0:
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/wsrun/-/wsrun-5.2.0.tgz#a7c0587cb371ea29352f0b3cad002ea839a25b0f"
+  integrity sha512-48j1AltgQxEy3dwDrqWJTZIYSNYPGHtkZzTDjQiHPICXv2qtXPXFj+XutE4aZlCCWKZW+Lc+v6dUjBdH3yg8PQ==
+  dependencies:
+    bluebird "^3.5.1"
+    chalk "^2.3.0"
+    glob "^7.1.2"
+    jest-changed-files "^24.9.0"
+    lodash "^4.17.4"
+    minimatch "^3.0.4"
+    split "^1.0.1"
+    throat "^4.1.0"
+    yargs "^11.1.1"
+
 xml-name-validator@^3.0.0:
   version "3.0.0"
   resolved "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-3.0.0.tgz#6ae73e06de4d8c6e47f9fb181f78d648ad457c6a"
   integrity sha512-A5CUptxDsvxKJEU3yO6DuWBSJz/qizqzJKOMIfUJHETbBw/sFaDxgd6fxm1ewUaM0jZ444Fc5vC5ROYurg/4Pw==
 
-xtend@~4.0.1:
-  version "4.0.2"
-  resolved "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz#bb72779f5fa465186b1f438f674fa347fdb5db54"
-  integrity sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==
+y18n@^3.2.1:
+  version "3.2.1"
+  resolved "https://registry.yarnpkg.com/y18n/-/y18n-3.2.1.tgz#6d15fba884c08679c0d77e88e7759e811e07fa41"
+  integrity sha1-bRX7qITAhnnA136I53WegR4H+kE=
 
 y18n@^4.0.0:
   version "4.0.0"
   resolved "https://registry.npmjs.org/y18n/-/y18n-4.0.0.tgz#95ef94f85ecc81d007c264e190a120f0a3c8566b"
   integrity sha512-r9S/ZyXu/Xu9q1tYlpsLIsa3EeLXXk0VwlxqTcFRfg9EhMW+17kbt9G0NrgCmhGb5vT2hyhJZLfDGx+7+5Uj/w==
 
-yallist@^3.0.0, yallist@^3.0.2, yallist@^3.0.3:
-  version "3.1.1"
-  resolved "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz#dbb7daf9bfd8bac9ab45ebf602b8cbad0d5d08fd"
-  integrity sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==
-
-yargs-parser@^10.0.0:
-  version "10.1.0"
-  resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-10.1.0.tgz#7202265b89f7e9e9f2e5765e0fe735a905edbaa8"
-  integrity sha512-VCIyR1wJoEBZUqk5PA+oOBF6ypbwh5aNB3I50guxAL/quggdfs4TtNHQrSazFA3fYZ+tEqfs0zIGlv0c/rgjbQ==
-  dependencies:
-    camelcase "^4.1.0"
-
 yargs-parser@^13.1.2:
   version "13.1.2"
   resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-13.1.2.tgz#130f09702ebaeef2650d54ce6e3e5706f7a4fb38"
@@ -7047,37 +4167,37 @@ yargs-parser@^13.1.2:
     camelcase "^5.0.0"
     decamelize "^1.2.0"
 
-yargs-parser@^15.0.1:
-  version "15.0.1"
-  resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-15.0.1.tgz#54786af40b820dcb2fb8025b11b4d659d76323b3"
-  integrity sha512-0OAMV2mAZQrs3FkNpDQcBk1x5HXb8X4twADss4S0Iuk+2dGnLOE/fRHrsYm542GduMveyA77OF4wrNJuanRCWw==
+yargs-parser@^9.0.2:
+  version "9.0.2"
+  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-9.0.2.tgz#9ccf6a43460fe4ed40a9bb68f48d43b8a68cc077"
+  integrity sha1-nM9qQ0YP5O1Aqbto9I1DuKaMwHc=
   dependencies:
-    camelcase "^5.0.0"
-    decamelize "^1.2.0"
+    camelcase "^4.1.0"
 
-yargs@^13.3.0:
-  version "13.3.2"
-  resolved "https://registry.npmjs.org/yargs/-/yargs-13.3.2.tgz#ad7ffefec1aa59565ac915f82dccb38a9c31a2dd"
-  integrity sha512-AX3Zw5iPruN5ie6xGRIDgqkT+ZhnRlZMLMHAs8tg7nRruy2Nb+i5o9bwghAogtM08q1dpr2LVoS8KSTMYpWXUw==
+yargs@^11.1.1:
+  version "11.1.1"
+  resolved "https://registry.yarnpkg.com/yargs/-/yargs-11.1.1.tgz#5052efe3446a4df5ed669c995886cc0f13702766"
+  integrity sha512-PRU7gJrJaXv3q3yQZ/+/X6KBswZiaQ+zOmdprZcouPYtQgvNU35i+68M4b1ZHLZtYFT5QObFLV+ZkmJYcwKdiw==
   dependencies:
-    cliui "^5.0.0"
-    find-up "^3.0.0"
-    get-caller-file "^2.0.1"
+    cliui "^4.0.0"
+    decamelize "^1.1.1"
+    find-up "^2.1.0"
+    get-caller-file "^1.0.1"
+    os-locale "^3.1.0"
     require-directory "^2.1.1"
-    require-main-filename "^2.0.0"
+    require-main-filename "^1.0.1"
     set-blocking "^2.0.0"
-    string-width "^3.0.0"
+    string-width "^2.0.0"
     which-module "^2.0.0"
-    y18n "^4.0.0"
-    yargs-parser "^13.1.2"
+    y18n "^3.2.1"
+    yargs-parser "^9.0.2"
 
-yargs@^14.2.2:
-  version "14.2.3"
-  resolved "https://registry.npmjs.org/yargs/-/yargs-14.2.3.tgz#1a1c3edced1afb2a2fea33604bc6d1d8d688a414"
-  integrity sha512-ZbotRWhF+lkjijC/VhmOT9wSgyBQ7+zr13+YLkhfsSiTriYsMzkTUFP18pFhWwBeMa5gUc1MzbhrO6/VB7c9Xg==
+yargs@^13.3.0:
+  version "13.3.2"
+  resolved "https://registry.npmjs.org/yargs/-/yargs-13.3.2.tgz#ad7ffefec1aa59565ac915f82dccb38a9c31a2dd"
+  integrity sha512-AX3Zw5iPruN5ie6xGRIDgqkT+ZhnRlZMLMHAs8tg7nRruy2Nb+i5o9bwghAogtM08q1dpr2LVoS8KSTMYpWXUw==
   dependencies:
     cliui "^5.0.0"
-    decamelize "^1.2.0"
     find-up "^3.0.0"
     get-caller-file "^2.0.1"
     require-directory "^2.1.1"
@@ -7086,7 +4206,7 @@ yargs@^14.2.2:
     string-width "^3.0.0"
     which-module "^2.0.0"
     y18n "^4.0.0"
-    yargs-parser "^15.0.1"
+    yargs-parser "^13.1.2"
 
 yargs@~3.10.0:
   version "3.10.0"