diff --git a/Makefile b/Makefile
index 5c3d664..b386afc 100644
--- a/Makefile
+++ b/Makefile
@@ -5,6 +5,7 @@ test:
 	karma start
 
 test-all:
+	standard
 	mocha
 	karma start --single-run --browsers browserstack-osx-chrome
 	karma start --single-run --browsers browserstack-osx-firefox
diff --git a/actions.js b/actions.js
index 9b5dfc2..e4b70ba 100644
--- a/actions.js
+++ b/actions.js
@@ -1,181 +1,182 @@
-var debug = require('debug')('browser-monkey');
-var sendkeys = require('./sendkeys');
-var errorHandler = require('./errorHandler');
-function notSillyBlankIEObject(element){
-  return Object.keys(element).length > 0;
+var debug = require('debug')('browser-monkey')
+var sendkeys = require('./sendkeys')
+var errorHandler = require('./errorHandler')
+function notSillyBlankIEObject (element) {
+  return Object.keys(element).length > 0
 }
 module.exports = {
-  focus: function(element, options) {
-    var focus = typeof options == 'object' && options.hasOwnProperty('focus')? options.focus: true;
+  focus: function (element, options) {
+    var focus = typeof options === 'object' && options.hasOwnProperty('focus') ? options.focus : true
 
     if (focus) {
-      var $ = this.get('$');
-      var document = this.get('document');
+      var $ = this.get('$')
+      var document = this.get('document')
       if (element && element.length > 0) {
-        element = element[0];
+        element = element[0]
       }
 
-      var activeElement = document.activeElement;
+      var activeElement = document.activeElement
       if (activeElement && !$(activeElement).is(':focus') && notSillyBlankIEObject(activeElement)) {
-        $(activeElement).trigger('blur');
+        $(activeElement).trigger('blur')
       }
-      if (['[object Document]', '[object HTMLDocument]'].indexOf(document.toString()) === -1){
-        document.activeElement = element;
+      if (['[object Document]', '[object HTMLDocument]'].indexOf(document.toString()) === -1) {
+        document.activeElement = element
       }
-      $(element).focus();
+      $(element).focus()
     }
   },
 
-  click: function(options) {
-    var self = this;
+  click: function (options) {
+    var self = this
 
     if (typeof options === 'string') {
-      self = this.linkOrButton(options);
+      self = this.linkOrButton(options)
     }
 
-    return self.enabled().element(options).then(function(element) {
-      debug('click', element);
-      self.handleEvent({type: 'click', element: element});
-      self.focus(element, options);
-      element.trigger('mousedown');
-      element.trigger('mouseup');
-      element.trigger('click');
-    }).catch(errorHandler(new Error()));
+    return self.enabled().element(options).then(function (element) {
+      debug('click', element)
+      self.handleEvent({type: 'click', element: element})
+      self.focus(element, options)
+      element.trigger('mousedown')
+      element.trigger('mouseup')
+      element.trigger('click')
+    }).catch(errorHandler(new Error()))
   },
 
-  select: function(options) {
-    if (typeof options == 'string') {
-      var o = arguments[1] || {};
-      o.text = options;
-      return this.select(o);
+  select: function (options) {
+    if (typeof options === 'string') {
+      var o = arguments[1] || {}
+      o.text = options
+      return this.select(o)
     }
-    var $ = this.get('$');
-    var self = this;
-
-    return this.is('select').find('option', options).elements(options).then(function(optionElements) {
-      var optionElement = $(optionElements[0]);
-      var selectElement = optionElement.parent();
-      self.focus(selectElement, options);
-      optionElement.prop('selected', true);
-      optionElement.attr('selected', 'selected');
-      selectElement.val(optionElement.val());
-
-      debug('select', selectElement);
+    var $ = this.get('$')
+    var self = this
+
+    return this.is('select').find('option', options).elements(options).then(function (optionElements) {
+      var optionElement = $(optionElements[0])
+      var selectElement = optionElement.parent()
+      self.focus(selectElement, options)
+      optionElement.prop('selected', true)
+      optionElement.attr('selected', 'selected')
+      selectElement.val(optionElement.val())
+
+      debug('select', selectElement)
       self.handleEvent({
         type: 'select option',
         value: selectElement.val(),
         element: selectElement,
         optionElement: optionElement
-      });
+      })
 
-      selectElement.trigger('change');
-    }).catch(errorHandler(new Error()));
+      selectElement.trigger('change')
+    }).catch(errorHandler(new Error()))
   },
 
-  typeIn: function(text, options) {
-    if (typeof text === 'object'){
-      text = text.text;
+  typeIn: function (text, options) {
+    if (typeof text === 'object') {
+      text = text.text
     }
-    var self = this;
-
-    return this.element(options).then(function(element) {
-      debug('typeIn', element, text);
-      assertCanTypeIntoElement(element);
-      self.focus(element, options);
-      self.handleEvent({type: 'typing', text: text, element: element});
-      return sendkeys(element, text);
-    }).catch(errorHandler(new Error()));
+    var self = this
+
+    return this.element(options).then(function (element) {
+      debug('typeIn', element, text)
+      assertCanTypeIntoElement(element)
+      self.focus(element, options)
+      self.handleEvent({type: 'typing', text: text, element: element})
+      return sendkeys(element, text)
+    }).catch(errorHandler(new Error()))
   },
 
-  submit: function(options) {
-    var self = this;
+  submit: function (options) {
+    var self = this
 
-    return this.element(options).then(function(element) {
-      debug('submit', element);
-      self.focus(element, options);
-      self.handleEvent({type: 'submit', element: element});
-      return element.trigger('submit');
-    }).catch(errorHandler(new Error()));
+    return this.element(options).then(function (element) {
+      debug('submit', element)
+      self.focus(element, options)
+      self.handleEvent({type: 'submit', element: element})
+      return element.trigger('submit')
+    }).catch(errorHandler(new Error()))
   },
 
-  typeInHtml: function(html, options) {
-    var self = this;
+  typeInHtml: function (html, options) {
+    var self = this
 
-    return this.element(options).then(function(element) {
-      self.focus(element, options);
-      debug('typeInHtml', element, html);
-      self.handleEvent({type: 'typing html', html: html, element: element});
-      return sendkeys.html(element, html);
-    }).catch(errorHandler(new Error()));
+    return this.element(options).then(function (element) {
+      self.focus(element, options)
+      debug('typeInHtml', element, html)
+      self.handleEvent({type: 'typing html', html: html, element: element})
+      return sendkeys.html(element, html)
+    }).catch(errorHandler(new Error()))
   },
 
-
-  fill: function(field){
-    var isArray = Object.prototype.toString.call(field) === '[object Array]';
-    var component = this;
+  fill: function (field) {
+    var isArray = Object.prototype.toString.call(field) === '[object Array]'
+    var component = this
     var Promise = this.promise()
-    return new Promise(function(success, failure){
+    return new Promise(function (resolve, reject) {
       if (isArray) {
-        var fields = field;
-          function fillField(){
-            var field = fields.shift();
-            if (field) {
-              return component.fill(field).then(fillField).catch(failure);
-            } else {
-              success();
-            }
-          }
-
-          fillField();
+        fillField(component, field)
+          .then(resolve)
+          .catch(reject)
       } else {
         if (!field.name) {
           try {
-            field = inferField(component, field);
-          } catch(e) {
-            failure(e.message);
-            return;
+            field = inferField(component, field)
+          } catch (e) {
+            reject(e)
+            return
           }
         }
 
         if (typeof component[field.name] === 'function') {
-          var finder = component[field.name]()
-          success(component[field.name]()[field.action](field.options));
+          resolve(component[field.name]()[field.action](field.options))
         } else {
-          failure("No field '"+field.name+"' exists on this component");
+          reject(new Error("No field '" + field.name + "' exists on this component"))
         }
       }
-    });
+    })
   }
-};
+}
 
-function inferField(component, field){
-  var ignoreActions = {constructor: true, _options: true};
+function fillField (component, fields) {
+  var field = fields.shift()
+  if (field) {
+    return component.fill(field).then(function () {
+      return fillField(component, fields)
+    })
+  } else {
+    return Promise.resolve()
+  }
+}
+
+function inferField (component, field) {
+  var ignoreActions = {constructor: true, _options: true}
   for (var action in component) {
-    if (field[action] && !ignoreActions[action]){
+    if (field[action] && !ignoreActions[action]) {
       var newField = {
         name: field[action],
         action: action,
         options: field
-      };
-      delete field[action];
+      }
+      delete field[action]
 
       if (field.options) {
-        newField.options = field.options;
+        newField.options = field.options
       }
 
-      if (typeof component[newField.name] !== 'function'){
-        throw new Error("Field '"+newField.name+"' does not exist");
+      if (typeof component[newField.name] !== 'function') {
+        throw new Error("Field '" + newField.name + "' does not exist")
       }
 
-      return newField;
+      return newField
     }
   };
   if (!field.name) {
-    throw new Error('No action found for field: '+JSON.stringify(field));
+    throw new Error('No action found for field: ' + JSON.stringify(field))
   }
 }
 
-function canTypeIntoElement(element) {
+function canTypeIntoElement (element) {
   return element.is('input:not([type]), ' +
                        'input[type=text], ' +
                        'input[type=email], ' +
@@ -184,11 +185,11 @@ function canTypeIntoElement(element) {
                        'input[type=tel], ' +
                        'input[type=url], ' +
                        'input[type=number],' +
-                       'textarea');
+                       'textarea')
 }
 
-function assertCanTypeIntoElement(element) {
+function assertCanTypeIntoElement (element) {
   if (!canTypeIntoElement(element)) {
-    throw new Error('Cannot type into ' + element.prop('tagName'));
+    throw new Error('Cannot type into ' + element.prop('tagName'))
   }
 }
diff --git a/angular.js b/angular.js
index 60164f8..9178b20 100644
--- a/angular.js
+++ b/angular.js
@@ -1,18 +1,19 @@
 var debug = require('debug')('browser-monkey:angular')
-var Mount = require('./mount');
-var createMonkey = require('./create');
-var createTestDiv = require('./createTestDiv');
+var Mount = require('./mount')
+var createMonkey = require('./create')
+var createTestDiv = require('./createTestDiv')
+var angular = require('angular')
 
-module.exports = function(app) {
+module.exports = function (app) {
   return new Mount(app, {
-    stopApp: function(){},
-    startApp: function(){
+    stopApp: function () {},
+    startApp: function () {
       debug('Mounting angular app ' + app.moduleName)
-      var div = createTestDiv();
-      div.setAttribute(app.directiveName, '');
-      angular.bootstrap(div, [app.moduleName]);
+      var div = createTestDiv()
+      div.setAttribute(app.directiveName, '')
+      angular.bootstrap(div, [app.moduleName])
 
-      return createMonkey(document.body);
+      return createMonkey(document.body)
     }
-  }).start();
+  }).start()
 }
diff --git a/assertions.js b/assertions.js
index 7b90e60..1203f54 100644
--- a/assertions.js
+++ b/assertions.js
@@ -1,20 +1,19 @@
-var Options = require('./options');
-var expectOneElement = require('./expectOneElement');
-var errorHandler = require('./errorHandler');
+var Options = require('./options')
+var expectOneElement = require('./expectOneElement')
+var errorHandler = require('./errorHandler')
 
 module.exports = {
   is: function (css) {
-    var $ = this.get('$');
-    return this.addFinder(this.createElementTester({css: css}));
+    return this.addFinder(this.createElementTester({css: css}))
   },
 
   exists: function (options) {
-    return this.shouldExist(options);
+    return this.shouldExist(options)
   },
 
   shouldExist: function (options) {
     return this.resolve(options)
-      .catch(errorHandler(new Error()));
+      .catch(errorHandler(new Error()))
   },
 
   shouldFind: function (selector, findOptions, existOptions) {
@@ -24,68 +23,66 @@ module.exports = {
 
   shouldNotExist: function (options) {
     return this.notResolve(options)
-      .catch(errorHandler(new Error()));
+      .catch(errorHandler(new Error()))
   },
 
-  has: function(options) {
-    return this.shouldHave(options);
+  has: function (options) {
+    return this.shouldHave(options)
   },
 
-  shouldHave: function(options) {
-    var $ = this.get('$');
-    var self = this;
+  shouldHave: function (options) {
+    var self = this
 
-    var resolveOptions = Options.remove(options, ['timeout', 'interval']);
-    resolveOptions.allowMultiple = true;
+    var resolveOptions = Options.remove(options, ['timeout', 'interval'])
+    resolveOptions.allowMultiple = true
 
-    var additionalAssertions = Object.keys(options).filter(function(finderMethodName){
-      return options[finderMethodName] && options[finderMethodName].constructor === Object && typeof self[finderMethodName] === 'function';
-    });
+    var additionalAssertions = Object.keys(options).filter(function (finderMethodName) {
+      return options[finderMethodName] && options[finderMethodName].constructor === Object && typeof self[finderMethodName] === 'function'
+    })
 
-    var additionalOptions = Options.remove(options, additionalAssertions);
+    var additionalOptions = Options.remove(options, additionalAssertions)
 
-    var assertions = additionalAssertions.map(function(finderMethodName){
+    var assertions = additionalAssertions.map(function (finderMethodName) {
       if (typeof self[finderMethodName] === 'function') {
-        return self[finderMethodName]().shouldHave(additionalOptions[finderMethodName]);
+        return self[finderMethodName]().shouldHave(additionalOptions[finderMethodName])
       }
-    });
+    })
 
-    assertions.push(this.addFinder(this.createElementTester(options)).shouldExist(resolveOptions));
+    assertions.push(this.addFinder(this.createElementTester(options)).shouldExist(resolveOptions))
     return Promise.all(assertions)
-      .catch(errorHandler(new Error()));
+      .catch(errorHandler(new Error()))
   },
 
-  shouldHaveElement: function(fn, options) {
-    var $ = this.get('$');
-    var self = this;
+  shouldHaveElement: function (fn, options) {
+    var $ = this.get('$')
+    var self = this
 
     return this.addFinder({
       find: function (elements) {
-        expectOneElement(self, elements);
-        elements.toArray().forEach(function(element){
-          fn($(element));
-        });
-        return elements;
+        expectOneElement(self, elements)
+        elements.toArray().forEach(function (element) {
+          fn($(element))
+        })
+        return elements
       }
-    }).shouldExist(options);
+    }).shouldExist(options)
   },
 
-  shouldHaveElements: function(fn, options) {
-    options = Options.default(options, {allowMultiple: true, trace: false});
+  shouldHaveElements: function (fn, options) {
+    options = Options.default(options, {allowMultiple: true, trace: false})
 
     return this.addFinder({
       find: function (elements) {
-        fn(elements.toArray());
-        return elements;
+        fn(elements.toArray())
+        return elements
       }
-    }).shouldExist(options);
+    }).shouldExist(options)
   },
 
-  shouldNotHave: function(options) {
-    var $ = this.get('$');
-    var resolveOptions = Options.remove(options, ['timeout', 'interval']);
-    resolveOptions.allowMultiple = true;
+  shouldNotHave: function (options) {
+    var resolveOptions = Options.remove(options, ['timeout', 'interval'])
+    resolveOptions.allowMultiple = true
 
-    return this.addFinder(this.createElementTester(options)).shouldNotExist(resolveOptions);
+    return this.addFinder(this.createElementTester(options)).shouldNotExist(resolveOptions)
   }
-};
+}
diff --git a/create.js b/create.js
index 4f84893..468fb2c 100644
--- a/create.js
+++ b/create.js
@@ -1,13 +1,13 @@
-var Selector = require('./selector');
-var finders = require('./finders');
-var actions = require('./actions');
-var assertions = require('./assertions');
-var promise = require('./promise');
+var Selector = require('./selector')
+var finders = require('./finders')
+var actions = require('./actions')
+var assertions = require('./assertions')
+var promise = require('./promise')
 
-module.exports = function(rootSelector) {
+module.exports = function (rootSelector) {
   return new Selector(rootSelector)
     .component(promise)
     .component(finders)
     .component(actions)
-    .component(assertions);
+    .component(assertions)
 }
diff --git a/createTestDiv.js b/createTestDiv.js
index 9beb4d4..8b0ea21 100644
--- a/createTestDiv.js
+++ b/createTestDiv.js
@@ -1,12 +1,12 @@
 var div
 
-module.exports = function() {
+module.exports = function () {
   if (div && div.parentNode) {
-    div.parentNode.removeChild(div);
+    div.parentNode.removeChild(div)
   }
 
   div = window.document.createElement('div')
   window.document.body.appendChild(div)
 
-  return div;
+  return div
 }
diff --git a/elementTester.js b/elementTester.js
index 43898ed..66ba8ef 100644
--- a/elementTester.js
+++ b/elementTester.js
@@ -1,35 +1,34 @@
-var chai = require('chai');
-var expect = chai.expect;
-var elementsToString = require('./elementsToString');
-require('array.prototype.find').shim();
+var chai = require('chai')
+var expect = chai.expect
+var elementsToString = require('./elementsToString')
+require('array.prototype.find').shim()
 
-function assertElementProperties($, elements, expected, getProperty, exact) {
-  function assertion(actual, expected) {
+function assertElementProperties ($, elements, expected, getProperty, exact) {
+  function assertion (actual, expected) {
     if (exact) {
-      expect(actual, 'expected element to have exact text ' + JSON.stringify(expected) + ' but contained ' + JSON.stringify(actual)).to.equal(expected.toString());
+      expect(actual, 'expected element to have exact text ' + JSON.stringify(expected) + ' but contained ' + JSON.stringify(actual)).to.equal(expected.toString())
     } else {
-      expect(actual, 'expected element to contain ' + JSON.stringify(expected) + ' but contained ' + JSON.stringify(actual)).to.contain(expected);
+      expect(actual, 'expected element to contain ' + JSON.stringify(expected) + ' but contained ' + JSON.stringify(actual)).to.contain(expected)
     }
   }
 
   if (expected instanceof Array) {
     var actualTexts = elements.toArray().map(function (item) {
-      return getProperty($(item));
-    });
-
-    expect(actualTexts.length, 'expected ' + JSON.stringify(actualTexts) + ' to respectively contain ' + JSON.stringify(expected)).to.eql(expected.length);
+      return getProperty($(item))
+    })
 
+    expect(actualTexts.length, 'expected ' + JSON.stringify(actualTexts) + ' to respectively contain ' + JSON.stringify(expected)).to.eql(expected.length)
 
-    var comparer = exact == true ?
-      function(a, b) { return a == b; } :
-      function(a, b) { return a.indexOf(b) != -1}
+    var comparer = exact === true
+      ? function (a, b) { return a === b }
+      : function (a, b) { return a.indexOf(b) !== -1 }
 
-    var found = [];
-    expected.forEach(function(value) {
-      var foundValue = actualTexts.find(function(actual) {
+    var found = []
+    expected.forEach(function (value) {
+      var foundValue = actualTexts.find(function (actual) {
         return comparer(actual, value)
       })
-      if (foundValue != undefined) {
+      if (foundValue !== undefined) {
         actualTexts.splice(actualTexts.indexOf(foundValue), 1)
         found.push(value)
       }
@@ -37,126 +36,125 @@ function assertElementProperties($, elements, expected, getProperty, exact) {
 
     try {
       expect(found).to.eql(expected)
-    } catch(e) {
-      if (found.slice().sort().toString() == expected.slice().sort().toString()) {
-        e.message += '\nThe text was found but in a different order than specified - maybe you need some sorting?';
+    } catch (e) {
+      if (found.slice().sort().toString() === expected.slice().sort().toString()) {
+        e.message += '\nThe text was found but in a different order than specified - maybe you need some sorting?'
       }
-      throw e;
+      throw e
     }
   } else {
-    var elementText = getProperty($(elements));
-    assertion(elementText, expected);
+    var elementText = getProperty($(elements))
+    assertion(elementText, expected)
   }
 }
 
-function getNormalisedText(el) {
-  return (el.innerText() || '').replace(/ +/g,' ').replace(/ *\r?\n */g,"\n");
+function getNormalisedText (el) {
+  return (el.innerText() || '').replace(/ +/g, ' ').replace(/ *\r?\n */g, '\n')
 }
 
-function getValue(e, property) {
-  var val = e.val();
+function getValue (e, property) {
+  var val = e.val()
   // Fails with missing value attribute in VDOM without 'string' test (returns SoftSetHook{value: ''})
-  return (typeof val === "string" && val) || '';
+  return (typeof val === 'string' && val) || ''
 }
 
 module.exports = {
-  css: function($el, message, css) {
+  css: function ($el, message, css) {
     if (!$el.is(css)) {
-      throw new Error(message || ('expected elements ' + elementsToString($el) + ' to have css ' + css));
+      throw new Error(message || ('expected elements ' + elementsToString($el) + ' to have css ' + css))
     }
   },
-  elements: function($el, message, predicate){
+  elements: function ($el, message, predicate) {
     if (!predicate($el.toArray())) {
-      throw new Error(message || 'expected elements to pass predicate');
+      throw new Error(message || 'expected elements to pass predicate')
     }
   },
-  text: function($el, message, text) {
-    assertElementProperties(this.get('$'), $el, text, function (e) { return getNormalisedText(e)}, text === '');
+  text: function ($el, message, text) {
+    assertElementProperties(this.get('$'), $el, text, function (e) { return getNormalisedText(e) }, text === '')
   },
-  length: function($el, message, length) {
+  length: function ($el, message, length) {
     if ($el.length !== length) {
-      throw new Error(message || ('expected ' + elementsToString($el) + ' to have ' + length + ' elements'));
+      throw new Error(message || ('expected ' + elementsToString($el) + ' to have ' + length + ' elements'))
     }
   },
-  html: function($el, message, html) {
-    assertElementProperties(this.get('$'), $el, html, function (e) { return e.html(); });
+  html: function ($el, message, html) {
+    assertElementProperties(this.get('$'), $el, html, function (e) { return e.html() })
   },
-  checked: function($el, message, checked) {
-    var $ = this.get('$');
-    var elements = $el.toArray();
+  checked: function ($el, message, checked) {
+    var $ = this.get('$')
+    var elements = $el.toArray()
 
     if (checked instanceof Array) {
       var elementsChecked = elements.map(function (element) {
-        return !!$(element).prop('checked');
-      });
-      expect(elementsChecked, 'expected ' + elementsToString($el) + ' to have checked states ' + JSON.stringify(checked)).to.eql(checked);
+        return !!$(element).prop('checked')
+      })
+      expect(elementsChecked, 'expected ' + elementsToString($el) + ' to have checked states ' + JSON.stringify(checked)).to.eql(checked)
     } else {
       var elementsNotMatching = elements.filter(function (element) {
-        return $(element).prop('checked') !== checked;
-      });
-      expect(elementsNotMatching.length, 'expected ' + elementsToString($el) + ' to be ' + (checked? 'checked': 'unchecked')).to.equal(0);
+        return $(element).prop('checked') !== checked
+      })
+      expect(elementsNotMatching.length, 'expected ' + elementsToString($el) + ' to be ' + (checked ? 'checked' : 'unchecked')).to.equal(0)
     }
   },
-  exactText: function($el, message, exactText) {
-    assertElementProperties(this.get('$'), $el, exactText, function (e) { return getNormalisedText(e); }, true);
+  exactText: function ($el, message, exactText) {
+    assertElementProperties(this.get('$'), $el, exactText, function (e) { return getNormalisedText(e) }, true)
   },
-  value: function($el, message, value) {
-    assertElementProperties(this.get('$'), $el, value, getValue, value === '');
+  value: function ($el, message, value) {
+    assertElementProperties(this.get('$'), $el, value, getValue, value === '')
   },
-  exactValue: function($el, message, exactValue) {
-    assertElementProperties(this.get('$'), $el, exactValue, getValue, true);
+  exactValue: function ($el, message, exactValue) {
+    assertElementProperties(this.get('$'), $el, exactValue, getValue, true)
   },
-  attributes: function($el, message, attributes) {
-    var $ = this.get('$');
-    var elements = $el.toArray();
+  attributes: function ($el, message, attributes) {
+    var $ = this.get('$')
+    var elements = $el.toArray()
 
     if (attributes instanceof Array) {
       expect(elements.length).to.equal(attributes.length, 'expected the matched elements to be the same length as the expected attributes')
-      elements.forEach(function(el, index){
-        var attributesForElement = attributes[index];
-        Object.keys(attributesForElement).forEach(function(attributeKey){
-          expect($(el).attr(attributeKey)).to.equal(attributesForElement[attributeKey]);
-        });
-      });
-
+      elements.forEach(function (el, index) {
+        var attributesForElement = attributes[index]
+        Object.keys(attributesForElement).forEach(function (attributeKey) {
+          expect($(el).attr(attributeKey)).to.equal(attributesForElement[attributeKey])
+        })
+      })
     } else {
-      elements.forEach(function(el){
-        Object.keys(attributes).forEach(function(attributeKey){
-          expect($(el).attr(attributeKey)).to.equal(attributes[attributeKey]);
-        });
-      });
+      elements.forEach(function (el) {
+        Object.keys(attributes).forEach(function (attributeKey) {
+          expect($(el).attr(attributeKey)).to.equal(attributes[attributeKey])
+        })
+      })
     }
   },
 
-  label: function($el, message, label) {
-    var $ = this.get('$');
-    var links = $el.toArray().filter(function(el) {
+  label: function ($el, message, label) {
+    var $ = this.get('$')
+    var links = $el.toArray().filter(function (el) {
       if ($(el).is('a')) {
-        var anchor = $(el);
-        var href = anchor.attr('href');
+        var anchor = $(el)
+        var href = anchor.attr('href')
         return typeof href !== typeof undefined &&
         href !== false &&
         (
-         anchor.text() == label ||
-         anchor.attr('id') == label ||
-         anchor.attr('title') == label ||
-         anchor.find("img").toArray().filter(function(img) {
-           return $(img).attr('alt') == label;
+         anchor.text() === label ||
+         anchor.attr('id') === label ||
+         anchor.attr('title') === label ||
+         anchor.find('img').toArray().filter(function (img) {
+           return $(img).attr('alt') === label
          }).length > 0
-        );
+        )
       }
       if ($(el).is('button, input[type=submit], input[type=button], input[type=reset]')) {
-        var button = $(el);
-        return button.attr('id') == label ||
-      button.text() == label ||
-      (typeof button.attr('value') == 'string' && button.attr('value').indexOf(label) > -1) ||
-      (typeof button.attr('title') == 'string' && button.attr('title').indexOf(label) > -1) ||
-      button.find("img").toArray().filter(function(img) {
-        return typeof $(img).attr('alt') == 'string' && $(img).attr('alt').indexOf(label) > -1;
+        var button = $(el)
+        return button.attr('id') === label ||
+      button.text() === label ||
+      (typeof button.attr('value') === 'string' && button.attr('value').indexOf(label) > -1) ||
+      (typeof button.attr('title') === 'string' && button.attr('title').indexOf(label) > -1) ||
+      button.find('img').toArray().filter(function (img) {
+        return typeof $(img).attr('alt') === 'string' && $(img).attr('alt').indexOf(label) > -1
       }).length > 0
       }
-    });
+    })
 
-    expect(links.length).to.equal(1, message);
+    expect(links.length).to.equal(1, message)
   }
-};
+}
diff --git a/elementsToString.js b/elementsToString.js
index b5f3928..d07bd46 100644
--- a/elementsToString.js
+++ b/elementsToString.js
@@ -1,6 +1,5 @@
-module.exports = function elementsToString(els) {
+module.exports = function elementsToString (els) {
   return els.toArray().map(function (el) {
-    if (el && el.outerHTML)
-    return el.outerHTML.replace(el.innerHTML, '');
-  }).join(', ');
+    if (el && el.outerHTML) { return el.outerHTML.replace(el.innerHTML, '') }
+  }).join(', ')
 }
diff --git a/errorHandler.js b/errorHandler.js
index 5ff27ee..598e77e 100644
--- a/errorHandler.js
+++ b/errorHandler.js
@@ -1,15 +1,15 @@
-function BrowserMonkeyError(message, stack) {
-  this.name = 'BrowserMonkeyError';
-  this.message = message;
-  this.stack = stack;
+function BrowserMonkeyError (message, stack) {
+  this.name = 'BrowserMonkeyError'
+  this.message = message
+  this.stack = stack
 }
-BrowserMonkeyError.prototype = Object.create(Error.prototype);
-BrowserMonkeyError.prototype.constructor = BrowserMonkeyError;
+BrowserMonkeyError.prototype = Object.create(Error.prototype)
+BrowserMonkeyError.prototype.constructor = BrowserMonkeyError
 
-module.exports = function(error) {
-  return function(e) {
-    var bmError = new BrowserMonkeyError(e.message, error.stack);
-    //bmError.internalError = e;
-    throw bmError;
+module.exports = function (error) {
+  return function (e) {
+    var bmError = new BrowserMonkeyError(e.message, error.stack)
+    // bmError.internalError = e;
+    throw bmError
   }
 }
diff --git a/expectOneElement.js b/expectOneElement.js
index df434ba..0ca1f53 100644
--- a/expectOneElement.js
+++ b/expectOneElement.js
@@ -1,8 +1,8 @@
-var chai = require('chai');
-var expect = chai.expect;
-var elementsToString = require('./elementsToString');
+var chai = require('chai')
+var expect = chai.expect
+var elementsToString = require('./elementsToString')
 
-module.exports = function expectOneElement(scope, elements) {
-  var msg = "expected to find exactly one element: " + scope.printFinders(scope._finders) + ', but found :' + elementsToString(elements);
-  expect(elements.length, msg).to.equal(1);
+module.exports = function expectOneElement (scope, elements) {
+  var msg = 'expected to find exactly one element: ' + scope.printFinders(scope._finders) + ', but found :' + elementsToString(elements)
+  expect(elements.length, msg).to.equal(1)
 }
diff --git a/finders.js b/finders.js
index ce9f698..7a53a7f 100644
--- a/finders.js
+++ b/finders.js
@@ -1,283 +1,283 @@
-var Options = require('./options');
-var expectOneElement = require('./expectOneElement');
+var Options = require('./options')
+var expectOneElement = require('./expectOneElement')
+var window = require('global')
 
 module.exports = {
-  elementFinder: function(css) {
-    var $ = this.get('$');
-    var self = this;
+  elementFinder: function (css) {
+    var $ = this.get('$')
+    var self = this
     return {
-      find: function(element) {
-        var els = $(element).find(css);
+      find: function (element) {
+        var els = $(element).find(css)
         if (self.get('visibleOnly')) {
-          els = els.filter(function(index){
-            var el = this[index] || this;
-            var ignoreVisibilityOfTags = ['OPTION'];
+          els = els.filter(function (index) {
+            var el = this[index] || this
+            var ignoreVisibilityOfTags = ['OPTION']
             if (el && ignoreVisibilityOfTags.indexOf(el.tagName) !== -1) {
-              el = el.parentNode;
+              el = el.parentNode
             }
-            return $(el).is(':visible');
-          });
+            return $(el).is(':visible')
+          })
         }
         if (els.length > 0) {
-          return els;
+          return els
         }
       },
 
-      toString: function() {
-        return css;
+      toString: function () {
+        return css
       }
-    };
+    }
   },
 
   addFinder: function (finder) {
-    var finders = this._finders && this._finders.slice() || [];
-    finders.push(finder);
-    return this.clone({_finders: finders});
+    var finders = this._finders && (this._finders.slice() || [])
+    finders.push(finder)
+    return this.clone({_finders: finders})
   },
 
-  createElementTester: function(criteria) {
-    var self = this;
+  createElementTester: function (criteria) {
+    var self = this
 
     if (typeof criteria === 'string') {
-      criteria = { css: criteria };
+      criteria = { css: criteria }
     }
 
     if (typeof criteria === 'function') {
-      criteria = { predicate: criteria };
+      criteria = { predicate: criteria }
     }
 
     return {
-      find: function($el) {
-        var message = criteria.message;
-        Object.keys(criteria).forEach(function(key){
-          var value = criteria[key];
-          var tester = self._elementTesters[key];
+      find: function ($el) {
+        var message = criteria.message
+        Object.keys(criteria).forEach(function (key) {
+          var value = criteria[key]
+          var tester = self._elementTesters[key]
 
           if (value !== undefined && tester !== undefined) {
-            tester.call(self, $el, message, value);
+            tester.call(self, $el, message, value)
           }
-        });
-        return $el;
+        })
+        return $el
       },
 
-      toString: function(){
-        return criteria.message || criteria.css || criteria.text;
+      toString: function () {
+        return criteria.message || criteria.css || criteria.text
       }
-    };
+    }
   },
 
   find: function (selector, options) {
-    var $ = this.get('$');
-    var message = JSON.stringify(options);
-    var scope = this.addFinder(this.elementFinder(selector));
+    var message = JSON.stringify(options)
+    var scope = this.addFinder(this.elementFinder(selector))
 
     if (options) {
-      var tester = this.createElementTester(options);
+      var tester = this.createElementTester(options)
 
       return scope.filter(function (element) {
         try {
-          return tester.find(element);
+          return tester.find(element)
         } catch (error) {
-          return false;
+          return false
         }
-      }, message);
+      }, message)
     } else {
-      return scope;
+      return scope
     }
   },
 
   containing: function (selector, options) {
-    var $ = this.get('$');
-    var message = options && JSON.stringify(options);
-    var findElements = this.elementFinder(selector);
-    var finder;
+    var $ = this.get('$')
+    var message = options && JSON.stringify(options)
+    var findElements = this.elementFinder(selector)
+    var finder
 
     if (options) {
-      var tester = this.createElementTester(options);
+      var tester = this.createElementTester(options)
 
       finder = {
         find: function (elements) {
-          var found = findElements.find(elements);
+          var found = findElements.find(elements)
           var tested = found.toArray().filter(function (element) {
             try {
-              tester.find(element);
-              return true;
+              tester.find(element)
+              return true
             } catch (error) {
-              return false;
+              return false
             }
-          });
+          })
 
           if (tested.length > 0) {
-            return tested;
+            return tested
           }
         },
 
         toString: function () {
-          return selector + (message? ' ' + message: '');
+          return selector + (message ? ' ' + message : '')
         }
       }
     } else {
-      finder = findElements;
+      finder = findElements
     }
 
     return this.addFinder({
-      find: function(elements) {
-        var els = Array.prototype.filter.call(elements, function(el) {
+      find: function (elements) {
+        var els = Array.prototype.filter.call(elements, function (el) {
           try {
-            return finder.find(el);
+            return finder.find(el)
           } catch (e) {
-            return false;
+            return false
           }
-        });
+        })
 
         if (els.length > 0) {
-          return $(els);
+          return $(els)
         }
       },
 
-      toString: function() {
-        return ':has(' + finder.toString() + ')';
+      toString: function () {
+        return ':has(' + finder.toString() + ')'
       }
-    });
+    })
   },
 
-  linkOrButton: function(label) {
+  linkOrButton: function (label) {
     return this.find(
       'a, button, input[type=submit], input[type=button], input[type=reset]',
       {label: label},
-      "[linkOrButton: " + label + "]"
-    );
+      '[linkOrButton: ' + label + ']'
+    )
   },
 
-  button: function(label) {
+  button: function (label) {
     return this.find(
       'button, input[type=submit], input[type=button], input[type=reset]',
       {label: label},
-      "[button: " + label + "]"
-    );
+      '[button: ' + label + ']'
+    )
   },
 
-  link: function(label) {
-    return this.find('a', {label: label}, "[link: " + label + "]");
+  link: function (label) {
+    return this.find('a', {label: label}, '[link: ' + label + ']')
   },
 
   elements: function (options) {
-    options = Options.default(options, {allowMultiple: true});
-    return this.resolve(options);
+    options = Options.default(options, {allowMultiple: true})
+    return this.resolve(options)
   },
 
   element: function (options) {
-    var $ = this.get('$');
+    var $ = this.get('$')
     return this.resolve(options).then(function (elements) {
-      return $(elements[0]);
-    });
+      return $(elements[0])
+    })
   },
 
   printFinders: function (finders) {
-    return finders.map(function (f) { return f.toString(); }).join(' ').replace(/\s+\:/g,':');
+    return finders.map(function (f) { return f.toString() }).join(' ').replace(/\s+:/g, ':')
   },
 
   findElements: function (options) {
-    var $ = this.get('$');
-    var self = this;
-    var allowMultiple = Options.get(options, 'allowMultiple');
+    var $ = this.get('$')
+    var self = this
+    var allowMultiple = Options.get(options, 'allowMultiple')
 
-    function findWithFinder(el, finderIndex) {
-      var finder = self._finders[finderIndex];
+    function findWithFinder (el, finderIndex) {
+      var finder = self._finders[finderIndex]
 
       if (finder) {
-        var found = finder.find(el);
+        var found = finder.find(el)
 
         if (!found) {
-          throw new Error("expected to find: " + self.printFinders(self._finders));
+          throw new Error('expected to find: ' + self.printFinders(self._finders))
         }
 
-        return findWithFinder(found, finderIndex + 1);
+        return findWithFinder(found, finderIndex + 1)
       } else {
-        return el;
+        return el
       }
     };
 
-    function selector() {
-      var selector = self._selector;
+    function selector () {
+      var selector = self._selector
       if (
         selector &&
-        typeof Element !== 'undefined' &&
-        selector instanceof Element &&
-        selector.tagName == 'IFRAME'
+        typeof window.Element !== 'undefined' &&
+        selector instanceof window.Element &&
+        selector.tagName === 'IFRAME'
       ) {
-        return selector.contentDocument;
+        return selector.contentDocument
       } else if (
         selector &&
         typeof selector.prop === 'function' &&
         selector.prop('tagName') === 'IFRAME'
       ) {
-        return selector[0].contentDocument;
+        return selector[0].contentDocument
       } else {
-        return selector || 'html';
+        return selector || 'html'
       }
     }
 
-    var elements = findWithFinder($(selector()), 0);
+    var elements = findWithFinder($(selector()), 0)
     if (!allowMultiple) {
-      expectOneElement(self, elements);
+      expectOneElement(self, elements)
     }
 
-    return elements.toArray();
+    return elements.toArray()
   },
 
-  resolve: function(options) {
-    var self = this;
-    var defaultTimeout = this.get('timeout') || 1000;
-    var retryOptions = Options.remove(options, ['timeout', 'interval']);
-    retryOptions.timeout = retryOptions.timeout || defaultTimeout;
+  resolve: function (options) {
+    var self = this
+    var defaultTimeout = this.get('timeout') || 1000
+    var retryOptions = Options.remove(options, ['timeout', 'interval'])
+    retryOptions.timeout = retryOptions.timeout || defaultTimeout
 
-    var result = this.retry(retryOptions, function() {
-      return self.findElements(options);
-    });
+    var result = this.retry(retryOptions, function () {
+      return self.findElements(options)
+    })
 
-    return result;
+    return result
   },
 
-  notResolve: function(options) {
-    var self = this;
+  notResolve: function (options) {
+    var self = this
 
-    return this.retry(options, function() {
-      var found = false;
+    return this.retry(options, function () {
+      var found = false
       try {
-        self.findElements({allowMultiple: true});
-        found = true;
+        self.findElements({allowMultiple: true})
+        found = true
       } catch (e) {
       }
       if (found) {
-        throw new Error("didn't expect to find element: " + self.printFinders(self._finders));
+        throw new Error("didn't expect to find element: " + self.printFinders(self._finders))
       }
-    });
+    })
   },
   filter: function (filter, message) {
-    var $ = this.get('$');
+    var $ = this.get('$')
     return this.addFinder({
       find: function (elements) {
-        var filteredElements = elements.toArray().filter(function(element){
+        var filteredElements = elements.toArray().filter(function (element) {
           return filter($(element))
-        });
+        })
 
         if (filteredElements && filteredElements.length > 0) {
-          return $(filteredElements);
+          return $(filteredElements)
         }
       },
 
       toString: function () {
-        return message || '[filter]';
+        return message || '[filter]'
       }
-    });
+    })
   },
 
   enabled: function () {
     return this.filter(function (element) {
-      var tagName = element.prop('tagName');
-      return !((tagName == 'BUTTON' || tagName == 'INPUT') && element.prop('disabled'));
-    }, '[disabled=false]');
+      var tagName = element.prop('tagName')
+      return !((tagName === 'BUTTON' || tagName === 'INPUT') && element.prop('disabled'))
+    }, '[disabled=false]')
   }
 
-};
+}
diff --git a/hyperdom.js b/hyperdom.js
index 916073e..77c71fd 100644
--- a/hyperdom.js
+++ b/hyperdom.js
@@ -1,41 +1,41 @@
-var Mount = require('./mount');
-var hyperdom = require('hyperdom');
-var createMonkey = require('./create');
-var window = require('global');
+var Mount = require('./mount')
+var hyperdom = require('hyperdom')
+var createMonkey = require('./create')
+var window = require('global')
 var createTestDiv = require('./createTestDiv')
 var extend = require('lowscore/extend')
 
-module.exports = function(app, options) {
+module.exports = function (app, options) {
   return new Mount(app, {
-    stopApp: function(){
+    stopApp: function () {
     },
-    startApp: function(){
+    startApp: function () {
       if (options && options.router) {
         options.router.reset()
       }
-      var app = this.app;
+      var app = this.app
 
       if (Mount.runningInNode) {
         try {
-          var vquery = require('vdom-query');
+          var vquery = require('vdom-query')
         } catch (e) {
-          throw new Error('you must `npm install vdom-query --save-dev` to run tests in node');
+          throw new Error('you must `npm install vdom-query --save-dev` to run tests in node')
         }
-        var vdom = hyperdom.html('body');
+        var vdom = hyperdom.html('body')
 
-        var monkey = createMonkey(vdom);
-        monkey.set({$: vquery, visibleOnly: false, document: {}});
+        var monkey = createMonkey(vdom)
+        monkey.set({$: vquery, visibleOnly: false, document: {}})
 
-        hyperdom.appendVDom(vdom, app, extend({ requestRender: setTimeout, window: window }, options));
-        return monkey;
+        hyperdom.appendVDom(vdom, app, extend({ requestRender: setTimeout, window: window }, options))
+        return monkey
       } else {
         var testDiv = createTestDiv()
         if (options && (options.hash || options.url) && options.router) {
           options.router.push(options.url || options.hash)
         }
-        hyperdom.append(testDiv, app, extend({ requestRender: setTimeout }, options));
-        return createMonkey(testDiv);
+        hyperdom.append(testDiv, app, extend({ requestRender: setTimeout }, options))
+        return createMonkey(testDiv)
       }
     }
-  }).start();
+  }).start()
 }
diff --git a/iframe.js b/iframe.js
index a708cd5..dadbbf9 100644
--- a/iframe.js
+++ b/iframe.js
@@ -1,46 +1,45 @@
 var debug = require('debug')('browser-monkey:angular')
-var Mount = require('./mount');
-var createMonkey = require('./create');
-var hobostyle = require('hobostyle');
-var createTestDiv = require('./createTestDiv');
-var addressBarInterval;
+var Mount = require('./mount')
+var createMonkey = require('./create')
+var hobostyle = require('hobostyle')
+var createTestDiv = require('./createTestDiv')
+var addressBarInterval
 
-module.exports = function(url) {
+module.exports = function (url) {
   return new Mount(url, {
-    stopApp: function(){},
-    startApp: function(){
+    stopApp: function () {},
+    startApp: function () {
       debug('Mounting iframe: ' + url)
-      var div = createTestDiv();
-      var addressBar = document.createElement('div');
-      addressBar.innerText = url;
-      addressBar.className = 'address-bar';
-      div.appendChild(addressBar);
+      var div = createTestDiv()
+      var addressBar = document.createElement('div')
+      addressBar.innerText = url
+      addressBar.className = 'address-bar'
+      div.appendChild(addressBar)
 
-      var iframe = document.createElement('iframe');
-      iframe.src = url;
+      var iframe = document.createElement('iframe')
+      iframe.src = url
       iframe.onload = function () {
-        addressBar.innerText = iframe.contentWindow.location.href;
-      };
-      iframe.height = window.innerHeight - addressBar.clientHeight - 10;
-      div.appendChild(iframe);
+        addressBar.innerText = iframe.contentWindow.location.href
+      }
+      iframe.height = window.innerHeight - addressBar.clientHeight - 10
+      div.appendChild(iframe)
 
       if (addressBarInterval) {
-        clearInterval(addressBarInterval);
+        clearInterval(addressBarInterval)
       }
       addressBarInterval = setInterval(function () {
         if (iframe.contentWindow) {
-          addressBar.innerText = iframe.contentWindow.location.href;
+          addressBar.innerText = iframe.contentWindow.location.href
         } else {
-          clearInterval(addressBarInterval);
+          clearInterval(addressBarInterval)
         }
-      }, 300);
+      }, 300)
 
-      hobostyle.style('html,body { margin: 0; height: 100%; }');
-      hobostyle.style('iframe { border: none; width: 100%; }');
+      hobostyle.style('html,body { margin: 0; height: 100%; }')
+      hobostyle.style('iframe { border: none; width: 100%; }')
       hobostyle.style('.address-bar { padding: 5px; font-family: arial; font-size: 20px; border-bottom: 1px solid gray; }')
 
-      return createMonkey(iframe);
+      return createMonkey(iframe)
     }
-  }).start();
+  }).start()
 }
-
diff --git a/index.js b/index.js
index b385d8a..9838084 100644
--- a/index.js
+++ b/index.js
@@ -1 +1 @@
-module.exports = require('./create')();
+module.exports = require('./create')()
diff --git a/jquery.js b/jquery.js
index 94f58de..deb61f9 100644
--- a/jquery.js
+++ b/jquery.js
@@ -1,63 +1,62 @@
-var jquery = require('jquery');
-function dispatchEvent(element, eventType){
-  var event;
+var jquery = require('jquery')
+function dispatchEvent (element, eventType) {
+  var event
 
   if (eventType === 'click') {
-    element.click();
+    element.click()
   } else {
     if (document.createEvent) {
-      event = document.createEvent("Event");
-      event.initEvent(eventType, true, true);
-      element.dispatchEvent(event);
+      event = document.createEvent('Event')
+      event.initEvent(eventType, true, true)
+      element.dispatchEvent(event)
     } else {
-      event = document.createEventObject();
-      event.eventType = eventType;
-      event.eventName = eventType;
-      element.fireEvent("on" + event.eventType, event);
+      event = document.createEventObject()
+      event.eventType = eventType
+      event.eventName = eventType
+      element.fireEvent('on' + event.eventType, event)
     }
   }
 }
 
 if (jquery.fn) {
   jquery.fn.extend({
-    innerText: function(){
-      var el = this[0].body || this[0];
-      return el.innerText || el.textContent;
+    innerText: function () {
+      var el = this[0].body || this[0]
+      return el.innerText || el.textContent
     },
 
-    trigger: function(eventType){
-      for (var i=0; i<this.length; i++){
-        var element = this[i];
+    trigger: function (eventType) {
+      for (var i = 0; i < this.length; i++) {
+        var element = this[i]
         if (eventType === 'submit' && element.form) {
           if (!jquery.preventFormSubmit) {
-            element.form.submit();
+            element.form.submit()
           }
-          dispatchEvent(element.form, eventType);
-        }
-        else {
-          dispatchEvent(element, eventType);
+          dispatchEvent(element.form, eventType)
+        } else {
+          dispatchEvent(element, eventType)
         }
       }
 
-      return this;
+      return this
     },
 
-    on: function(eventType, cb){
-      for (var i=0; i<this.length; i++){
-        var element = this[i];
-        element.addEventListener(eventType, cb, false);
+    on: function (eventType, cb) {
+      for (var i = 0; i < this.length; i++) {
+        var element = this[i]
+        element.addEventListener(eventType, cb, false)
       }
-      return this;
+      return this
     },
 
-    focus: function(){
-      for (var i=0; i<this.length; i++){
-        var element = this[i];
-        element.focus();
+    focus: function () {
+      for (var i = 0; i < this.length; i++) {
+        var element = this[i]
+        element.focus()
       }
-      return this;
+      return this
     }
-  });
+  })
 }
 
-module.exports = jquery;
+module.exports = jquery
diff --git a/karma.conf.js b/karma.conf.js
index 7f8fa6f..aec5277 100644
--- a/karma.conf.js
+++ b/karma.conf.js
@@ -1,4 +1,4 @@
-module.exports = function(config) {
+module.exports = function (config) {
   config.set({
     basePath: '',
     frameworks: ['browserify', 'mocha', 'server-side'],
@@ -6,7 +6,7 @@ module.exports = function(config) {
       'test/global.js',
       'test/**/*Spec.js',
       'test/page1.html',
-      'test/page2.html',
+      'test/page2.html'
     ],
     exclude: [
       '**/*.sw?'
@@ -17,13 +17,13 @@ module.exports = function(config) {
     },
 
     envPreprocessor: [
-      'BM_TIMEOUT',
+      'BM_TIMEOUT'
     ],
 
     browserify: {
       debug: true,
       extensions: ['.jsx'],
-      transform: ['babelify', [require('./removeStrictFromSend'), {global: true}]],
+      transform: ['babelify', [require('./removeStrictFromSend'), {global: true}]]
     },
 
     client: {
@@ -31,12 +31,12 @@ module.exports = function(config) {
         timeout: 0
       }
     },
-    reporters: process.env.BROWSERS? ['dots']: ['mocha'],
+    reporters: process.env.BROWSERS ? ['dots'] : ['mocha'],
     port: 9876,
     colors: true,
     logLevel: config.LOG_INFO,
     autoWatch: true,
-    browsers: process.env.BROWSERS == 'all'? Object.keys(browsers): ['Chrome'],
+    browsers: process.env.BROWSERS === 'all' ? Object.keys(browsers) : ['Chrome'],
 
     browserStack: {
       username: process.env.BROWSERSTACK_USER,
@@ -51,85 +51,86 @@ module.exports = function(config) {
     proxies: {
       '/iframe-test/': 'http://localhost:4572/'
     }
-  });
-};
+  })
+}
 
 var browsers = {
   'browserstack-windows-firefox': {
     base: 'BrowserStack',
-    browser : 'Firefox',
-    browser_version : '52.0',
-    os : 'Windows',
-    os_version : '10',
-    resolution : '1280x1024'
+    browser: 'Firefox',
+    browser_version: '52.0',
+    os: 'Windows',
+    os_version: '10',
+    resolution: '1280x1024'
   },
   'browserstack-osx-firefox': {
     base: 'BrowserStack',
-    browser : 'Firefox',
-    browser_version : '52.0',
-    os : 'OS X',
-    os_version : 'Sierra',
-    resolution : '1280x1024'
+    browser: 'Firefox',
+    browser_version: '52.0',
+    os: 'OS X',
+    os_version: 'Sierra',
+    resolution: '1280x1024'
   },
   'browserstack-safari': {
     base: 'BrowserStack',
-    browser : 'Safari',
-    browser_version : '10',
-    os : 'OS X',
-    os_version : 'Sierra',
-    resolution : '1280x1024'
+    browser: 'Safari',
+    browser_version: '10',
+    os: 'OS X',
+    os_version: 'Sierra',
+    resolution: '1280x1024'
   },
   'browserstack-safari-ios': {
     base: 'BrowserStack',
-    device : 'iPhone 6S',
-    os : 'ios',
-    os_version : '9.1',
+    device: 'iPhone 6S',
+    os: 'ios',
+    os_version: '9.1'
   },
   'browserstack-windows-chrome': {
     base: 'BrowserStack',
-    browser : 'Chrome',
-    browser_version : '52.0',
-    os : 'Windows',
-    os_version : '10',
-    resolution : '1280x1024'
+    browser: 'Chrome',
+    browser_version: '52.0',
+    os: 'Windows',
+    os_version: '10',
+    resolution: '1280x1024'
   },
   'browserstack-osx-chrome': {
     base: 'BrowserStack',
-    browser : 'Chrome',
-    browser_version : '52.0',
-    os : 'OS X',
-    os_version : 'Sierra',
-    resolution : '1280x1024'
+    browser: 'Chrome',
+    browser_version: '52.0',
+    os: 'OS X',
+    os_version: 'Sierra',
+    resolution: '1280x1024'
   },
   'browserstack-ie9': {
     base: 'BrowserStack',
-    browser : 'IE',
-    browser_version : '9.0',
-    os : 'Windows',
-    os_version : '7',
-    resolution : '1280x1024'
+    browser: 'IE',
+    browser_version: '9.0',
+    os: 'Windows',
+    os_version: '7',
+    resolution: '1280x1024'
   },
   'browserstack-ie10': {
     base: 'BrowserStack',
-    browser : 'IE',
-    browser_version : '10.0',
-    os : 'Windows',
-    os_version : '8',
-    resolution : '1280x1024'
+    browser: 'IE',
+    browser_version: '10.0',
+    os: 'Windows',
+    os_version: '8',
+    resolution: '1280x1024'
   },
   'browserstack-ie11': {
     base: 'BrowserStack',
-    browser : 'IE',
-    browser_version : '11.0',
-    os : 'Windows',
-    os_version : '10',
-    resolution : '1280x1024'
-  },'browserstack-edge': {
-    base: 'BrowserStack',
-    browser : 'Edge',
-    browser_version : '13.0',
-    os : 'Windows',
-    os_version : '10',
-    resolution : '1280x1024'
+    browser: 'IE',
+    browser_version: '11.0',
+    os: 'Windows',
+    os_version: '10',
+    resolution: '1280x1024'
   },
-};
+  'browserstack-edge': {
+    base: 'BrowserStack',
+    browser: 'Edge',
+    browser_version: '13.0',
+    os: 'Windows',
+    os_version: '10',
+    resolution: '1280x1024'
+  }
+}
diff --git a/mount.js b/mount.js
index e84e28a..6c18855 100644
--- a/mount.js
+++ b/mount.js
@@ -1,48 +1,47 @@
-var window = require('global');
-var document = window.document;
+var window = require('global')
+var document = window.document
 
-function Mount(app, options) {
-  this.app = app;
-  this.startApp = options.startApp.bind(this);
-  this.stopApp = options.stopApp.bind(this);
+function Mount (app, options) {
+  this.app = app
+  this.startApp = options.startApp.bind(this)
+  this.stopApp = options.stopApp.bind(this)
 }
 
-Mount.prototype.start = function() {
+Mount.prototype.start = function () {
   var monkey = this.startApp()
 
   monkey.set({
     app: this.app,
-    mount: this,
+    mount: this
   })
 
-  return monkey;
+  return monkey
 }
 
-Mount.prototype.stop = function(){
-  this.stopApp();
+Mount.prototype.stop = function () {
+  this.stopApp()
 }
 
 Mount.runningInNode =
   (typeof process !== 'undefined') &&
   (typeof process.versions.node !== 'undefined') &&
-  (typeof process.versions.electron === 'undefined');
+  (typeof process.versions.electron === 'undefined')
 
-module.exports = Mount;
+module.exports = Mount
 
-function addRefreshButton() {
-  var refreshLink = document.createElement('a');
-  refreshLink.href = window.location.href;
-  refreshLink.innerText = 'refresh';
-  document.body.appendChild(refreshLink);
-  document.body.appendChild(document.createElement('hr'));
+function addRefreshButton () {
+  var refreshLink = document.createElement('a')
+  refreshLink.href = window.location.href
+  refreshLink.innerText = 'refresh'
+  document.body.appendChild(refreshLink)
+  document.body.appendChild(document.createElement('hr'))
 }
 
 if (Mount.runningInNode) {
-  require('./stubBrowser');
+  require('./stubBrowser')
 } else {
   if (/\/debug\.html$/.test(window.location.pathname)) {
-    localStorage['debug'] = 'browser-monkey';
-    addRefreshButton();
+    window.localStorage['debug'] = 'browser-monkey'
+    addRefreshButton()
   }
 }
-
diff --git a/options.js b/options.js
index 0c3b3ba..4ad2251 100644
--- a/options.js
+++ b/options.js
@@ -1,57 +1,56 @@
-function Options(options){
-  this.options = options;
-  this.isOptionsObject = typeof options === 'object';
-  this.validOptions = [];
+function Options (options) {
+  this.options = options
+  this.isOptionsObject = typeof options === 'object'
+  this.validOptions = []
 }
 
-
-Options.get = function(options, propertyName){
+Options.get = function (options, propertyName) {
   if (typeof options === 'object') {
-    var value = options[propertyName];
-    return value;
+    var value = options[propertyName]
+    return value
   }
 }
 
-Options.remove = function(options, propertyNames){
-  var newOptions = {};
+Options.remove = function (options, propertyNames) {
+  var newOptions = {}
 
   if (typeof options === 'object') {
-    propertyNames.forEach(function(propertyName){
-      newOptions[propertyName] = options[propertyName];
-      delete options[propertyName];
-    });
+    propertyNames.forEach(function (propertyName) {
+      newOptions[propertyName] = options[propertyName]
+      delete options[propertyName]
+    })
   }
 
-  return newOptions;
+  return newOptions
 }
 
-Options.default = function(options, defaults){
-  var newOptions = typeof options === 'object' ? options : {};
+Options.default = function (options, defaults) {
+  var newOptions = typeof options === 'object' ? options : {}
 
-  Object.keys(defaults).forEach(function(key){
+  Object.keys(defaults).forEach(function (key) {
     if (!newOptions.hasOwnProperty(key)) {
       newOptions[key] = defaults[key]
     }
-  });
+  })
 
-  return newOptions;
+  return newOptions
 }
 
-Options.prototype.option = function(name) {
-  this.validOptions.push(name);
+Options.prototype.option = function (name) {
+  this.validOptions.push(name)
   if (this.isOptionsObject) {
-    var value = this.options.hasOwnProperty(name)? this.options[name]: undefined;
-    delete this.options[name];
-    return value;
+    var value = this.options.hasOwnProperty(name) ? this.options[name] : undefined
+    delete this.options[name]
+    return value
   }
 }
 
-Options.prototype.validate = function(){
+Options.prototype.validate = function () {
   if (this.isOptionsObject) {
-    var keys = Object.keys(this.options);
+    var keys = Object.keys(this.options)
 
     if (keys.length > 0) {
-      throw new Error('properties ' + keys.join(', ') + ' not recognised, try ' + this.validOptions.join(', '));
+      throw new Error('properties ' + keys.join(', ') + ' not recognised, try ' + this.validOptions.join(', '))
     }
   }
 }
diff --git a/package.json b/package.json
index 72b34c8..40084eb 100644
--- a/package.json
+++ b/package.json
@@ -4,7 +4,7 @@
   "description": "reliable dom testing",
   "main": "index.js",
   "scripts": {
-    "test": "mocha && karma start --single-run"
+    "test": "standard && mocha && karma start --single-run"
   },
   "engines": {
     "node": "7.6.0"
@@ -42,6 +42,7 @@
     "react": "^15.4.1",
     "react-dom": "^15.4.1",
     "server-destroy": "^1.0.1",
+    "standard": "^10.0.0",
     "vdom-query": "https://github.com/featurist/vdom-query",
     "virtual-dom": "^2.1.1",
     "watchify": "^3.7.0"
@@ -59,6 +60,9 @@
     "lowscore": "^1.12.1",
     "trytryagain": "1.2.0"
   },
+  "standard": {
+    "env": ["mocha"]
+  },
   "browserify": {
     "transform": [
       "browserify-optional"
diff --git a/promise.js b/promise.js
index f54b94e..04ef42b 100644
--- a/promise.js
+++ b/promise.js
@@ -1,16 +1,16 @@
-var FinishedPromise = require('finished-promise');
-var trytryagain = require('trytryagain');
+var FinishedPromise = require('finished-promise')
+var trytryagain = require('trytryagain')
 
-function immediately(retryOptions, fn) {
-  return FinishedPromise.resolve().then(fn);
+function immediately (retryOptions, fn) {
+  return FinishedPromise.resolve().then(fn)
 }
 
 module.exports = {
   promise: function () {
-    return this.get('immediate') ? FinishedPromise : Promise;
+    return this.get('immediate') ? FinishedPromise : Promise
   },
 
   retry: function (options, fn) {
-    return this.get('immediate') ? immediately(options, fn) : trytryagain(options, fn);
+    return this.get('immediate') ? immediately(options, fn) : trytryagain(options, fn)
   }
 }
diff --git a/react.js b/react.js
index 7e859b8..602556e 100644
--- a/react.js
+++ b/react.js
@@ -1,18 +1,18 @@
-var Mount = require('./mount');
+var Mount = require('./mount')
 var React = require('react')
 var ReactDOM = require('react-dom')
-var createMonkey = require('./create');
-var createTestDiv = require('./createTestDiv');
+var createMonkey = require('./create')
+var createTestDiv = require('./createTestDiv')
 
-module.exports = function(app) {
+module.exports = function (app) {
   return new Mount(app, {
-    stopApp: function() {
+    stopApp: function () {
     },
-    startApp: function() {
+    startApp: function () {
       var div = createTestDiv()
       ReactDOM.render(React.createElement(this.app.constructor, null), div)
 
-      return createMonkey(document.body);
+      return createMonkey(document.body)
     }
   }).start()
 }
diff --git a/reloadButton.js b/reloadButton.js
index 6c8b2ac..f997621 100644
--- a/reloadButton.js
+++ b/reloadButton.js
@@ -2,7 +2,7 @@ var href = window.location.href
 var hobostyle = require('hobostyle')
 var extend = require('lowscore/extend')
 
-module.exports = function refreshButton(_options) {
+module.exports = function refreshButton (_options) {
   var options = extend({
     style: true,
     class: 'browser-monkey-reload'
@@ -10,21 +10,21 @@ module.exports = function refreshButton(_options) {
 
   if (options.style) {
     hobostyle.style(
-      '.' + options['class'] + ' {'
-        + 'z-index: 1000;'
-        + 'position: fixed;'
-        + 'right: 5px;'
-        + 'bottom: 5px;'
-        + 'background-color: rgba(255, 255, 255, 0.85);'
-        + 'padding: 5px 10px;'
-        + 'text-decoration: none;'
-        + 'color: #444444;'
-        + 'font-family: "Open Sans", sans-serif;'
-      + '}'
-      + '.' + options['class'] + ':hover {'
-        + 'color: black;'
-        + 'box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 5px;'
-      + '}')
+      '.' + options['class'] + ' {' +
+        'z-index: 1000;' +
+        'position: fixed;' +
+        'right: 5px;' +
+        'bottom: 5px;' +
+        'background-color: rgba(255, 255, 255, 0.85);' +
+        'padding: 5px 10px;' +
+        'text-decoration: none;' +
+        'color: #444444;' +
+        'font-family: "Open Sans", sans-serif;' +
+      '}' +
+      '.' + options['class'] + ':hover {' +
+        'color: black;' +
+        'box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 5px;' +
+      '}')
   }
 
   var link = document.createElement('a')
diff --git a/removeStrictFromSend.js b/removeStrictFromSend.js
index 0e38b28..b1571d3 100644
--- a/removeStrictFromSend.js
+++ b/removeStrictFromSend.js
@@ -1,6 +1,5 @@
-var util = require('util');
-var through = require('through');
-var path = require('path');
+var through = require('through')
+var path = require('path')
 
 // in pre safari 10 send causes a strict mode bug to occur in safari
 // and so can't load vinehill/express apps at all
@@ -9,35 +8,35 @@ var path = require('path');
 // in any browser anymore. will be able to remove this once
 // older versions of safari are less used
 
-function unstrictifySend(file, opts) {
-  opts = opts || {};
-  opts.exclude = ['json'].concat(opts.exclude||[]);
+function unstrictifySend (file, opts) {
+  opts = opts || {}
+  opts.exclude = ['json'].concat(opts.exclude || [])
 
-  var stream = through(write, end);
-  var applied = false;
+  var stream = through(write, end)
+  var applied = false
 
-  var filetype = path.extname(file).replace('.', '');
+  var filetype = path.extname(file).replace('.', '')
   var excluded = (opts.exclude).some(function (excludedExt) {
-    return filetype == excludedExt.replace('.', '');
-  });
+    return filetype === excludedExt.replace('.', '')
+  })
 
-  return stream;
+  return stream
 
-  function write(buf) {
+  function write (buf) {
     if (!applied && !excluded) {
-      applied = true;
+      applied = true
     }
-    if (file.indexOf('send/index.js') != -1) {
+    if (file.indexOf('send/index.js') !== -1) {
       var output = buf.toString().replace(/'use strict'/, '')
       stream.queue(output)
     } else {
-      stream.queue(buf);
+      stream.queue(buf)
     }
   }
 
-  function end() {
-    stream.queue(null);
+  function end () {
+    stream.queue(null)
   }
 }
 
-module.exports = unstrictifySend;
+module.exports = unstrictifySend
diff --git a/selector.js b/selector.js
index 49d13d1..62334ab 100644
--- a/selector.js
+++ b/selector.js
@@ -1,78 +1,78 @@
-var elementTester = require('./elementTester');
-var global = require('global');
-
-function Selector(selector, finders, options) {
-  this._selector = selector;
-  this._finders = finders || [];
-  this._options = options || { visibleOnly: true, $: require('./jquery'), document: global.document, immediate: false, timeout: 1000 };
-  this._handlers = [];
-  this._elementTesters = elementTester;
+var elementTester = require('./elementTester')
+var global = require('global')
+
+function Selector (selector, finders, options) {
+  this._selector = selector
+  this._finders = finders || []
+  this._options = options || { visibleOnly: true, $: require('./jquery'), document: global.document, immediate: false, timeout: 1000 }
+  this._handlers = []
+  this._elementTesters = elementTester
 }
 
-Selector.prototype.set = function(options){
-  var self = this;
-  Object.keys(options).forEach(function(key){
-    self._options[key] = options[key];
-  });
-  return this;
+Selector.prototype.set = function (options) {
+  var self = this
+  Object.keys(options).forEach(function (key) {
+    self._options[key] = options[key]
+  })
+  return this
 }
 
-Selector.prototype.get = function(key){
-  return this._options[key];
+Selector.prototype.get = function (key) {
+  return this._options[key]
 }
 
 Selector.prototype.clone = function (extension) {
-  var clone = new this.constructor();
-  var self = this;
+  var clone = new this.constructor()
+  var self = this
 
   Object.keys(self).forEach(function (key) {
-    clone[key] = self[key];
-  });
+    clone[key] = self[key]
+  })
 
   Object.keys(extension).forEach(function (key) {
-    clone[key] = extension[key];
-  });
+    clone[key] = extension[key]
+  })
 
-  return clone;
-};
+  return clone
+}
 
 Selector.prototype.on = function (handler) {
-  this._handlers.push(handler);
-  return this;
-};
+  this._handlers.push(handler)
+  return this
+}
 
 Selector.prototype.handleEvent = function () {
-  var args = arguments;
+  var args = arguments
 
   this._handlers.forEach(function (handler) {
-    handler.apply(undefined, args);
-  });
-};
+    handler.apply(undefined, args)
+  })
+}
 
 Selector.prototype.scope = function (scope) {
   if (scope instanceof Selector) {
-    return this.clone(scope);
+    return this.clone(scope)
   } else {
-    return this.clone({_selector: scope});
+    return this.clone({_selector: scope})
   }
-};
+}
 
 Selector.prototype.extend = function (methods) {
-  return this.component(methods);
-};
+  return this.component(methods)
+}
 
 Selector.prototype.component = function (methods) {
-  function Component() {
-    Selector.apply(this, arguments);
+  function Component () {
+    Selector.apply(this, arguments)
   }
 
-  Component.prototype = new this.constructor();
+  Component.prototype = new this.constructor()
   Object.keys(methods).forEach(function (method) {
-    Component.prototype[method] = methods[method];
-  });
-  Component.prototype.constructor = Component;
+    Component.prototype[method] = methods[method]
+  })
+  Component.prototype.constructor = Component
 
-  return new Component().scope(this);
-};
+  return new Component().scope(this)
+}
 
-module.exports = Selector;
+module.exports = Selector
diff --git a/sendkeys.js b/sendkeys.js
index 44cec2f..fa41405 100644
--- a/sendkeys.js
+++ b/sendkeys.js
@@ -1,37 +1,37 @@
-function dispatchEvent(el, type, char) {
-  el.trigger(type, {charCode: char});
+function dispatchEvent (el, type, char) {
+  el.trigger(type, {charCode: char})
 }
 
-function sendkey(el, char) {
-  dispatchEvent(el, "keydown", char);
-  dispatchEvent(el, "keypress", char);
-  dispatchEvent(el, "input");
-  dispatchEvent(el, "keyup", char);
+function sendkey (el, char) {
+  dispatchEvent(el, 'keydown', char)
+  dispatchEvent(el, 'keypress', char)
+  dispatchEvent(el, 'input')
+  dispatchEvent(el, 'keyup', char)
 }
 
-function sendkeys(el, text) {
-  var originalValue = el.val();
+function sendkeys (el, text) {
+  var originalValue = el.val()
 
   if (text.length === 0) {
-    el.val('');
-    sendkey(el, '');
+    el.val('')
+    sendkey(el, '')
   } else {
     for (var n = 0; n < text.length; ++n) {
-      var char = text[n];
-      var value = text.substring(0, n + 1);
-      el.val(value);
-      sendkey(el, char);
+      var char = text[n]
+      var value = text.substring(0, n + 1)
+      el.val(value)
+      sendkey(el, char)
     }
   }
 
-  if (originalValue !== text){
-    dispatchEvent(el, 'change');
+  if (originalValue !== text) {
+    dispatchEvent(el, 'change')
   }
 };
 
-sendkeys.html = function(el, html) {
-  el.innerHTML = html;
-  dispatchEvent(el, "input");
-};
+sendkeys.html = function (el, html) {
+  el.innerHTML = html
+  dispatchEvent(el, 'input')
+}
 
-module.exports = sendkeys;
+module.exports = sendkeys
diff --git a/setTestUrl.js b/setTestUrl.js
index e9331fc..8f8a6d2 100644
--- a/setTestUrl.js
+++ b/setTestUrl.js
@@ -1,4 +1,4 @@
-module.exports = function(options) {
+module.exports = function (options) {
   if (options) {
     if (options.hash !== undefined) {
       window.location.hash = options.hash
diff --git a/stubBrowser.js b/stubBrowser.js
index 1f4ee8b..706322b 100644
--- a/stubBrowser.js
+++ b/stubBrowser.js
@@ -1,26 +1,28 @@
-var window = require('global');
+var window = require('global')
 
-var registeredEvents = {};
-var pushState, replaceState;
+var registeredEvents = {}
+var pushState, replaceState
 
-pushState = replaceState = function(state, title, url) {
+pushState = replaceState = function (state, title, url) {
   window.location.pathname = url;
-  (registeredEvents['onpopstate'] || []).forEach(function(cb) { cb({}); });
-};
+  (registeredEvents['onpopstate'] || []).forEach(function (cb) {
+    cb()
+  })
+}
 
-window.location = window.location || {};
-window.location.pathname = window.location.pathname || '/';
-window.location.origin = window.location.origin || '';
-window.location.search = window.location.search || '';
+window.location = window.location || {}
+window.location.pathname = window.location.pathname || '/'
+window.location.origin = window.location.origin || ''
+window.location.search = window.location.search || ''
 window.history = {
   pushState: pushState,
-  replaceState: replaceState,
-};
+  replaceState: replaceState
+}
 
-window.addEventListener = function(eventName, cb) {
-  eventName = 'on'+eventName;
+window.addEventListener = function (eventName, cb) {
+  eventName = 'on' + eventName
   if (!registeredEvents[eventName]) {
-    registeredEvents[eventName] = [];
+    registeredEvents[eventName] = []
   }
-  registeredEvents[eventName].push(cb);
-};
+  registeredEvents[eventName].push(cb)
+}
diff --git a/test/actionsSpec.js b/test/actionsSpec.js
index f287d3e..f466473 100644
--- a/test/actionsSpec.js
+++ b/test/actionsSpec.js
@@ -1,317 +1,313 @@
-var AssertionError = require('assert').AssertionError
 var demand = require('must')
-var domTest = require('./domTest');
-var retry = require('trytryagain');
+var domTest = require('./domTest')
+var retry = require('trytryagain')
 
-describe('actions', function(){
+describe('actions', function () {
   describe('clicking', function () {
-    domTest('stack trace', function(browser, dom){
+    domTest('stack trace', function (browser, dom) {
       return browser.find('div')
         .click()
-        .assertStackTrace(__filename);
+        .assertStackTrace(__filename)
     }, {
       mochaOnly: true
-    });
+    })
 
     domTest('should eventually click an element', function (browser, dom, $) {
-      var promise = browser.find('.element').click();
-      var clicked = false;
+      var promise = browser.find('.element').click()
+      var clicked = false
 
       dom.eventuallyInsert(
         $('<div class="element"></div>').on('click', function () {
-          clicked = true;
+          clicked = true
         })
-      );
+      )
 
       return promise.then(function () {
-        demand(clicked).to.equal(true);
-      });
-    });
+        demand(clicked).to.equal(true)
+      })
+    })
 
     domTest('sends mousedown mouseup and click events', function (browser, dom) {
-      var events = [];
+      var events = []
 
       dom.insert('<div class="element"></div>').on('mousedown', function () {
-        events.push('mousedown');
+        events.push('mousedown')
       }).on('mouseup', function () {
-        events.push('mouseup');
+        events.push('mouseup')
       }).on('click', function () {
-        events.push('click');
-      });
+        events.push('click')
+      })
 
       return browser.find('.element').click().then(function () {
-        demand(events).to.eql(['mousedown', 'mouseup', 'click']);
-      });
-    });
+        demand(events).to.eql(['mousedown', 'mouseup', 'click'])
+      })
+    })
 
     domTest('mousedown mouseup and click events bubble up to parent', function (browser, dom) {
-      var events = [];
+      var events = []
 
       dom.insert('<div class="element"><div class="inner-element">inner</div></div>').on('mousedown', function () {
-        events.push('mousedown');
+        events.push('mousedown')
       }).on('mouseup', function () {
-        events.push('mouseup');
+        events.push('mouseup')
       }).on('click', function () {
-        events.push('click');
-      });
+        events.push('click')
+      })
 
       return browser.find('.inner-element').click().then(function () {
-        demand(events).to.eql(['mousedown', 'mouseup', 'click']);
-      });
-    }, {vdom: false});
+        demand(events).to.eql(['mousedown', 'mouseup', 'click'])
+      })
+    }, {vdom: false})
 
     domTest('waits until checkbox is enabled before clicking', function (browser, dom) {
-      var promise = browser.find('input[type=checkbox]').click();
-      var clicked;
-      var buttonState = 'disabled';
+      var promise = browser.find('input[type=checkbox]').click()
+      var clicked
+      var buttonState = 'disabled'
 
-      var button = dom.insert('<input type=checkbox disabled></input>');
+      var button = dom.insert('<input type=checkbox disabled></input>')
       button.on('click', function () {
-        clicked = buttonState;
-      });
+        clicked = buttonState
+      })
 
       setTimeout(function () {
-        button.prop('disabled', false);
+        button.prop('disabled', false)
         buttonState = 'enabled'
-      }, 10);
+      }, 10)
 
       return promise.then(function () {
-        demand(clicked).to.equal('enabled');
-      });
-    });
+        demand(clicked).to.equal('enabled')
+      })
+    })
 
     domTest('waits until button is enabled before clicking', function (browser, dom) {
-      var promise = browser.find('button', {text: 'a button'}).click();
-      var clicked;
-      var buttonState = 'disabled';
+      var promise = browser.find('button', {text: 'a button'}).click()
+      var clicked
+      var buttonState = 'disabled'
 
-      var button = dom.insert('<button disabled>a button</button>');
+      var button = dom.insert('<button disabled>a button</button>')
       button.on('click', function () {
-        clicked = buttonState;
-      });
+        clicked = buttonState
+      })
 
       setTimeout(function () {
-        button.prop('disabled', false);
+        button.prop('disabled', false)
         buttonState = 'enabled'
-      }, 10);
+      }, 10)
 
       return promise.then(function () {
-        demand(clicked).to.equal('enabled');
-      });
-    });
-  });
+        demand(clicked).to.equal('enabled')
+      })
+    })
+  })
 
-  describe('select', function(){
-    domTest('stack trace', function(browser, dom){
+  describe('select', function () {
+    domTest('stack trace', function (browser, dom) {
       return browser.find('div')
         .select({text: 'Text'})
-        .assertStackTrace(__filename);
+        .assertStackTrace(__filename)
     }, {
       mochaOnly: true
-    });
+    })
 
-    describe('text', function(){
-      domTest('respects timeout option', function(browser, dom, $){
-        var promise = browser.find('.element').select({text: 'Second', timeout: 3 });
+    describe('text', function () {
+      domTest('respects timeout option', function (browser, dom, $) {
+        var promise = browser.find('.element').select({text: 'Second', timeout: 3})
 
         dom.eventuallyInsert(
           $('<select class="element"><option>First</option><option>Second</option></select>')
-        , 6);
+        , 6)
 
         return demand(promise).reject.with.error()
-      });
+      })
 
-      domTest('respects timeout option, when passed separately from text', function(browser, dom, $){
-        var promise = browser.find('.element').select('Second', {timeout: 3 });
+      domTest('respects timeout option, when passed separately from text', function (browser, dom, $) {
+        var promise = browser.find('.element').select('Second', {timeout: 3})
 
         dom.eventuallyInsert(
           $('<select class="element"><option>First</option><option>Second</option></select>')
-        , 6);
+        , 6)
 
-        return demand(promise).reject.with.error('expected to find: .element select option {"timeout":3,"text":"Second"}');
-      });
+        return demand(promise).reject.with.error('expected to find: .element select option {"timeout":3,"text":"Second"}')
+      })
 
-      domTest('eventually selects an option element using the text', function(browser, dom, $){
-        var promise = browser.find('.element').select({text: 'Second'});
-        var selectedItem = undefined;
+      domTest('eventually selects an option element using the text', function (browser, dom, $) {
+        var promise = browser.find('.element').select({text: 'Second'})
+        var selectedItem
 
         dom.eventuallyInsert(
           $('<select class="element"><option>First</option><option>Second</option></select>').on('change', function () {
-            selectedItem = $(this).find('option[selected]').text();
+            selectedItem = $(this).find('option[selected]').text()
           })
-        );
+        )
 
         return promise.then(function () {
-          demand(selectedItem).to.equal('Second');
-        });
-      });
+          demand(selectedItem).to.equal('Second')
+        })
+      })
 
-      domTest('eventually selects an option element using the text, when text is passed as a string', function(browser, dom, $){
-        var promise = browser.find('.element').select('Second');
-        var selectedItem = undefined;
+      domTest('eventually selects an option element using the text, when text is passed as a string', function (browser, dom, $) {
+        var promise = browser.find('.element').select('Second')
+        var selectedItem
 
         dom.eventuallyInsert(
           $('<select class="element"><option>First</option><option>Second</option></select>').on('change', function () {
-            selectedItem = $(this).find('option[selected]').text();
+            selectedItem = $(this).find('option[selected]').text()
           })
-        );
+        )
 
         return promise.then(function () {
-          demand(selectedItem).to.equal('Second');
-        });
-      });
+          demand(selectedItem).to.equal('Second')
+        })
+      })
 
-      domTest('should eventually select an option element using a partial match', function(browser, dom, $){
-        var promise = browser.find('.element').select({text: 'Seco'});
-        var selectedItem = undefined;
+      domTest('should eventually select an option element using a partial match', function (browser, dom, $) {
+        var promise = browser.find('.element').select({text: 'Seco'})
+        var selectedItem
 
         dom.eventuallyInsert(
           $('<select class="element"><option>First</option><option>Second</option></select>').on('change', function (e) {
-            selectedItem = $(this).find('option[selected]').text();
+            selectedItem = $(this).find('option[selected]').text()
           })
-        );
+        )
 
         return promise.then(function () {
-          demand(selectedItem).to.equal('Second');
-        });
-      });
+          demand(selectedItem).to.equal('Second')
+        })
+      })
 
-      domTest('selects the first match if multiple available', function(browser, dom, $){
-        var selectedItem = undefined;
+      domTest('selects the first match if multiple available', function (browser, dom, $) {
+        var selectedItem
 
         var select = dom.insert('<select><option value="1">Item</option><option value="2">Item</option></select>').on('change', function (e) {
-          selectedItem = select.val();
-        });
+          selectedItem = select.val()
+        })
 
-        return browser.find('select').select({text: 'Item'}).then(function(){
-          demand(selectedItem).to.equal('1');
-        });
-      });
+        return browser.find('select').select({text: 'Item'}).then(function () {
+          demand(selectedItem).to.equal('1')
+        })
+      })
 
-      domTest('selects an option that eventually appears', function(browser, dom, $){
-        var promise = browser.find('.element').select({text: 'Second'});
-        var selectedItem = undefined;
+      domTest('selects an option that eventually appears', function (browser, dom, $) {
+        var promise = browser.find('.element').select({text: 'Second'})
+        var selectedItem
 
         var select = dom.insert('<select class="element"></select>').on('change', function (e) {
-          selectedItem = $(this).find('option[selected]').text();
-        });
+          selectedItem = $(this).find('option[selected]').text()
+        })
 
         setTimeout(function () {
-          select.append('<option>First</option><option>Second</option>');
-        }, 20);
+          select.append('<option>First</option><option>Second</option>')
+        }, 20)
 
         return promise.then(function () {
-          demand(selectedItem).to.equal('Second');
-        });
-      });
+          demand(selectedItem).to.equal('Second')
+        })
+      })
 
-      domTest('errors when the specified option does not exist', function(browser, dom){
-        var promise = browser.find('.element').select({text: 'Does not exist'});
+      domTest('errors when the specified option does not exist', function (browser, dom) {
+        var promise = browser.find('.element').select({text: 'Does not exist'})
 
-        dom.eventuallyInsert('<select class="element"><option>First</option><option>Second</option></select>');
+        dom.eventuallyInsert('<select class="element"><option>First</option><option>Second</option></select>')
 
         return demand(promise).reject.with.error()
-      });
-
-      domTest('errors when the input is not a select', function(browser, dom){
-        var promise = browser.find('.element').select({text: 'Whatevs'});
-        dom.eventuallyInsert('<div class="element"></div>');
-        return demand(promise).reject.with.error(/to have css select/);
-      });
+      })
 
-      domTest('selects an option using text that is falsy', function(browser, dom, $){
-        var promise = browser.find('.element').select({text: 0});
-        var selectedItem = undefined;
+      domTest('errors when the input is not a select', function (browser, dom) {
+        var promise = browser.find('.element').select({text: 'Whatevs'})
+        dom.eventuallyInsert('<div class="element"></div>')
+        return demand(promise).reject.with.error(/to have css select/)
+      })
 
-        var select = dom.insert('<select class="element"><option>0</option><option>1</option></select>').on('change', function (e) {
-          selectedItem = $(this).find('option[selected]').text();
-        });
+      domTest('selects an option using text that is falsy', function (browser, dom, $) {
+        var promise = browser.find('.element').select({text: 0})
+        var selectedItem
 
+        dom.insert('<select class="element"><option>0</option><option>1</option></select>').on('change', function (e) {
+          selectedItem = $(this).find('option[selected]').text()
+        })
 
         return promise.then(function () {
-          demand(selectedItem).to.equal('0');
-        });
-      });
-    });
-
-    describe('exactText', function(){
-      domTest('should select an option using exact text that would otherwise match multiple options', function(browser, dom, $){
-        var promise = browser.find('.element').select({exactText: 'Mr'});
-        var selectedItem = undefined;
+          demand(selectedItem).to.equal('0')
+        })
+      })
+    })
 
-        var select = dom.insert('<select class="element"><option>Mr</option><option>Mrs</option></select>').on('change', function (e) {
-          selectedItem = $(this).find('option[selected]').text();
-        });
+    describe('exactText', function () {
+      domTest('should select an option using exact text that would otherwise match multiple options', function (browser, dom, $) {
+        var promise = browser.find('.element').select({exactText: 'Mr'})
+        var selectedItem
 
+        dom.insert('<select class="element"><option>Mr</option><option>Mrs</option></select>').on('change', function (e) {
+          selectedItem = $(this).find('option[selected]').text()
+        })
 
         return promise.then(function () {
-          demand(selectedItem).to.equal('Mr');
-        });
-      });
-
-      domTest('should select an option using exact text that is falsy', function(browser, dom, $){
-        var promise = browser.find('.element').select({exactText: 0});
-        var selectedItem = undefined;
+          demand(selectedItem).to.equal('Mr')
+        })
+      })
 
-        var select = dom.insert('<select class="element"><option>0</option><option>1</option></select>').on('change', function (e) {
-          selectedItem = $(this).find('option[selected]').text();
-        });
+      domTest('should select an option using exact text that is falsy', function (browser, dom, $) {
+        var promise = browser.find('.element').select({exactText: 0})
+        var selectedItem
 
+        dom.insert('<select class="element"><option>0</option><option>1</option></select>').on('change', function (e) {
+          selectedItem = $(this).find('option[selected]').text()
+        })
 
         return promise.then(function () {
-          demand(selectedItem).to.equal('0');
-        });
-      });
-    });
-  });
+          demand(selectedItem).to.equal('0')
+        })
+      })
+    })
+  })
 
   describe('submit', function () {
-    domTest('stack trace', function(browser, dom){
+    domTest('stack trace', function (browser, dom) {
       return browser.find('div')
         .submit()
-        .assertStackTrace(__filename);
+        .assertStackTrace(__filename)
     }, {
       mochaOnly: true
-    });
+    })
 
     domTest('should submit the form', function (browser, dom) {
-      var submitted = false;
-      var promise = browser.find('input').submit();
+      var submitted = false
+      var promise = browser.find('input').submit()
 
       dom.insert('<form action="#"><input type=text></form>').on('submit', function (ev) {
-        submitted = true;
-      });
+        submitted = true
+      })
 
       return promise.then(function () {
-        demand(submitted).to.equal(true);
-      });
-    });
+        demand(submitted).to.equal(true)
+      })
+    })
 
     domTest('should submit the form when submit button is clicked', function (browser, dom) {
-      var submitted = false;
-      var promise = browser.find('input').click();
+      var submitted = false
+      var promise = browser.find('input').click()
 
       dom.insert('<form action="#"><input type="submit">submit</input></form>').on('submit', function (ev) {
-        ev.preventDefault();
-        submitted = true;
-      });
+        ev.preventDefault()
+        submitted = true
+      })
 
       return promise.then(function () {
-        demand(submitted).to.be.true;
-      });
-    }, {vdom: false});
-  });
+        demand(submitted).to.equal(true)
+      })
+    }, {vdom: false})
+  })
 
-  describe('typeIn', function(){
-    domTest('stack trace', function(browser, dom){
+  describe('typeIn', function () {
+    domTest('stack trace', function (browser, dom) {
       return browser.find('input')
         .typeIn('hello')
-        .assertStackTrace(__filename);
+        .assertStackTrace(__filename)
     }, {
       mochaOnly: true
-    });
+    })
 
-    [
+    var allowedToTypeInto = [
       '<input class="element"></input>',
       '<input class="element" type="text"></input>',
       '<input class="element" type="email"></input>',
@@ -321,201 +317,203 @@ describe('actions', function(){
       '<input class="element" type="url"></input>',
       '<input class="element" type="number"></input>',
       '<textarea class="element"></textara>'
-    ].forEach(function(html) {
+    ]
+
+    allowedToTypeInto.forEach(function (html) {
       domTest('eventually enters text into: ' + html, function (browser, dom) {
-        var promise = browser.find('.element').typeIn('1234');
-        dom.eventuallyInsert(html);
+        var promise = browser.find('.element').typeIn('1234')
+        dom.eventuallyInsert(html)
         return promise.then(function () {
-          demand(dom.el.find('.element').val()).to.equal('1234');
-        });
-      });
-    });
-    return
+          demand(dom.el.find('.element').val()).to.equal('1234')
+        })
+      })
+    })
 
-    [
+    var notAllowedToTypeInto = [
       '<div class="element"></div>',
       '<input type="checkbox" class="element"></input>',
       '<select class="element"></select>'
-    ].forEach(function(html) {
+    ]
 
+    notAllowedToTypeInto.forEach(function (html) {
       domTest('rejects attempt to type into element: ' + html, function (browser, dom, $) {
-        var promise = browser.find('.element').typeIn('whatevs');
-        dom.eventuallyInsert(html);
-        return demand(promise).reject.with.error('Cannot type into ' + $(html).prop('tagName'));
-      });
-    });
+        var promise = browser.find('.element').typeIn('whatevs')
+        dom.eventuallyInsert(html)
+        return demand(promise).reject.with.error('Cannot type into ' + $(html).prop('tagName'))
+      })
+    })
 
     domTest('blanks out existing text when typing empty text', function (browser, dom) {
-      var firedEvents = [];
+      var firedEvents = []
       dom.insert('<input type="text" class="element" value="good bye">')
-      .on('input', function(ev){ firedEvents.push('input: ' + JSON.stringify(ev.target.value)); });
+      .on('input', function (ev) { firedEvents.push('input') })
 
       return browser.find('.element').typeIn('').then(function () {
-        return retry(function(){
-          demand(dom.el.find('input.element').val()).to.equal('');
-          demand(firedEvents).to.eql(['input']);
-        });
-      });
-    });
-  });
-  describe('typeInHtml', function(){
-    domTest('stack trace', function(browser, dom){
+        return retry(function () {
+          demand(dom.el.find('input.element').val()).to.equal('')
+          demand(firedEvents).to.eql(['input'])
+        })
+      })
+    })
+  })
+  describe('typeInHtml', function () {
+    domTest('stack trace', function (browser, dom) {
       return browser.find('input')
         .typeInHtml('<p>hello</p>')
-        .assertStackTrace(__filename);
+        .assertStackTrace(__filename)
     }, {
       mochaOnly: true
-    });
-  });
+    })
+  })
 
-  describe('checkboxes', function(){
+  describe('checkboxes', function () {
     domTest('can check a checkbox by clicking on it', function (browser, dom, $) {
-      var checkbox = dom.insert('<input class="checkbox" type=checkbox>');
-      var checked;
+      var checkbox = dom.insert('<input class="checkbox" type=checkbox>')
+      var checked
 
       checkbox.on('click', function (ev) {
-        checked = $(this).prop('checked');
-      });
+        checked = $(this).prop('checked')
+      })
 
       demand(checkbox.prop('checked')).to.equal(false)
 
-      var clicked = browser.find('.checkbox').click();
+      var clicked = browser.find('.checkbox').click()
       return clicked.then(function () {
         demand(checkbox.prop('checked')).to.equal(true)
         demand(checked).to.equal(true)
       }).then(function () {
-        return browser.find('.checkbox').click();
+        return browser.find('.checkbox').click()
       }).then(function () {
         demand(checkbox.prop('checked')).to.equal(false)
         demand(checked).to.equal(false)
-      });
-    });
+      })
+    })
 
     domTest('can check a checkbox by clicking its label', function (browser, dom, $) {
-      var label = dom.insert('<label>Check: <input class="checkbox" type=checkbox></label>');
-      var checkbox = dom.el.find('input');
-      var checked;
+      dom.insert('<label>Check: <input class="checkbox" type=checkbox></label>')
+      var checkbox = dom.el.find('input')
+      var checked
 
       checkbox.on('click', function (ev) {
-        checked = $(this).prop('checked');
-      });
+        checked = $(this).prop('checked')
+      })
 
       demand(checkbox.prop('checked')).to.equal(false)
 
-      var clicked = browser.find('label').click();
+      var clicked = browser.find('label').click()
       return clicked.then(function () {
         demand(checkbox.prop('checked')).to.equal(true)
         demand(checked).to.equal(true)
       }).then(function () {
-        return browser.find('.checkbox').click();
+        return browser.find('.checkbox').click()
       }).then(function () {
         demand(checkbox.prop('checked')).to.equal(false)
         demand(checked).to.equal(false)
-      });
-    });
-  });
+      })
+    })
+  })
 
-  describe('fill', function(){
-    domTest('fills a component with the supplied values', function(browser, dom){
+  describe('fill', function () {
+    domTest('fills a component with the supplied values', function (browser, dom) {
       var component = browser.component({
-        title: function(){
-          return this.find('.title');
+        title: function () {
+          return this.find('.title')
         },
-        name: function(){
-          return this.find('.name');
+        name: function () {
+          return this.find('.name')
         }
-      });
-      dom.eventuallyInsert('<select class="title"><option>Mrs</option><option>Mr</option></select>');
-      dom.eventuallyInsert('<input type="text" class="name"></input>');
+      })
+      dom.eventuallyInsert('<select class="title"><option>Mrs</option><option>Mr</option></select>')
+      dom.eventuallyInsert('<input type="text" class="name"></input>')
 
       return component.fill([
-        { name: 'title', action: 'select', options: {exactText: 'Mr'}},
-        { name: 'name', action: 'typeIn', options: {text: 'Joe'}}
-      ]).then(function(){
-        demand(dom.el.find('.title').val()).to.equal('Mr');
-        demand(dom.el.find('.name').val()).to.equal('Joe');
-      });
-    });
-
-    domTest('can fill using shortcut syntax', function(browser, dom){
+        {name: 'title', action: 'select', options: {exactText: 'Mr'}},
+        {name: 'name', action: 'typeIn', options: {text: 'Joe'}}
+      ]).then(function () {
+        demand(dom.el.find('.title').val()).to.equal('Mr')
+        demand(dom.el.find('.name').val()).to.equal('Joe')
+      })
+    })
+
+    domTest('can fill using shortcut syntax', function (browser, dom) {
       var component = browser.component({
-        title: function(){
-          return this.find('.title');
+        title: function () {
+          return this.find('.title')
         },
-        name: function(){
-          return this.find('.name');
+        name: function () {
+          return this.find('.name')
         },
-        agree: function(){
-          return this.find('.agree');
+        agree: function () {
+          return this.find('.agree')
         }
-      });
-      dom.eventuallyInsert('<select class="title"><option>Mrs</option><option>Mr</option></select>');
-      dom.eventuallyInsert('<input type="text" class="name"></input>');
-      dom.eventuallyInsert('<label class="agree">Check: <input type="checkbox"></label>');
+      })
+      dom.eventuallyInsert('<select class="title"><option>Mrs</option><option>Mr</option></select>')
+      dom.eventuallyInsert('<input type="text" class="name"></input>')
+      dom.eventuallyInsert('<label class="agree">Check: <input type="checkbox"></label>')
 
       return component.fill([
-        { select: 'title', text: 'Mrs'},
-        { typeIn: 'name', options: {text: 'Joe'}},
-        { click: 'agree' }
-      ]).then(function(){
-        demand(dom.el.find('.title').val()).to.equal('Mrs');
-        demand(dom.el.find('.name').val()).to.equal('Joe');
-        demand(dom.el.find('.agree input').prop('checked')).to.equal(true);
-      });
-    });
-
-    domTest('can execute actions on a component', function(browser, dom){
-      var myActionRan = false;
+        {select: 'title', text: 'Mrs'},
+        {typeIn: 'name', options: {text: 'Joe'}},
+        {click: 'agree'}
+      ]).then(function () {
+        demand(dom.el.find('.title').val()).to.equal('Mrs')
+        demand(dom.el.find('.name').val()).to.equal('Joe')
+        demand(dom.el.find('.agree input').prop('checked')).to.equal(true)
+      })
+    })
+
+    domTest('can execute actions on a component', function (browser, dom) {
+      var myActionRan = false
       var component = browser.component({
-        myAction: function(){
-          myActionRan = true;
+        myAction: function () {
+          myActionRan = true
 
-          return new Promise(function(success){
-            success();
-          });
+          return new Promise(function (resolve) {
+            resolve()
+          })
         }
       }).component({
-        title: function(){
-          return this.find('.title');
-        },
-      });
-      dom.eventuallyInsert('<select class="title"><option>Mrs</option></select>');
+        title: function () {
+          return this.find('.title')
+        }
+      })
+      dom.eventuallyInsert('<select class="title"><option>Mrs</option></select>')
 
       return component.fill([
         { myAction: 'title' }
-      ]).then(function(){
+      ]).then(function () {
         demand(myActionRan).to.equal(true)
-      });
-    });
+      })
+    })
 
-    domTest('throws an error if the action cannot be found', function(browser, dom){
-      var component = browser.component({});
+    domTest('throws an error if the action cannot be found', function (browser, dom) {
+      var component = browser.component({})
 
       var promise = component.fill([
-        { actionDoesNotExist: 'name'}
-      ]);
+        {actionDoesNotExist: 'name'}
+      ])
 
-      return demand(promise).reject.to.include('actionDoesNotExist');
-    });
+      return demand(promise).reject.with.error(/actionDoesNotExist/)
+    })
 
-    domTest('throws an error when trying to call an action on a field which does not exist', function(browser, dom){
-      var component = browser.component({});
+    domTest('throws an error when trying to call an action on a field which does not exist', function (browser, dom) {
+      var component = browser.component({})
 
       var promise = component.fill([
-        { typeIn: 'name'}
-      ]);
+        {typeIn: 'name'}
+      ])
 
-      return demand(promise).reject.to.include("Field 'name' does not exist");
-    });
+      return demand(promise).reject.with.error("Field 'name' does not exist")
+    })
 
-    domTest('throws an error if the field does not exist', function(browser, dom){
-      var component = browser.component({});
+    domTest('throws an error if the field does not exist', function (browser, dom) {
+      var component = browser.component({})
 
       var promise = component.fill(
         { name: 'address', action: 'blah' }
-      );
+      )
 
-      return demand(promise).reject.to.include("No field 'address' exists on this component");
-    });
-  });
+      return demand(promise).reject.with.error("No field 'address' exists on this component")
+    })
+  })
 })
diff --git a/test/app/angular.js b/test/app/angular.js
index 6e286e3..db5aa83 100644
--- a/test/app/angular.js
+++ b/test/app/angular.js
@@ -1,4 +1,4 @@
-var angular = require('angular');
+var angular = require('angular')
 
 angular
   .module('FrameworksApp', [])
@@ -10,14 +10,14 @@ angular
         <button ng-click="hello()">press me</button>
         <div class="message">{{message}}</div>
       </div>`
-    };
+    }
   })
-  .controller('FrameworksController', function($scope){
-    $scope.message = 'default';
+  .controller('FrameworksController', function ($scope) {
+    $scope.message = 'default'
     $scope.hello = function () {
-      $scope.message = 'hello browser-monkey';
+      $scope.message = 'hello browser-monkey'
     }
-  });
+  })
 
 module.exports = {
   directiveName: 'best-frameworks',
diff --git a/test/app/hyperdom.jsx b/test/app/hyperdom.jsx
index 67ecd75..56efbe2 100644
--- a/test/app/hyperdom.jsx
+++ b/test/app/hyperdom.jsx
@@ -1,20 +1,19 @@
 /** @jsx hyperdom.jsx */
-var httpism = require('httpism/browser');
-var hyperdom = require('hyperdom');
+var hyperdom = require('hyperdom')
 
 module.exports = class WebApp {
-  constructor() {
-    this.message = 'default';
+  constructor () {
+    this.message = 'default'
   }
 
   hello () {
-    this.message = 'hello browser-monkey';
+    this.message = 'hello browser-monkey'
   }
 
-  render() {
+  render () {
     return <div>
       <button onclick={() => this.hello()}>press me</button>
-      <div class="message">{this.message}</div>
+      <div class='message'>{this.message}</div>
     </div>
   }
 }
diff --git a/test/app/react.jsx b/test/app/react.jsx
index 0555a87..8ccb4f0 100644
--- a/test/app/react.jsx
+++ b/test/app/react.jsx
@@ -1,23 +1,21 @@
 /** @jsx */
 
-const httpism = require('httpism/browser')
 const React = require('react')
-const ReactDOM = require('react-dom')
 
 class WebApp extends React.Component {
-  constructor() {
+  constructor () {
     super()
     this.state = { message: 'default' }
   }
 
   hello () {
-    this.setState({message : 'hello browser-monkey'})
+    this.setState({message: 'hello browser-monkey'})
   }
 
-  render() {
+  render () {
     return <div>
       <button onClick={() => this.hello()}>press me</button>
-      <div className="message">{this.state.message}</div>
+      <div className='message'>{this.state.message}</div>
     </div>
   }
 }
diff --git a/test/app/server.js b/test/app/server.js
index a028279..8b55d9a 100644
--- a/test/app/server.js
+++ b/test/app/server.js
@@ -1,10 +1,10 @@
-var expressApp = (require('express'))();
+var expressApp = (require('express'))()
 expressApp.get('/api/frameworks', (req, res) => {
   res.json([
     'browser-monkey',
     'hyperdom',
-    'vinehill',
-  ]);
-});
+    'vinehill'
+  ])
+})
 
-module.exports = expressApp;
+module.exports = expressApp
diff --git a/test/assertionsSpec.js b/test/assertionsSpec.js
index 60a3079..cb2dab7 100644
--- a/test/assertionsSpec.js
+++ b/test/assertionsSpec.js
@@ -1,95 +1,95 @@
 var assert = require('assert')
 var demand = require('must')
-var domTest = require('./domTest');
-
-describe('assertions', function(){
+var domTest = require('./domTest')
 
+describe('assertions', function () {
   describe('shouldNotExist', function () {
     domTest("should ensure that element eventually doesn't exists", function (browser, dom) {
-      dom.insert('<div class="removing"></div>');
-      dom.insert('<div class="staying"></div>');
+      dom.insert('<div class="removing"></div>')
+      dom.insert('<div class="staying"></div>')
 
-      var good = browser.find('.removing').shouldNotExist();
-      var bad = browser.find('.staying').shouldNotExist();
+      var good = browser.find('.removing').shouldNotExist()
+      var bad = browser.find('.staying').shouldNotExist()
 
       setTimeout(function () {
-        dom.el.find('.removing').remove();
-      }, 50);
+        dom.el.find('.removing').remove()
+      }, 50)
 
       return Promise.all([
         good,
         demand(bad).reject.with.error()
-      ]);
-    });
+      ])
+    })
 
     domTest('allows trytryagain parameters to be used', function (browser, dom) {
-      dom.insert('<div class="removing"></div>');
+      dom.insert('<div class="removing"></div>')
 
-      var promise = browser.find('.removing').shouldNotExist({timeout: 500, interval: 100});
+      var promise = browser.find('.removing').shouldNotExist({timeout: 500, interval: 100})
 
       setTimeout(function () {
-        dom.el.find('.removing').remove();
-      }, 50);
+        dom.el.find('.removing').remove()
+      }, 50)
 
-      return promise;
-    });
+      return promise
+    })
 
-    domTest('stack trace', function(browser, dom){
-      dom.insert('<div></div>');
+    domTest('stack trace', function (browser, dom) {
+      dom.insert('<div></div>')
 
       return browser.find('div')
         .shouldNotExist()
-        .assertStackTrace(__filename);
+        .assertStackTrace(__filename)
     }, {
       mochaOnly: true
-    });
-  });
+    })
+  })
 
-  describe('shouldExist', function(){
-    domTest('stack trace', function(browser, dom){
+  describe('shouldExist', function () {
+    domTest('stack trace', function (browser, dom) {
       return browser.find('div')
         .shouldExist()
-        .assertStackTrace(__filename);
+        .assertStackTrace(__filename)
     }, {
       mochaOnly: true
-    });
-  });
+    })
+  })
 
-  describe('shouldFind', function(){
-    domTest('stack trace', function(browser, dom){
+  describe('shouldFind', function () {
+    domTest('stack trace', function (browser, dom) {
       return browser
         .shouldFind('div')
-        .assertStackTrace(__filename);
+        .assertStackTrace(__filename)
     }, {
       mochaOnly: true
-    });
-  });
+    })
+  })
 
   describe('is', function () {
     domTest('should eventually find an element if it has a class', function (browser, dom) {
-      var good = browser.find('.element').is('.good').shouldExist();
-      var bad = browser.find('.element').is('.bad').shouldExist();
+      var good = browser.find('.element').is('.good').shouldExist()
+      var bad = browser.find('.element').is('.bad').shouldExist()
 
       setTimeout(function () {
-        var element = dom.insert('<div class="element"></div>');
+        var element = dom.insert('<div class="element"></div>')
 
         setTimeout(function () {
-          element.addClass('good');
-        }, 10);
-      }, 10);
+          element.addClass('good')
+        }, 10)
+      }, 10)
 
-      return Promise.all([good, demand(bad).reject.with.error()]);
-    });
-  });
+      return Promise.all([good, demand(bad).reject.with.error()])
+    })
+  })
 
   domTest('eventually finds an element containing text', function (browser, dom) {
-    var promise = browser.find('.element', {text: 'some t'}).shouldExist();
-    dom.eventuallyInsert('<div class="element"><div>some text</div></div>');
-    return promise;
-  });
+    var promise = browser.find('.element', {text: 'some t'}).shouldExist()
+    dom.eventuallyInsert('<div class="element"><div>some text</div></div>')
+    return promise
+  })
 
   domTest('eventually finds an element containing text as it appears on the page', function (browser, dom) {
-    var promise = browser.find('.element').shouldHave({text: 'This is some text that is all on one line.\nAnd some more on another line'});
+    var promise = browser.find('.element').shouldHave({text: 'This is some text that is all on one line.\nAnd some more on another line'})
+/* eslint-disable no-multi-str */
     dom.eventuallyInsert('<div class="element"><div>\
     This\
     is\
@@ -98,25 +98,25 @@ describe('assertions', function(){
     that is all on one line.\
     <br/>\
     And some more on another line.\
-  </div></div>');
-    return promise;
-  });
+  </div></div>')
+/* eslint-enable no-multi-str */
+    return promise
+  })
 
   domTest('eventually finds an element containing exactText', function (browser, dom) {
-    var good = browser.find('.a', {exactText: '8'}).shouldExist();
-    var bad = browser.find('.b', {exactText: '8'}).shouldExist();
+    var good = browser.find('.a', {exactText: '8'}).shouldExist()
+    var bad = browser.find('.b', {exactText: '8'}).shouldExist()
 
-    dom.eventuallyInsert('<div><div class="a">8</div><div class="b">28</div></div>');
+    dom.eventuallyInsert('<div><div class="a">8</div><div class="b">28</div></div>')
 
     return Promise.all([
       good,
       demand(bad).reject.with.error()
-    ]);
-  });
+    ])
+  })
 
   domTest("treats assertion of text: '' as exact text", function (browser, dom) {
-
-    dom.eventuallyInsert('<div><div class="a">something</div><div class="b"></div></div>');
+    dom.eventuallyInsert('<div><div class="a">something</div><div class="b"></div></div>')
 
     return browser.find('.a', {text: 'something'}).shouldExist().then(function () {
       return Promise.all([
@@ -124,128 +124,127 @@ describe('assertions', function(){
         browser.find('.b', {text: ''}).shouldExist()
       ])
     })
-  });
+  })
 
   describe('shouldHave', function () {
-    domTest('stack trace', function(browser, dom){
-      dom.insert('<div>hello</div>');
+    domTest('stack trace', function (browser, dom) {
+      dom.insert('<div>hello</div>')
       return browser.find('div')
         .shouldHave({text: 'something'})
-        .assertStackTrace(__filename);
+        .assertStackTrace(__filename)
     }, {
       mochaOnly: true
-    });
+    })
 
     domTest('eventually finds an element and asserts that it has text', function (browser, dom) {
-      var good = browser.find('.element').shouldHave({text: 'some t'});
-      var bad = browser.find('.element').shouldHave({text: 'sme t'});
+      var good = browser.find('.element').shouldHave({text: 'some t'})
+      var bad = browser.find('.element').shouldHave({text: 'sme t'})
 
-      dom.eventuallyInsert('<div class="element"><div>some text</div></div>');
+      dom.eventuallyInsert('<div class="element"><div>some text</div></div>')
 
       return Promise.all([
         good,
         demand(bad).reject.with.error()
-      ]);
-    });
+      ])
+    })
 
     domTest('allows trytryagain parameters to be used', function (browser, dom) {
-      var good = browser.find('.element').shouldHave({text: 'some t', timeout: 400, interval: 100});
-      var bad = browser.find('.element').shouldHave({text: 'sme t'});
+      var good = browser.find('.element').shouldHave({text: 'some t', timeout: 400, interval: 100})
+      var bad = browser.find('.element').shouldHave({text: 'sme t'})
 
-      dom.eventuallyInsert('<div class="element"><div>some text</div></div>');
+      dom.eventuallyInsert('<div class="element"><div>some text</div></div>')
 
       return Promise.all([
         good,
         demand(bad).reject.with.error()
-      ]);
-    });
+      ])
+    })
 
     domTest('finds duplicate text when asserting array of text', function (browser, dom) {
-      dom.insert('<div class="element1">a</div>');
-      dom.insert('<div class="element1">a</div>');
-
-      return browser.find('.element1').shouldHave({text: ['a', 'a']});
-    });
+      dom.insert('<div class="element1">a</div>')
+      dom.insert('<div class="element1">a</div>')
 
+      return browser.find('.element1').shouldHave({text: ['a', 'a']})
+    })
 
     domTest('eventually finds an element and asserts that it has value', function (browser, dom) {
-      var good1 = browser.find('.element1 input').shouldHave({value: 'some t'});
-      var good2 = browser.find('.element2 input').shouldHave({value: 0});
-      var bad = browser.find('.element1 input').shouldHave({value: 'sme t'});
+      var good1 = browser.find('.element1 input').shouldHave({value: 'some t'})
+      var good2 = browser.find('.element2 input').shouldHave({value: 0})
+      var bad = browser.find('.element1 input').shouldHave({value: 'sme t'})
 
-      dom.eventuallyInsert('<div class="element1"><input type=text value="some text" /></div>');
-      dom.eventuallyInsert('<div class="element2"><input type=text value="0" /></div>');
+      dom.eventuallyInsert('<div class="element1"><input type=text value="some text" /></div>')
+      dom.eventuallyInsert('<div class="element2"><input type=text value="0" /></div>')
 
       return Promise.all([
         good1,
         good2,
         demand(bad).reject.with.error()
-      ]);
-    });
+      ])
+    })
 
-    domTest('error has a tip with suggestions for how to fix it', function(browser, dom){
-      dom.insert('<span>abc</span>');
-      dom.insert('<span>bac</span>');
-      dom.insert('<span>cba</span>');
+    domTest('error has a tip with suggestions for how to fix it', function (browser, dom) {
+      dom.insert('<span>abc</span>')
+      dom.insert('<span>bac</span>')
+      dom.insert('<span>cba</span>')
 
       return browser.find('span').shouldHave({
         text: [
           'cba',
           'abc',
-          'bac',
+          'bac'
         ]
-      }).catch(function(error) {
-        demand(error.message).to.include('\nThe text was found but in a different order than specified - maybe you need some sorting?');
-      });
-    });
+      }).catch(function (error) {
+        demand(error.message).to.include('\nThe text was found but in a different order than specified - maybe you need some sorting?')
+      })
+    })
 
     domTest('finds an element with exact value', function (browser, dom) {
-      var bad = browser.find('.element1 input').shouldHave({exactValue: 'some t'});
-      var good = browser.find('.element1 input').shouldHave({exactValue: 'some text'});
+      var bad = browser.find('.element1 input').shouldHave({exactValue: 'some t'})
+      var good = browser.find('.element1 input').shouldHave({exactValue: 'some text'})
 
-      dom.eventuallyInsert('<div class="element1"><input type=text value="some text" /></div>');
+      dom.eventuallyInsert('<div class="element1"><input type=text value="some text" /></div>')
 
       return Promise.all([
         good,
         demand(bad).reject.with.error()
-      ]);
-    });
+      ])
+    })
 
     domTest("treats assertion of value: '' as exact value", function (browser, dom) {
-      var bad = browser.find('.element1 input').shouldHave({value: ''});
-      var good = browser.find('.element2 input').shouldHave({value: ''});
+      var bad = browser.find('.element1 input').shouldHave({value: ''})
+      var good = browser.find('.element2 input').shouldHave({value: ''})
 
       dom.eventuallyInsert('<div>\n' +
                              '<div class="element1"><input type=text value="some text" /></div>\n' +
                              '<div class="element2"><input type=text value="" /></div>\n' +
-                           '</div>');
+                           '</div>')
 
       return Promise.all([
         good,
         demand(bad).reject.with.error()
-      ]);
-    });
+      ])
+    })
 
-    domTest("treats selects with no value as empty string", function(browser, dom){
-      dom.insert('<select></select>');
+    domTest('treats selects with no value as empty string', function (browser, dom) {
+      dom.insert('<select></select>')
 
-      var select = browser.find('select');
+      var select = browser.find('select')
 
       return Promise.all([
         select.shouldHave({value: ''}),
-        select.shouldHave({exactValue: ''}),
-      ]);
-    });
+        select.shouldHave({exactValue: ''})
+      ])
+    })
 
-    domTest('recurses through a tree of assertions', function(browser, dom){
-      dom.insert('<div class="airport"><span class="date">Aug 2055</span><span class="text">LHR</span><span class="blank"></span></div>');
+    domTest('recurses through a tree of assertions', function (browser, dom) {
+      dom.insert('<div class="airport"><span class="date">Aug 2055</span><span class="text">LHR</span><span class="blank"></span></div>')
       return browser.component({
-        airport: function(){
+        airport: function () {
           return this.find('.airport').component({
-            date: function(){ return this.find('.date'); },
-            text: function(){ return this.find('.text'); },
-            blank: function(){ return this.find('.blank'); }
-          });
+            date: function () { return this.find('.date') },
+            text: function () { return this.find('.text') },
+            blank: function () { return this.find('.blank') }
+          })
         }
       }).shouldHave({
         airport: {
@@ -253,252 +252,251 @@ describe('assertions', function(){
           text: { text: 'LHR' },
           blank: { text: undefined }
         }
-      });
-    });
+      })
+    })
 
-    domTest('verifies attributes are present', function(browser, dom){
-      dom.insert('<a id="abc" href="/home">hello</a>');
+    domTest('verifies attributes are present', function (browser, dom) {
+      dom.insert('<a id="abc" href="/home">hello</a>')
       var good = browser.find('a').shouldHave({
         attributes: {
           id: 'abc',
           href: '/home'
         }
-      });
+      })
       var bad = browser.find('a').shouldHave({
         attributes: {
           'class': 'other'
         }
-      });
+      })
       return Promise.all([
         good,
         demand(bad).reject.with.error()
-      ]);
-    });
+      ])
+    })
 
-    domTest('verifies array of attributes are present', function(browser, dom){
-      dom.insert('<div><img src="/a"/><img src="/b"/><img src="/c"/></div>');
+    domTest('verifies array of attributes are present', function (browser, dom) {
+      dom.insert('<div><img src="/a"/><img src="/b"/><img src="/c"/></div>')
       var good = browser.find('img').shouldHave({
         attributes: [
           {src: '/a'},
           {src: '/b'},
-          {src: '/c'},
+          {src: '/c'}
         ]
-      });
+      })
       var bad = browser.find('img').shouldHave({
         attributes: [
           {src: '/c'},
           {src: '/a'},
-          {src: '/b'},
+          {src: '/b'}
         ]
-      });
+      })
       return Promise.all([
         good,
         demand(bad).reject.with.error()
-      ]);
-    });
+      ])
+    })
 
-    describe('exactText', function(){
-      domTest('eventually finds elements that have the exact array of text', function(browser, dom){
-        var promise = browser.find('.element option').shouldHave({exactText: ['', 'Mr', 'Mrs']});
+    describe('exactText', function () {
+      domTest('eventually finds elements that have the exact array of text', function (browser, dom) {
+        var promise = browser.find('.element option').shouldHave({exactText: ['', 'Mr', 'Mrs']})
 
-        dom.eventuallyInsert('<select class="element"><option></option><option>Mr</option><option>Mrs</option></select>');
+        dom.eventuallyInsert('<select class="element"><option></option><option>Mr</option><option>Mrs</option></select>')
 
-        return promise;
-      });
+        return promise
+      })
 
-      domTest('fails to find exact text', function(browser, dom){
-        var promise = browser.find('option').shouldHave({exactText: ['', 'Mr', 'Mrs']});
+      domTest('fails to find exact text', function (browser, dom) {
+        var promise = browser.find('option').shouldHave({exactText: ['', 'Mr', 'Mrs']})
 
-        dom.eventuallyInsert('<select><option>Optional</option><option>Mr</option><option>Mrs</option></select>');
+        dom.eventuallyInsert('<select><option>Optional</option><option>Mr</option><option>Mrs</option></select>')
 
         return demand(promise).reject.with.error()
-      });
-    });
+      })
+    })
 
     describe('checkboxes', function () {
       domTest('eventually finds a checked checkbox', function (browser, dom) {
-        var good = browser.find('.checkbox').shouldHave({checked: true});
+        var good = browser.find('.checkbox').shouldHave({checked: true})
 
-        var checkbox = dom.insert('<input class="checkbox" type=checkbox />');
+        var checkbox = dom.insert('<input class="checkbox" type=checkbox />')
         setTimeout(function () {
-          checkbox.prop('checked', true);
-        }, 20);
+          checkbox.prop('checked', true)
+        }, 20)
 
         return Promise.all([
           good
-        ]);
-      });
+        ])
+      })
 
       domTest('fails if only one of many checkboxes is checked', function (browser, dom) {
-        var good = browser.find('.checkbox').shouldHave({checked: true});
+        var good = browser.find('.checkbox').shouldHave({checked: true})
 
-        var checkbox = dom.insert('<input class="checkbox" type=checkbox />');
-        dom.insert('<input class="checkbox" type=checkbox />');
+        var checkbox = dom.insert('<input class="checkbox" type=checkbox />')
+        dom.insert('<input class="checkbox" type=checkbox />')
         setTimeout(function () {
-          checkbox.prop('checked', true);
-        }, 20);
+          checkbox.prop('checked', true)
+        }, 20)
 
         return Promise.all([
           demand(good).reject.with.error()
-        ]);
-      });
+        ])
+      })
 
       domTest('ensures that each checkbox in the scope is either checked or unchecked', function (browser, dom) {
-        var good = browser.find('.checkbox').shouldHave({checked: [true, false]});
-        var bad = browser.find('.checkbox').shouldHave({checked: [false, true]});
+        var good = browser.find('.checkbox').shouldHave({checked: [true, false]})
+        var bad = browser.find('.checkbox').shouldHave({checked: [false, true]})
 
-        var checkbox = dom.insert('<input class="checkbox" type=checkbox />');
-        dom.insert('<input class="checkbox" type=checkbox />');
+        var checkbox = dom.insert('<input class="checkbox" type=checkbox />')
+        dom.insert('<input class="checkbox" type=checkbox />')
         setTimeout(function () {
-          checkbox.prop('checked', true);
-        }, 20);
+          checkbox.prop('checked', true)
+        }, 20)
 
         return Promise.all([
           good,
           demand(bad).reject.with.error()
-        ]);
-      });
+        ])
+      })
 
       domTest('fails to find a checked checkbox', function (browser, dom) {
-        var good = browser.find('.checkbox').shouldHave({checked: false});
-        var bad = browser.find('.checkbox').shouldHave({checked: true});
+        var good = browser.find('.checkbox').shouldHave({checked: false})
+        var bad = browser.find('.checkbox').shouldHave({checked: true})
 
-        var checkbox = dom.insert('<input class="checkbox" type=checkbox />');
+        dom.insert('<input class="checkbox" type=checkbox />')
 
         return Promise.all([
           good,
           demand(bad).reject.with.error()
-        ]);
-      });
-    });
+        ])
+      })
+    })
 
     domTest('eventually finds elements and asserts that they each have text', function (browser, dom) {
-      var good = browser.find('.element div').shouldHave({text: ['one', 2]});
-      var bad1 = browser.find('.element div').shouldHave({text: ['one']});
-      var bad2 = browser.find('.element div').shouldHave({text: ['one', 'three']});
+      var good = browser.find('.element div').shouldHave({text: ['one', 2]})
+      var bad1 = browser.find('.element div').shouldHave({text: ['one']})
+      var bad2 = browser.find('.element div').shouldHave({text: ['one', 'three']})
 
-      dom.eventuallyInsert('<div class="element"><div>\nfirst one</div><div>number 2\n</div></div>');
+      dom.eventuallyInsert('<div class="element"><div>\nfirst one</div><div>number 2\n</div></div>')
 
       return Promise.all([
         good,
         demand(bad1).reject.with.error(),
         demand(bad2).reject.with.error()
-      ]);
-    });
+      ])
+    })
 
     domTest('eventually finds elements and asserts that they each have value', function (browser, dom) {
-      var good = browser.find('.element input').shouldHave({value: ['one', 2, 0]});
-      var bad1 = browser.find('.element input').shouldHave({value: ['one']});
-      var bad2 = browser.find('.element input').shouldHave({value: ['one', 'three']});
+      var good = browser.find('.element input').shouldHave({value: ['one', 2, 0]})
+      var bad1 = browser.find('.element input').shouldHave({value: ['one']})
+      var bad2 = browser.find('.element input').shouldHave({value: ['one', 'three']})
 
-      dom.eventuallyInsert('<div class="element"><input type=text value="first one"><input type=text value="number 2"><input type="text" value="0"></div>');
+      dom.eventuallyInsert('<div class="element"><input type=text value="first one"><input type=text value="number 2"><input type="text" value="0"></div>')
 
       return Promise.all([
         good,
         demand(bad1).reject.with.error(),
         demand(bad2).reject.with.error()
-      ]);
-    });
+      ])
+    })
 
     domTest('eventually finds an element and asserts that it has css', function (browser, dom) {
-      var good = browser.find('.element').shouldHave({css: '.the-class'});
-      var bad1 = browser.find('.element').shouldHave({css: '.not-the-class'});
-      var bad2 = browser.find('.element').shouldHave({css: '.not-found'});
+      var good = browser.find('.element').shouldHave({css: '.the-class'})
+      var bad1 = browser.find('.element').shouldHave({css: '.not-the-class'})
+      var bad2 = browser.find('.element').shouldHave({css: '.not-found'})
 
-      dom.eventuallyInsert('<div class="element the-class"><div class="not-the-class">some text</div></div>');
+      dom.eventuallyInsert('<div class="element the-class"><div class="not-the-class">some text</div></div>')
 
       return Promise.all([
         good,
         demand(bad1).reject.with.error(),
         demand(bad2).reject.with.error()
-      ]);
-    });
+      ])
+    })
 
     domTest('eventually finds an element and asserts that it has n elements', function (browser, dom) {
-      var good = browser.find('.element').shouldHave({length: 2});
-      var bad1 = browser.find('.element').shouldHave({length: 1});
+      var good = browser.find('.element').shouldHave({length: 2})
+      var bad1 = browser.find('.element').shouldHave({length: 1})
 
-      dom.eventuallyInsert('<div class="element"></div>');
-      dom.eventuallyInsert('<div class="element"></div>');
+      dom.eventuallyInsert('<div class="element"></div>')
+      dom.eventuallyInsert('<div class="element"></div>')
 
       return Promise.all([
         good,
         demand(bad1).reject.with.error()
-      ]);
-    });
+      ])
+    })
 
     domTest('eventually finds an element and asserts that it passes an assertion', function (browser, dom, $) {
       var good1 = browser.find('.element').shouldHaveElement(function (element) {
-        assert.equal(element.text(), 'a');
-      });
+        assert.equal(element.text(), 'a')
+      })
 
       var bad1 = browser.find('.multi').shouldHaveElement(function (element) {
-        assert.equal(element.text(), 'b');
-      });
+        assert.equal(element.text(), 'b')
+      })
 
       var bad2 = browser.find('.element').shouldHaveElement(function (element) {
-        debugger
-        assert.equal(element.text(), 'b');
-      });
+        assert.equal(element.text(), 'b')
+      })
 
-      var element = dom.insert('<div class="element"></div>');
-      dom.eventuallyInsert('<div class="multi"></div>');
-      dom.eventuallyInsert('<div class="multi">b</div>');
+      var element = dom.insert('<div class="element"></div>')
+      dom.eventuallyInsert('<div class="multi"></div>')
+      dom.eventuallyInsert('<div class="multi">b</div>')
 
       setTimeout(function () {
-        element.text('a');
-      }, 30);
+        element.text('a')
+      }, 30)
 
       return Promise.all([
         good1,
         demand(bad1).reject.with.error(/expected to find exactly one element/),
         demand(bad2).reject.with.error("'a' == 'b'")
-      ]);
-    });
+      ])
+    })
 
     domTest('eventually finds elements and asserts that they pass an assertion', function (browser, dom, $) {
       var good1 = browser.find('.element').shouldHaveElements(function (elements) {
         var xs = elements.map(function (element) {
-          return $(element).attr('data-x');
-        });
+          return $(element).attr('data-x')
+        })
 
-        assert.deepEqual(xs, ['one', 'two', 'three']);
-      });
+        assert.deepEqual(xs, ['one', 'two', 'three'])
+      })
 
       var bad1 = browser.find('.element').shouldHaveElements(function (elements) {
         var xs = elements.map(function (element) {
-          return $(element).attr('data-x');
-        });
+          return $(element).attr('data-x')
+        })
 
-        assert.deepEqual(xs, ['one', 'two']);
-      });
+        assert.deepEqual(xs, ['one', 'two'])
+      })
 
-      dom.eventuallyInsert('<div class="element" data-x="one"></div>');
-      dom.eventuallyInsert('<div class="element" data-x="two"></div>');
-      dom.eventuallyInsert('<div class="element" data-x="three"></div>');
+      dom.eventuallyInsert('<div class="element" data-x="one"></div>')
+      dom.eventuallyInsert('<div class="element" data-x="two"></div>')
+      dom.eventuallyInsert('<div class="element" data-x="three"></div>')
 
       return Promise.all([
         good1,
         demand(bad1).reject.with.error(/\[ 'one', 'two', 'three' \]/)
-      ]);
-    });
-  });
+      ])
+    })
+  })
 
   describe('shouldNotHave', function () {
     domTest('eventually finds an element and asserts that it does not have text', function (browser, dom) {
-      var promise = browser.find('.element').shouldNotHave({text: 'sme t'});
+      var promise = browser.find('.element').shouldNotHave({text: 'sme t'})
 
-      dom.eventuallyInsert('<div class="element"><div>some text</div></div>');
+      dom.eventuallyInsert('<div class="element"><div>some text</div></div>')
 
-      return promise;
-    });
+      return promise
+    })
 
     domTest('allows trytryagain parameters to be used', function (browser, dom) {
-      var promise = browser.find('.element').shouldNotHave({text: 'sme t', timeout: 400, interval: 100});
+      var promise = browser.find('.element').shouldNotHave({text: 'sme t', timeout: 400, interval: 100})
 
-      dom.eventuallyInsert('<div class="element"><div>some text</div></div>');
+      dom.eventuallyInsert('<div class="element"><div>some text</div></div>')
 
-      return promise;
-    });
-  });
-});
+      return promise
+    })
+  })
+})
diff --git a/test/componentSpec.js b/test/componentSpec.js
index cd98a1d..c6c760c 100644
--- a/test/componentSpec.js
+++ b/test/componentSpec.js
@@ -1,111 +1,111 @@
-var domTest = require('./domTest');
+var domTest = require('./domTest')
 
 describe('component', function () {
   domTest('can return new selectors by extending', function (browser, dom) {
     var user = browser.component({
       name: function () {
-        return this.find('.user-name');
+        return this.find('.user-name')
       },
 
       address: function () {
-        return this.find('.user-address');
+        return this.find('.user-address')
       }
-    });
+    })
 
-    var promise = user.name().shouldExist();
+    var promise = user.name().shouldExist()
 
-    dom.eventuallyInsert('<div class="user"><div class="user-name">bob</div><div class="user-address">bob\'s address</div></div>');
+    dom.eventuallyInsert('<div class="user"><div class="user-name">bob</div><div class="user-address">bob\'s address</div></div>')
 
-    return promise;
-  });
+    return promise
+  })
 
   domTest('components are independent', function (browser, dom) {
     var user = browser.component({
       name: function () {
-        return this.find('.user-name');
+        return this.find('.user-name')
       }
-    });
+    })
 
-    var bah = browser.component({
+    browser.component({
       name: function () {
-        return this.find('.bah-name');
+        return this.find('.bah-name')
       }
-    });
+    })
 
-    var promise = user.name().shouldExist();
+    var promise = user.name().shouldExist()
 
-    dom.eventuallyInsert('<div class="user"><div class="user-name">bob</div><div class="user-address">bob\'s address</div></div>');
+    dom.eventuallyInsert('<div class="user"><div class="user-name">bob</div><div class="user-address">bob\'s address</div></div>')
 
-    return promise;
-  });
+    return promise
+  })
 
   domTest('can extend another component', function (browser, dom) {
     var user = browser.component({
       name: function () {
-        return this.find('.user-name');
+        return this.find('.user-name')
       },
 
       address: function () {
-        return this.find('.user-address');
+        return this.find('.user-address')
       }
-    });
+    })
 
     var bossUser = user.component({
       secondAddress: function () {
-        return this.find('.user-second-address');
+        return this.find('.user-second-address')
       }
-    });
+    })
 
-    var name = bossUser.name().shouldExist();
-    var secondAddress = bossUser.secondAddress().shouldExist();
+    var name = bossUser.name().shouldExist()
+    var secondAddress = bossUser.secondAddress().shouldExist()
 
-    dom.eventuallyInsert('<div class="user"><div class="user-name">bob</div><div class="user-address">bob\'s address</div><div class="user-second-address">bob\'s second address</div></div>');
+    dom.eventuallyInsert('<div class="user"><div class="user-name">bob</div><div class="user-address">bob\'s address</div><div class="user-second-address">bob\'s second address</div></div>')
 
-    return Promise.all([name, secondAddress]);
-  });
+    return Promise.all([name, secondAddress])
+  })
 
   domTest('can return new scoped selectors', function (browser, dom) {
     var admin = browser.component({
       user: function () {
-        return user.scope(this.find('.user'));
+        return user.scope(this.find('.user'))
       }
-    });
+    })
 
     var user = browser.component({
       name: function () {
-        return this.find('.user-name');
+        return this.find('.user-name')
       },
 
       address: function () {
-        return this.find('.user-address');
+        return this.find('.user-address')
       }
-    });
+    })
 
-    var promise = admin.user().name().shouldExist();
+    var promise = admin.user().name().shouldExist()
 
-    dom.eventuallyInsert('<div class="user"><div class="user-name">bob</div><div class="user-address">bob\'s address</div></div>');
+    dom.eventuallyInsert('<div class="user"><div class="user-name">bob</div><div class="user-address">bob\'s address</div></div>')
 
-    return promise;
-  });
+    return promise
+  })
 
   domTest('components inherit scope', function (browser, dom) {
-    var adminArea = browser.find('.admin');
+    var adminArea = browser.find('.admin')
 
     var admin = adminArea.component({
       user: function () {
-        return this.find('.user');
+        return this.find('.user')
       }
-    });
+    })
 
-    var promise = admin.user().shouldHave({text: ['Jane']});
+    var promise = admin.user().shouldHave({text: ['Jane']})
 
     dom.eventuallyInsert(
-        '<div class="user">Bob</div>'
-      + '<div class="admin">'
-        + '<div class="user">Jane</div>'
-      + '</div>'
-    );
-
-    return promise;
-  });
-});
+        '<div class="user">Bob</div>' +
+      '<div class="admin">' +
+        '<div class="user">Jane</div>' +
+      '</div>'
+    )
+
+    return promise
+  })
+})
diff --git a/test/createTestDom.js b/test/createTestDom.js
index 2d82d00..4f75f35 100644
--- a/test/createTestDom.js
+++ b/test/createTestDom.js
@@ -1,21 +1,21 @@
-var $ = require('jquery');
+var $ = require('jquery')
 var createTestDiv = require('../createTestDiv')
 
-module.exports = function() {
+module.exports = function () {
   var div = createTestDiv()
 
   return {
     el: $(div),
-    insert: function(html){
-      var append = $(html);
-      this.el.append(append);
-      return append;
+    insert: function (html) {
+      var append = $(html)
+      this.el.append(append)
+      return append
     },
-    eventuallyInsert: function(html, after) {
-      var self = this;
+    eventuallyInsert: function (html, after) {
+      var self = this
       setTimeout(function () {
-        self.insert(html);
-      }, after || 10);
+        self.insert(html)
+      }, after || 10)
     }
-  };
-};
+  }
+}
diff --git a/test/createVDom.js b/test/createVDom.js
index 8ae374b..772b6fb 100644
--- a/test/createVDom.js
+++ b/test/createVDom.js
@@ -1,18 +1,18 @@
 var $ = require('vdom-query')
 
-module.exports = function createVDOM(body){
+module.exports = function createVDOM (body) {
   return {
     el: $(body),
-    insert: function(html){
-      var append = $(html);
-      this.el.append(append);
-      return append;
+    insert: function (html) {
+      var append = $(html)
+      this.el.append(append)
+      return append
     },
-    eventuallyInsert: function(html) {
-      var self = this;
+    eventuallyInsert: function (html) {
+      var self = this
       setTimeout(function () {
-        self.insert(html);
-      }, 10);
+        self.insert(html)
+      }, 10)
     }
   }
 }
diff --git a/test/domTest.js b/test/domTest.js
index 26c3eae..bb5987d 100644
--- a/test/domTest.js
+++ b/test/domTest.js
@@ -1,60 +1,60 @@
-var createHDom = require('./createTestDom');
-var createVDom = require('./createVDom');
-var isNode = require('detect-node');
-var h = require('virtual-dom/h');
+var createHDom = require('./createTestDom')
+var createVDom = require('./createVDom')
+var isNode = require('detect-node')
+var h = require('virtual-dom/h')
 var vquery = require('vdom-query')
-var jquery = require('../jquery');
-var createBrowser = require('../create');
+var jquery = require('../jquery')
+var createBrowser = require('../create')
 
-function domTest(testName, testCb, options){
-  options = options || {};
+function domTest (testName, testCb, options) {
+  options = options || {}
 
-  var runTests = options.only ? describe.only : describe;
-  var runHtml = it;
-  var runVDom = it;
+  var runTests = options.only ? describe.only : describe
+  var runHtml = it
+  var runVDom = it
 
   if (options.hasOwnProperty('vdom') && !options.vdom) {
-    runVDom = xit;
+    runVDom = xit
   }
   if (isNode || (options.hasOwnProperty('html') && !options.html)) {
-    runHtml = xit;
+    runHtml = xit
   }
   if (!isNode && options.hasOwnProperty('mochaOnly') && options.mochaOnly) {
-    runHtml = xit;
-    runVDom = xit;
+    runHtml = xit
+    runVDom = xit
   }
 
-  runTests(testName, function(){
-    runHtml('HTML', function(){
-      var htmlDom = createHDom();
-      var browser = createBrowser(document.body);
+  runTests(testName, function () {
+    runHtml('HTML', function () {
+      var htmlDom = createHDom()
+      var browser = createBrowser(document.body)
       browser.set({
         timeout: global.timeout || 200
-      });
-      jquery.preventFormSubmit = true;
-      return testCb(browser, htmlDom, jquery);
-    });
-
-    runVDom('VDOM', function(){
-      var body = h('body');
-      var browser = createBrowser(body);
+      })
+      jquery.preventFormSubmit = true
+      return testCb(browser, htmlDom, jquery)
+    })
+
+    runVDom('VDOM', function () {
+      var body = h('body')
+      var browser = createBrowser(body)
       browser.set({
         $: vquery,
         visibleOnly: false,
         document: {},
         timeout: 200
-      });
+      })
 
-      var virtualDom = createVDom(body);
-      return testCb(browser, virtualDom, vquery);
-    });
-  });
+      var virtualDom = createVDom(body)
+      return testCb(browser, virtualDom, vquery)
+    })
+  })
 }
 
-domTest.only = function(testName, testCb, options){
-  options = options || {};
-  options.only = true;
-  domTest(testName, testCb, options);
+domTest.only = function (testName, testCb, options) {
+  options = options || {}
+  options.only = true
+  domTest(testName, testCb, options)
 }
 
-module.exports = domTest;
+module.exports = domTest
diff --git a/test/eventsSpec.js b/test/eventsSpec.js
index 61ba1b8..11e738f 100644
--- a/test/eventsSpec.js
+++ b/test/eventsSpec.js
@@ -1,163 +1,162 @@
 var demand = require('must')
-var retry = require('trytryagain');
-var domTest = require('./domTest');
+var retry = require('trytryagain')
+var domTest = require('./domTest')
 
-describe('events', function(){
-  domTest('typeIn element should fire change', function(browser, dom){
-    var firedEvents = [];
+describe('events', function () {
+  domTest('typeIn element should fire change', function (browser, dom) {
+    var firedEvents = []
 
     dom.insert('<input type="text" class="input">')
-      .on('blur', function(){
-        firedEvents.push('blur');
-      }).on('change', function(){
-        firedEvents.push('change');
+      .on('blur', function () {
+        firedEvents.push('blur')
+      }).on('change', function () {
+        firedEvents.push('change')
       })
 
-    return browser.find('.input').typeIn('first').then(function(){
+    return browser.find('.input').typeIn('first').then(function () {
       demand(firedEvents).to.eql([
         'change'
       ])
-    });
-  });
+    })
+  })
 
-  domTest('typeIn element should fire input on each character', function(browser, dom){
-    var firedEvents = [];
+  domTest('typeIn element should fire input on each character', function (browser, dom) {
+    var firedEvents = []
 
     dom.insert('<input type="text" class="input">')
-      .on('input', function(){
-        firedEvents.push('input');
-      });
+      .on('input', function () {
+        firedEvents.push('input')
+      })
 
-    return browser.find('.input').typeIn('123').then(function(){
+    return browser.find('.input').typeIn('123').then(function () {
       demand(firedEvents).to.eql([
         'input',
         'input',
         'input'
       ])
-    });
-  });
+    })
+  })
 
-  domTest('typeIn element should fire change and then blur event on input', function(browser, dom){
-    var firedEvents = [];
+  domTest('typeIn element should fire change and then blur event on input', function (browser, dom) {
+    var firedEvents = []
 
-    dom.insert('<input type="text" class="input" />');
-    dom.insert('<input type="text" class="change" />');
+    dom.insert('<input type="text" class="input" />')
+    dom.insert('<input type="text" class="change" />')
 
-    dom.el.find('.input').on('blur', function(e){
-      firedEvents.push('blur');
-    }).on('change', function(){
-      firedEvents.push('change');
-    });
+    dom.el.find('.input').on('blur', function (e) {
+      firedEvents.push('blur')
+    }).on('change', function () {
+      firedEvents.push('change')
+    })
 
-    return browser.find('.input').typeIn('first').then(function(){
-      return browser.find('.change').typeIn('second');
+    return browser.find('.input').typeIn('first').then(function () {
+      return browser.find('.change').typeIn('second')
     }).then(function () {
-      return retry(function(){
+      return retry(function () {
         demand(firedEvents).to.eql([
           'change',
           'blur'
-        ]);
-      });
-    });
-  });
+        ])
+      })
+    })
+  })
 
-  domTest('click element should fire blur event on input', function(browser, dom){
-    var blurred = false;
+  domTest('click element should fire blur event on input', function (browser, dom) {
+    var blurred = false
+
+    dom.insert('<input type="text" class="input" />')
+    dom.insert('<button>button</button>')
+
+    dom.el.find('.input').on('blur', function (e) {
+      blurred = true
+    })
+
+    return browser.find('.input').typeIn('first').then(function () {
+      return browser.find('button').click()
+    }).then(function () {
+      return retry(function () {
+        demand(blurred).to.eql(true)
+      })
+    })
+  })
 
-    dom.insert('<input type="text" class="input" />');
-    dom.insert('<button>button</button>');
+  domTest('select element should fire blur event on input', function (browser, dom, $) {
+    var blurred = false
 
-    dom.el.find('.input').on('blur', function(e){
-      blurred = true;
+    dom.insert('<select><option>one</option></select>')
+    dom.insert('<input type="text" class="input"></input>')
+    dom.el.find('input').on('blur', function (e) {
+      blurred = true
     })
 
-    return browser.find('.input').typeIn('first').then(function(){
-      return browser.find('button').click();
-    }).then(function(){
-      return retry(function(){
-        demand(blurred).to.eql(true);
-      });
-    });
-  });
-
-  domTest('select element should fire blur event on input', function(browser, dom, $){
-    var blurred = false;
-
-    dom.insert('<select><option>one</option></select>');
-    dom.insert('<input type="text" class="input"></input>');
-    dom.el.find('input').on('blur', function(e){
-      blurred = true;
-    });
-
-
-    return browser.find('.input').typeIn('first').then(function(){
-      return browser.find('select').select({text: 'one'});
-    }).then(function(){
-      return retry(function(){
-        demand(blurred).to.eql(true);
-      });
-    });
-  });
+    return browser.find('.input').typeIn('first').then(function () {
+      return browser.find('select').select({text: 'one'})
+    }).then(function () {
+      return retry(function () {
+        demand(blurred).to.eql(true)
+      })
+    })
+  })
 
   describe('callbacks on interaction', function () {
     domTest('fires events on clicks', function (browser, dom) {
-      var button = dom.insert('<button>a button</button>');
+      var button = dom.insert('<button>a button</button>')
 
-      var event;
+      var event
 
       return browser.on(function (e) {
-        event = e;
+        event = e
       }).find('button').click().then(function () {
         demand(event).to.not.equal(undefined)
-        demand(event.type).to.equal('click');
-        demand(event.element[0]).to.equal(button[0]);
-      });
-    });
+        demand(event.type).to.equal('click')
+        demand(event.element[0]).to.equal(button[0])
+      })
+    })
 
     domTest('fires events on typeIn', function (browser, dom) {
-      var input = dom.insert('<input></input>');
+      var input = dom.insert('<input></input>')
 
-      var event;
+      var event
 
       return browser.on(function (e) {
-        event = e;
+        event = e
       }).find('input').typeIn('some text').then(function () {
         demand(event).to.not.equal(undefined)
-        demand(event.type).to.equal('typing');
-        demand(event.text).to.equal('some text');
-        demand(event.element[0]).to.equal(input[0]);
-      });
-    });
+        demand(event.type).to.equal('typing')
+        demand(event.text).to.equal('some text')
+        demand(event.element[0]).to.equal(input[0])
+      })
+    })
 
     domTest('fires events on typeIn', function (browser, dom) {
-      var editorDiv = dom.insert('<div class="editor"></div>');
+      var editorDiv = dom.insert('<div class="editor"></div>')
 
-      var event;
+      var event
 
       return browser.on(function (e) {
-        event = e;
+        event = e
       }).find('div.editor').typeInHtml('some <b>html</b>').then(function () {
         demand(event).to.not.equal(undefined)
-        demand(event.type).to.equal('typing html');
-        demand(event.html).to.equal('some <b>html</b>');
-        demand(event.element[0]).to.equal(editorDiv[0]);
-      });
-    });
+        demand(event.type).to.equal('typing html')
+        demand(event.html).to.equal('some <b>html</b>')
+        demand(event.element[0]).to.equal(editorDiv[0])
+      })
+    })
 
     domTest('fires events on select', function (browser, dom) {
-      var select = dom.insert('<select><option>one</option></select>');
+      var select = dom.insert('<select><option>one</option></select>')
 
-      var event;
+      var event
 
       return browser.on(function (e) {
-        event = e;
+        event = e
       }).find('select').select({text: 'one'}).then(function () {
         demand(event).to.not.equal(undefined)
-        demand(event.type).to.equal('select option');
-        demand(event.value).to.equal('one');
-        demand(event.optionElement[0]).to.equal(select.find('option')[0]);
-        demand(event.element[0]).to.equal(select[0]);
-      });
-    });
-  });
+        demand(event.type).to.equal('select option')
+        demand(event.value).to.equal('one')
+        demand(event.optionElement[0]).to.equal(select.find('option')[0])
+        demand(event.element[0]).to.equal(select[0])
+      })
+    })
+  })
 })
diff --git a/test/findersSpec.js b/test/findersSpec.js
index 1c61bdc..098bf59 100644
--- a/test/findersSpec.js
+++ b/test/findersSpec.js
@@ -1,213 +1,211 @@
 var demand = require('must')
-var domTest = require('./domTest');
+var domTest = require('./domTest')
 
 describe('find', function () {
   domTest('should eventually find an element', function (browser, dom) {
-    var promise = browser.find('.element').shouldExist();
+    var promise = browser.find('.element').shouldExist()
 
-    dom.eventuallyInsert('<div class="element"></div>');
+    dom.eventuallyInsert('<div class="element"></div>')
 
-    return promise;
-  });
+    return promise
+  })
 
   domTest('should eventually find an element, when collapsed into shouldFind(selector)', function (browser, dom) {
-    var promise = browser.shouldFind('.element');
+    var promise = browser.shouldFind('.element')
 
-    dom.eventuallyInsert('<div class="element"></div>');
+    dom.eventuallyInsert('<div class="element"></div>')
 
-    return promise;
-  });
+    return promise
+  })
 
   domTest('should eventually find an element using a filter', function (browser, dom) {
     var promise = browser.find('.element').filter(function (element) {
-      return element.hasClass('correct');
-    }, 'has class "correct"').element();
+      return element.hasClass('correct')
+    }, 'has class "correct"').element()
 
-    dom.insert('<div class="element"></div>');
-    dom.eventuallyInsert('<div class="element correct"></div>');
+    dom.insert('<div class="element"></div>')
+    dom.eventuallyInsert('<div class="element correct"></div>')
 
     return promise.then(function (element) {
-      demand(element.attr('class')).to.equal('element correct');
-    });
-  });
+      demand(element.attr('class')).to.equal('element correct')
+    })
+  })
 
   domTest('should eventually find an element with the right text', function (browser, dom) {
-    var promise = browser.find('.element', {text: 'green'}).element();
+    var promise = browser.find('.element', {text: 'green'}).element()
 
-    dom.insert('<div class="element"></div>');
-    dom.eventuallyInsert('<div class="element">red</div><div class="element">blue</div><div class="element">green</div>');
+    dom.insert('<div class="element"></div>')
+    dom.eventuallyInsert('<div class="element">red</div><div class="element">blue</div><div class="element">green</div>')
 
     return promise.then(function (element) {
-      demand(element.text()).to.equal('green');
-    });
-  });
+      demand(element.text()).to.equal('green')
+    })
+  })
 
   domTest('filter fails with the right message', function (browser, dom) {
     var promise = browser.find('.element').filter(function (element) {
-      return element.hasClass('correct');
-    }, 'has class "correct"').element();
-
-    dom.insert('<div class="element"></div>');
-    dom.eventuallyInsert('<div class="element"></div>');
-
-    return demand(promise).reject.with.error(/has class "correct"/);
-  });
-
-  domTest('should eventually find an element in an iframe', function(browser, dom){
-    var iframe = document.createElement('iframe');
-    iframe.src = '/base/test/page1.html';
-    iframe.width = 700;
-    iframe.height = 1000;
-    dom.el.append(iframe);
-    var iframeScope = browser.scope(iframe);
-    return iframeScope.find('a', {text: 'page 2'}).click().then(function(){
+      return element.hasClass('correct')
+    }, 'has class "correct"').element()
+
+    dom.insert('<div class="element"></div>')
+    dom.eventuallyInsert('<div class="element"></div>')
+
+    return demand(promise).reject.with.error(/has class "correct"/)
+  })
+
+  domTest('should eventually find an element in an iframe', function (browser, dom) {
+    var iframe = document.createElement('iframe')
+    iframe.src = '/base/test/page1.html'
+    iframe.width = 700
+    iframe.height = 1000
+    dom.el.append(iframe)
+    var iframeScope = browser.scope(iframe)
+    return iframeScope.find('a', {text: 'page 2'}).click().then(function () {
       return Promise.all([
         iframeScope.find('h1').shouldHave({text: 'Hello World'}),
         iframeScope.shouldHave({text: 'Hello World'})
-      ]);
-    });
-  }, {vdom: false});
+      ])
+    })
+  }, {vdom: false})
 
-  domTest('can find things in an iframe', function(browser, dom){
-    var iframe = document.createElement('iframe');
-    iframe.src = '/base/test/page2.html';
-    iframe.width = 700;
-    iframe.height = 1000;
-    dom.el.append(iframe);
+  domTest('can find things in an iframe', function (browser, dom) {
+    var iframe = document.createElement('iframe')
+    iframe.src = '/base/test/page2.html'
+    iframe.width = 700
+    iframe.height = 1000
+    dom.el.append(iframe)
 
-    return browser.find('iframe').element().then(function(iframe){
-      return browser.scope(iframe).find('h1', {text: 'Hello World'}).shouldExist();
-    });
-  }, {vdom: false});
+    return browser.find('iframe').element().then(function (iframe) {
+      return browser.scope(iframe).find('h1', {text: 'Hello World'}).shouldExist()
+    })
+  }, {vdom: false})
 
-  domTest('calls a function for each element found', function(browser, dom){
-    var promise = browser.find('span').elements();
+  domTest('calls a function for each element found', function (browser, dom) {
+    var promise = browser.find('span').elements()
 
-    dom.insert('<div><span>a</span><span>b</span></div>');
+    dom.insert('<div><span>a</span><span>b</span></div>')
 
-    return promise.then(function(elements){
-      demand(elements.length).to.equal(2);
-    });
-  });
+    return promise.then(function (elements) {
+      demand(elements.length).to.equal(2)
+    })
+  })
 
+  describe('visibility', function () {
+    domTest('should not find an element that is visually hidden', function (browser, dom) {
+      dom.insert('<div class="element">hello <span style="display:none;">world</span></div>')
 
-  describe('visibility', function(){
-    domTest('should not find an element that is visually hidden', function(browser, dom){
-      dom.insert('<div class="element">hello <span style="display:none;">world</span></div>');
+      return browser.find('.element > span').shouldNotExist()
+    }, {vdom: false})
 
-      return browser.find('.element > span').shouldNotExist();
-    }, {vdom: false});
+    domTest('should find an element that is visually hidden when visibleOnly = false', function (browser, dom) {
+      dom.insert('<div class="element">hello <span style="display:none;">world</span></div>')
 
-    domTest('should find an element that is visually hidden when visibleOnly = false', function(browser, dom){
-      dom.insert('<div class="element">hello <span style="display:none;">world</span></div>');
+      return browser.set({visibleOnly: false}).find('.element > span').shouldExist()
+    })
 
-      return browser.set({visibleOnly: false}).find('.element > span').shouldExist();
-    });
-
-    domTest('should find elements that are visually hidden because of how html renders them', function(browser, dom){
-      dom.insert('<select><option>First</option><option>Second</option></select>');
-      return browser.find('select option').shouldHave({text: ['First', 'Second']});
-    });
-  });
+    domTest('should find elements that are visually hidden because of how html renders them', function (browser, dom) {
+      dom.insert('<select><option>First</option><option>Second</option></select>')
+      return browser.find('select option').shouldHave({text: ['First', 'Second']})
+    })
+  })
 
   describe('containing', function () {
     domTest('eventually finds an element containing another element', function (browser, dom) {
-      var promise = browser.find('.outer').containing('.inner').shouldExist();
+      var promise = browser.find('.outer').containing('.inner').shouldExist()
 
       setTimeout(function () {
-        dom.insert('<div class="outer"><div>bad</div></div>');
-        dom.insert('<div class="outer"><div class="inner">good</div></div>');
-      }, 10);
+        dom.insert('<div class="outer"><div>bad</div></div>')
+        dom.insert('<div class="outer"><div class="inner">good</div></div>')
+      }, 10)
 
-      return promise;
-    });
+      return promise
+    })
 
     domTest('element returns the outer element', function (browser, dom) {
-      var promise = browser.find('.outer').containing('.inner').element();
+      var promise = browser.find('.outer').containing('.inner').element()
 
       setTimeout(function () {
-        dom.insert('<div class="outer"><div>bad</div></div>');
-        dom.insert('<div class="outer"><div class="inner">good</div></div>');
-      }, 10);
+        dom.insert('<div class="outer"><div>bad</div></div>')
+        dom.insert('<div class="outer"><div class="inner">good</div></div>')
+      }, 10)
 
       return promise.then(function (element) {
-        demand(element.hasClass('outer')).to.eql(true);
-      });
-    });
+        demand(element.hasClass('outer')).to.eql(true)
+      })
+    })
 
     domTest('errors with a usable css selector if it cant find something', function (browser, dom) {
-      var promise = browser.find('.outer').find('.not-there').element();
+      var promise = browser.find('.outer').find('.not-there').element()
 
       setTimeout(function () {
-        dom.insert('<div class="outer"><div>bad</div></div>');
-      }, 200);
+        dom.insert('<div class="outer"><div>bad</div></div>')
+      }, 200)
 
       return demand(promise).reject.with.error(/expected to find: .outer .not-there/)
-    });
+    })
 
     domTest('errors with a usable css selector if it cant find an element containing another', function (browser, dom) {
-      var promise = browser.find('.outer').containing('.not-there').shouldExist();
+      var promise = browser.find('.outer').containing('.not-there').shouldExist()
 
       setTimeout(function () {
-        dom.insert('<div class="outer"><div>bad</div></div>');
-      }, 200);
+        dom.insert('<div class="outer"><div>bad</div></div>')
+      }, 200)
 
       return demand(promise).reject.with.error('expected to find: .outer:has(.not-there)')
-    });
+    })
 
     domTest("fails if it can't find an element containing another", function (browser, dom) {
-      var promise = browser.find('.outer').containing('.inner').shouldExist();
+      var promise = browser.find('.outer').containing('.inner').shouldExist()
 
       setTimeout(function () {
-        dom.insert('<div class="outer"><div>bad</div></div>');
-      }, 200);
+        dom.insert('<div class="outer"><div>bad</div></div>')
+      }, 200)
 
-      return demand(promise).reject.with.error('expected to find: .outer:has(.inner)');
-    });
+      return demand(promise).reject.with.error('expected to find: .outer:has(.inner)')
+    })
 
     domTest('errors with a usable css selector if it cant find an element containing another', function (browser, dom) {
-      var promise = browser.find('.outer').containing('.not-there').shouldExist();
+      var promise = browser.find('.outer').containing('.not-there').shouldExist()
 
       setTimeout(function () {
-        dom.insert('<div class="outer"><div>bad</div></div>');
-      }, 200);
+        dom.insert('<div class="outer"><div>bad</div></div>')
+      }, 200)
 
       return demand(promise).reject.with.error('expected to find: .outer:has(.not-there)')
-    });
+    })
 
     domTest("fails if it can't find an element containing another", function (browser, dom) {
-      var promise = browser.find('.outer').containing('.inner').shouldExist();
+      var promise = browser.find('.outer').containing('.inner').shouldExist()
 
       setTimeout(function () {
-        dom.insert('<div class="outer"><div>bad</div></div>');
-      }, 10);
+        dom.insert('<div class="outer"><div>bad</div></div>')
+      }, 10)
 
       return demand(promise).reject.with.error()
-    });
-
-  });
+    })
+  })
   describe('chains', function () {
     domTest('eventually finds the inner element, even if the outer element exists', function (browser, dom) {
-      var promise = browser.find('.outer').find('.inner').shouldExist();
+      var promise = browser.find('.outer').find('.inner').shouldExist()
 
       setTimeout(function () {
-        var outer = dom.insert('<div class="outer"></div>');
+        var outer = dom.insert('<div class="outer"></div>')
         setTimeout(function () {
-          outer.append('<div class="inner">good</div>');
-        }, 10);
-      }, 10);
+          outer.append('<div class="inner">good</div>')
+        }, 10)
+      }, 10)
 
-      return promise;
-    });
+      return promise
+    })
 
     domTest('fails to find the inner element if it never arrives', function (browser, dom) {
-      var promise = browser.find('.outer').find('.inner').shouldExist();
+      var promise = browser.find('.outer').find('.inner').shouldExist()
 
       setTimeout(function () {
-        var outer = dom.insert('<div class="outer"></div>');
-      }, 10);
+        dom.insert('<div class="outer"></div>')
+      }, 10)
 
       return demand(promise).reject.with.error()
-    });
-  });
-});
+    })
+  })
+})
diff --git a/test/fuzzyFinderSpec.js b/test/fuzzyFinderSpec.js
index 56c487f..4b18e67 100644
--- a/test/fuzzyFinderSpec.js
+++ b/test/fuzzyFinderSpec.js
@@ -1,9 +1,9 @@
 var demand = require('must')
-var domTest = require('./domTest');
+var domTest = require('./domTest')
 
-describe('fuzzy finders', function() {
-  function domSetup(dom, $) {
-    var clicks = [];
+describe('fuzzy finders', function () {
+  function domSetup (dom, $) {
+    var clicks = []
     dom.insert(
       '<div>' +
       '<a id="link_one" href="#one">Link One</a> ' +
@@ -20,155 +20,153 @@ describe('fuzzy finders', function() {
       '<input id="button_seven" type="reset" value="Button Seven"></input> ' +
       '<input id="button_eight" type="button" value="Button Eight"></input> ' +
       '</div>'
-    );
-    dom.el.find('*').on('click', function(e) {
+    )
+    dom.el.find('*').on('click', function (e) {
       if (!$(this).is('div')) {
-        clicks.push($(this).attr('id'));
+        clicks.push($(this).attr('id'))
       }
-      return false;
-    });
+      return false
+    })
 
-    return clicks;
+    return clicks
   };
 
   describe('.click(label)', function () {
-    domTest('clicks links or buttons with the label', function(browser, dom, $) {
-      var labels = ['Link One', 'button_seven', 'Button Six'];
-      var clicks = domSetup(dom, $);
-      return Promise.all(labels.map(function(label) {
-        return browser.click(label);
-      })).then(function() {
-        demand(clicks.sort()).to.eql(['button_seven', 'button_six', 'link_one']);
-      });
-    });
-  });
+    domTest('clicks links or buttons with the label', function (browser, dom, $) {
+      var labels = ['Link One', 'button_seven', 'Button Six']
+      var clicks = domSetup(dom, $)
+      return Promise.all(labels.map(function (label) {
+        return browser.click(label)
+      })).then(function () {
+        demand(clicks.sort()).to.eql(['button_seven', 'button_six', 'link_one'])
+      })
+    })
+  })
 
   describe('.linkOrButton(label)', function () {
-    domTest('finds links or buttons with the label', function(browser, dom, $) {
-      var labels = ['Link Four', 'button_two', 'Button Eight'];
-      var clicks = domSetup(dom, $);
-      return Promise.all(labels.map(function(label) {
-        return browser.linkOrButton(label).click();
-      })).then(function() {
-        demand(clicks.sort()).to.eql(['button_eight', 'button_two', 'link_four']);
-      });
-    });
-  });
+    domTest('finds links or buttons with the label', function (browser, dom, $) {
+      var labels = ['Link Four', 'button_two', 'Button Eight']
+      var clicks = domSetup(dom, $)
+      return Promise.all(labels.map(function (label) {
+        return browser.linkOrButton(label).click()
+      })).then(function () {
+        demand(clicks.sort()).to.eql(['button_eight', 'button_two', 'link_four'])
+      })
+    })
+  })
 
   describe('.link(label)', function () {
     domTest('finds anchors by text', function (browser, dom, $) {
-      var clicks = domSetup(dom, $);
-      return browser.link('Link One').click().then(function() {
-        demand(clicks).to.eql(['link_one']);
-      });
-    });
+      var clicks = domSetup(dom, $)
+      return browser.link('Link One').click().then(function () {
+        demand(clicks).to.eql(['link_one'])
+      })
+    })
 
     domTest('finds anchors by id', function (browser, dom, $) {
-      var clicks = domSetup(dom, $);
-      return browser.link('link_two').click().then(function() {
-        demand(clicks).to.eql(['link_two']);
-      });
-    });
+      var clicks = domSetup(dom, $)
+      return browser.link('link_two').click().then(function () {
+        demand(clicks).to.eql(['link_two'])
+      })
+    })
 
     domTest('finds anchors by title', function (browser, dom, $) {
-      var clicks = domSetup(dom, $);
-      return browser.link('Link Three').click().then(function() {
-        demand(clicks).to.eql(['link_three']);
-      });
-    });
+      var clicks = domSetup(dom, $)
+      return browser.link('Link Three').click().then(function () {
+        demand(clicks).to.eql(['link_three'])
+      })
+    })
 
     domTest('finds anchors by nested img alt', function (browser, dom, $) {
-      var clicks = domSetup(dom, $);
-      return browser.link('Link Four').click().then(function() {
-        demand(clicks).to.eql(['link_four']);
-      });
-    });
+      var clicks = domSetup(dom, $)
+      return browser.link('Link Four').click().then(function () {
+        demand(clicks).to.eql(['link_four'])
+      })
+    })
 
     domTest('finds anchors inside elements', function (browser, dom, $) {
-      var clicks = domSetup(dom, $);
-      return browser.find('#container').link('Fifth Link').click().then(function() {
-        demand(clicks).to.eql(['link_five']);
-      });
-    });
+      var clicks = domSetup(dom, $)
+      return browser.find('#container').link('Fifth Link').click().then(function () {
+        demand(clicks).to.eql(['link_five'])
+      })
+    })
 
     domTest('does not find anchors by id', function (browser, dom, $) {
-      domSetup(dom, $);
-      return browser.link('omg').shouldNotExist();
-    });
+      domSetup(dom, $)
+      return browser.link('omg').shouldNotExist()
+    })
 
     domTest('does not find anchors inside elements', function (browser, dom, $) {
-      domSetup(dom, $);
-      return browser.find('#container').link('foo').shouldNotExist();
-    });
-
-  });
+      domSetup(dom, $)
+      return browser.find('#container').link('foo').shouldNotExist()
+    })
+  })
 
   describe('.button(label)', function () {
-
     domTest('finds button elements by text', function (browser, dom, $) {
-      var clicks = domSetup(dom, $);
-      return browser.button('Button One').click().then(function() {
-        demand(clicks).to.eql(['button_one']);
-      });
-    });
+      var clicks = domSetup(dom, $)
+      return browser.button('Button One').click().then(function () {
+        demand(clicks).to.eql(['button_one'])
+      })
+    })
 
     domTest('finds button elements by id', function (browser, dom, $) {
-      var clicks = domSetup(dom, $);
-      return browser.button('button_two').click().then(function() {
-        demand(clicks).to.eql(['button_two']);
-      });
-    });
+      var clicks = domSetup(dom, $)
+      return browser.button('button_two').click().then(function () {
+        demand(clicks).to.eql(['button_two'])
+      })
+    })
 
     domTest('does not find button elements by id', function (browser, dom, $) {
-      domSetup(dom, $);
-      return browser.button('button_666').shouldNotExist();
-    });
+      domSetup(dom, $)
+      return browser.button('button_666').shouldNotExist()
+    })
 
     domTest('finds button elements by value substring', function (browser, dom, $) {
-      var clicks = domSetup(dom, $);
-      return browser.button('Three').click().then(function() {
-        demand(clicks).to.eql(['button_three']);
-      });
-    });
+      var clicks = domSetup(dom, $)
+      return browser.button('Three').click().then(function () {
+        demand(clicks).to.eql(['button_three'])
+      })
+    })
 
     domTest('does not find button elements by value substring', function (browser, dom, $) {
-      domSetup(dom, $);
-      return browser.button('not a substring').shouldNotExist();
-    });
+      domSetup(dom, $)
+      return browser.button('not a substring').shouldNotExist()
+    })
 
     domTest('finds button elements by title substring', function (browser, dom, $) {
-      var clicks = domSetup(dom, $);
-      return browser.button('Four').click().then(function() {
-        demand(clicks).to.eql(['button_four']);
-      });
-    });
+      var clicks = domSetup(dom, $)
+      return browser.button('Four').click().then(function () {
+        demand(clicks).to.eql(['button_four'])
+      })
+    })
 
     domTest('finds input elements by title substring', function (browser, dom, $) {
-      var clicks = domSetup(dom, $);
-      return browser.button('Five').click().then(function() {
-        demand(clicks).to.eql(['button_five']);
-      });
-    });
+      var clicks = domSetup(dom, $)
+      return browser.button('Five').click().then(function () {
+        demand(clicks).to.eql(['button_five'])
+      })
+    })
 
     domTest('finds button elements by nested image alt substring', function (browser, dom, $) {
-      var clicks = domSetup(dom, $);
-      return browser.button('Six').click().then(function() {
-        demand(clicks).to.eql(['button_six']);
-      });
-    });
+      var clicks = domSetup(dom, $)
+      return browser.button('Six').click().then(function () {
+        demand(clicks).to.eql(['button_six'])
+      })
+    })
 
     domTest('finds input[type=reset] elements', function (browser, dom, $) {
-      var clicks = domSetup(dom, $);
-      return browser.button('Seven').click().then(function() {
-        demand(clicks).to.eql(['button_seven']);
-      });
-    });
+      var clicks = domSetup(dom, $)
+      return browser.button('Seven').click().then(function () {
+        demand(clicks).to.eql(['button_seven'])
+      })
+    })
 
     domTest('finds input[type=button] elements', function (browser, dom, $) {
-      var clicks = domSetup(dom, $);
-      return browser.button('Eight').click().then(function() {
-        demand(clicks).to.eql(['button_eight']);
-      });
-    });
-  });
-});
+      var clicks = domSetup(dom, $)
+      return browser.button('Eight').click().then(function () {
+        demand(clicks).to.eql(['button_eight'])
+      })
+    })
+  })
+})
diff --git a/test/global.js b/test/global.js
index 0360b84..80775e4 100644
--- a/test/global.js
+++ b/test/global.js
@@ -1,17 +1,16 @@
-require('lie/polyfill');
+require('lie/polyfill')
 
-var chai = require("chai");
-var expect = chai.expect;
-global.timeout = parseInt(typeof window == 'object' && window.__env__.BM_TIMEOUT || 200);
+var expect = require('chai').expect
+global.timeout = parseInt(typeof window === 'object' && (window.__env__.BM_TIMEOUT || 200))
 
-Promise.prototype.assertStackTrace = function(file) {
-  return this.then(function(){
-    throw new Error('This test should have thrown an error but did not. You need to fix this.');
-  }).catch(function(error){
-    var specLine = error.stack.split('\n').find(function(line){
-      return line.indexOf(file) != -1;
-    });
+Promise.prototype.assertStackTrace = function (file) { // eslint-disable-line
+  return this.then(function () {
+    throw new Error('This test should have thrown an error but did not. You need to fix this.')
+  }).catch(function (error) {
+    var specLine = error.stack.split('\n').find(function (line) {
+      return line.indexOf(file) !== -1
+    })
 
-    expect(specLine).to.include(file);
-  });
+    expect(specLine).to.include(file)
+  })
 }
diff --git a/test/hyperdomIntegrationSpec.js b/test/hyperdomIntegrationSpec.js
index f9df2b2..7039fab 100644
--- a/test/hyperdomIntegrationSpec.js
+++ b/test/hyperdomIntegrationSpec.js
@@ -1,65 +1,65 @@
 var demand = require('must')
-var retry = require('trytryagain');
-var browser = require('..');
-var hyperdom = require('hyperdom');
-var h = hyperdom.html;
+var retry = require('trytryagain')
+var browser = require('..')
+var hyperdom = require('hyperdom')
+var h = hyperdom.html
 
-describe('hyperdom integration', function(){
-  it('should find things rendered by hyperdom', function(){
+describe('hyperdom integration', function () {
+  it('should find things rendered by hyperdom', function () {
     function App (model) {
       this.model = model
     }
 
     App.prototype.render = function () {
       var model = this.model
-      function renderMessage(){
-        if(model.show) {
-          return h('span', 'hello');
+      function renderMessage () {
+        if (model.show) {
+          return h('span', 'hello')
         }
       }
       return h('div', [
-          h('a.toggle', {
-            onclick: function(){
-              model.show = !model.show;
-            }
-          }),
-          h('input', {type: 'text', binding: [model, 'name']}),
-          h('select', {binding: [model, 'gender']},
+        h('a.toggle', {
+          onclick: function () {
+            model.show = !model.show
+          }
+        }),
+        h('input', {type: 'text', binding: [model, 'name']}),
+        h('select', {binding: [model, 'gender']},
            h('option', 'Select..'),
            h('option', {value: 'fml'}, 'Female'),
            h('option', {value: 'ml'}, 'Male')
           ),
-          h('.name', 'Name: ', model.name),
-          h('.gender', 'Gender: ', model.gender),
-          renderMessage()
-        ]
-      );
+        h('.name', 'Name: ', model.name),
+        h('.gender', 'Gender: ', model.gender),
+        renderMessage()
+      ]
+      )
     }
 
-    var vdom = h('div');
+    var vdom = h('div')
 
-    var model = {};
-    hyperdom.appendVDom(vdom, new App(model), { requestRender: setTimeout, window: {} });
-    browser = browser.scope(vdom);
+    var model = {}
+    hyperdom.appendVDom(vdom, new App(model), { requestRender: setTimeout, window: {} })
+    browser = browser.scope(vdom)
     var vquery = require('vdom-query')
-    browser.set({$: vquery, visibleOnly: false, document: {}});
+    browser.set({$: vquery, visibleOnly: false, document: {}})
 
-    return browser.find('.toggle').click().then(function(){
-      return browser.find('span', {text: 'hello'}).shouldExist();
-    }).then(function(){
-      return browser.find('input').typeIn({text: 'monkey'});
-    }).then(function(){
-      return retry(function(){
-        demand(model.name).to.equal('monkey');
-      });
-    }).then(function(){
-      return browser.find('select').select({text: 'Female'});
-    }).then(function(){
-      return browser.find('.name').shouldHave({text: 'monkey'});
-    }).then(function(){
-      return browser.find('.gender').shouldHave({text: 'fml'});
-    }).then(function(){
-      return browser.find('input').shouldHave({value: 'monkey'});
+    return browser.find('.toggle').click().then(function () {
+      return browser.find('span', {text: 'hello'}).shouldExist()
+    }).then(function () {
+      return browser.find('input').typeIn({text: 'monkey'})
+    }).then(function () {
+      return retry(function () {
+        demand(model.name).to.equal('monkey')
+      })
+    }).then(function () {
+      return browser.find('select').select({text: 'Female'})
+    }).then(function () {
+      return browser.find('.name').shouldHave({text: 'monkey'})
+    }).then(function () {
+      return browser.find('.gender').shouldHave({text: 'fml'})
+    }).then(function () {
+      return browser.find('input').shouldHave({value: 'monkey'})
     })
-  });
-});
+  })
+})
diff --git a/test/immediateSpec.js b/test/immediateSpec.js
index db12404..81f1d36 100644
--- a/test/immediateSpec.js
+++ b/test/immediateSpec.js
@@ -1,65 +1,65 @@
 var demand = require('must')
-var domTest = require('./domTest');
+var domTest = require('./domTest')
 
 describe('.set({ immediate: true })', function () {
   describe('click', function () {
     domTest('makes clicks happen immediately', function (browser, dom, $) {
-      var clicked = false;
+      var clicked = false
 
       dom.insert('<div class="element">red</div>').on('click', function () {
-        clicked = true;
+        clicked = true
       })
 
-      browser.set({ immediate: true });
-      browser.find('.element').click();
-      demand(clicked).to.equal(true);
-    });
+      browser.set({ immediate: true })
+      browser.find('.element').click()
+      demand(clicked).to.equal(true)
+    })
 
     domTest('throws errors immediately', function (browser, dom, $) {
-      browser.set({ immediate: true });
+      browser.set({ immediate: true })
       demand(function () {
-        browser.find('.element').click();
+        browser.find('.element').click()
       }).throw('expected to find: .element [disabled=false]')
-    });
+    })
   })
 
-  domTest('fills a component with supplied values immediately', function(browser, dom){
-    browser.set({ immediate: true });
+  domTest('fills a component with supplied values immediately', function (browser, dom) {
+    browser.set({ immediate: true })
 
     var component = browser.component({
-      title: function(){
-        return this.find('.title');
+      title: function () {
+        return this.find('.title')
       },
-      name: function(){
-        return this.find('.name');
+      name: function () {
+        return this.find('.name')
       }
-    });
-    dom.insert('<select class="title"><option>Mrs</option><option>Mr</option></select>');
-    dom.insert('<input type="text" class="name"></input>');
+    })
+    dom.insert('<select class="title"><option>Mrs</option><option>Mr</option></select>')
+    dom.insert('<input type="text" class="name"></input>')
 
     component.fill([
-      { name: 'title', action: 'select', options: {exactText: 'Mr'}},
-      { name: 'name', action: 'typeIn', options: {text: 'Joe'}}
+      {name: 'title', action: 'select', options: {exactText: 'Mr'}},
+      {name: 'name', action: 'typeIn', options: {text: 'Joe'}}
     ])
-    demand(dom.el.find('.title').val()).to.equal('Mr');
-    demand(dom.el.find('.name').val()).to.equal('Joe');
-  });
+    demand(dom.el.find('.title').val()).to.equal('Mr')
+    demand(dom.el.find('.name').val()).to.equal('Joe')
+  })
 
   describe('shouldHave', function () {
     domTest('tests text values immediately', function (browser, dom, $) {
       dom.insert('<div class="element">red</div>')
 
-      browser.set({ immediate: true });
-      browser.find('.element').shouldHave({text: 'red'});
-    });
+      browser.set({ immediate: true })
+      browser.find('.element').shouldHave({text: 'red'})
+    })
 
     domTest('throws on failure immediately', function (browser, dom, $) {
       dom.insert('<div class="element">red</div>')
 
-      browser.set({ immediate: true });
+      browser.set({ immediate: true })
       demand(function () {
-        browser.find('.element').shouldHave({text: 'blue'});
-      }).throw(/expected element to contain \"blue\" but contained \"red\"/)
-    });
+        browser.find('.element').shouldHave({text: 'blue'})
+      }).throw(/expected element to contain "blue" but contained "red"/)
+    })
   })
-});
+})
diff --git a/test/mountSpec.js b/test/mountSpec.js
index 0816c47..d20a249 100644
--- a/test/mountSpec.js
+++ b/test/mountSpec.js
@@ -1,28 +1,28 @@
-var server = require('karma-server-side');
+var server = require('karma-server-side')
 var expect = require('chai').expect
-var isBrowser = !require('is-node');
+var isBrowser = !require('is-node')
 
-function isSupportedBrowser(){
+function isSupportedBrowser () {
   if (isBrowser) {
-    var browser = require('detect-browser');
+    var browser = require('detect-browser')
     if (browser.name === 'ie' && parseInt(browser.version.match(/(\d+)./)[1]) <= 10) {
-      return false;
+      return false
     }
 
-    return true;
+    return true
   }
 }
 
 if (isSupportedBrowser()) {
-  testMount('angular', require('./app/angular'), require('../angular'));
-  testMount('hyperdom', new (require('./app/hyperdom')), require('../hyperdom'));
-  testMount('react', new (require('./app/react')), require('../react'));
+  testMount('angular', require('./app/angular'), require('../angular'))
+  testMount('hyperdom', new (require('./app/hyperdom'))(), require('../hyperdom'))
+  testMount('react', new (require('./app/react'))(), require('../react'))
 
   context('iframe', () => {
-    var app;
+    var app
     before(() => {
-      return server.run(function() {
-        var express = serverRequire('express');
+      return server.run(function () {
+        var express = serverRequire('express') // eslint-disable-line 
         app = express()
         app.get('/', (req, res) => {
           res.send(`<form action="/iframe-test/click">
@@ -35,9 +35,9 @@ if (isSupportedBrowser()) {
           res.send('<div class="message">hello browser-monkey</div>')
         })
 
-        var self = this;
-        return new Promise(function(resolve) {
-          self.server = app.listen(4572, function() {
+        var self = this
+        return new Promise(function (resolve) {
+          self.server = app.listen(4572, function () {
             resolve()
           })
         })
@@ -45,38 +45,37 @@ if (isSupportedBrowser()) {
     })
 
     after(() => {
-      return server.run(function() {
-        var self = this;
-        return new Promise(function(resolve) {
+      return server.run(function () {
+        var self = this
+        return new Promise(function (resolve) {
           self.server.close(resolve)
         })
       })
     })
-    testMount('iframe', location.origin + '/iframe-test/', require('../iframe'));
+    testMount('iframe', window.location.origin + '/iframe-test/', require('../iframe'))
   })
+}
 
-  function testMount(appType, app, monkeyBuilder) {
-    describe(`mount ${appType}`, () => {
-      var monkey
+function testMount (appType, app, monkeyBuilder) {
+  describe(`mount ${appType}`, () => {
+    var monkey
 
-      beforeEach(() => {
-        monkey = monkeyBuilder(app)
-      });
+    beforeEach(() => {
+      monkey = monkeyBuilder(app)
+    })
 
-      afterEach(() => monkey.get('mount').stop());
+    afterEach(() => monkey.get('mount').stop())
 
-      it('loads some data', () => {
-        return monkey.find('.message').shouldHave({text: 'default'}).then(() => {
-          return monkey.find('button').click();
-        }).then(() => {
-          return monkey.find('.message').shouldHave({text: 'hello browser-monkey'})
-        })
-      });
+    it('loads some data', () => {
+      return monkey.find('.message').shouldHave({text: 'default'}).then(() => {
+        return monkey.find('button').click()
+      }).then(() => {
+        return monkey.find('.message').shouldHave({text: 'hello browser-monkey'})
+      })
+    })
 
-      it('exposes the app', () => {
-        expect(monkey.get('app')).to.equal(app);
-      });
-    });
-  }
+    it('exposes the app', () => {
+      expect(monkey.get('app')).to.equal(app)
+    })
+  })
 }
-
diff --git a/test/optionsSpec.js b/test/optionsSpec.js
index dfbb049..fe69b66 100644
--- a/test/optionsSpec.js
+++ b/test/optionsSpec.js
@@ -1,26 +1,26 @@
 var demand = require('must')
-var create = require('../create');
+var create = require('../create')
 
 describe('options', function () {
-  it('can set an option that is inerhited by components', function(){
-    var browser = create();
-    var parentComponent = browser.find('div').component({});
-    parentComponent.set({myOption: 'abc'});
-    var childComponent = parentComponent.find('div').component({});
-    demand(childComponent.get('myOption')).to.equal('abc');
-  });
+  it('can set an option that is inerhited by components', function () {
+    var browser = create()
+    var parentComponent = browser.find('div').component({})
+    parentComponent.set({myOption: 'abc'})
+    var childComponent = parentComponent.find('div').component({})
+    demand(childComponent.get('myOption')).to.equal('abc')
+  })
 
-  it('can overide default timeout', function(){
-    var browser = create();
-    var defaultTimeout = browser.get('timeout');
-    browser.set({timeout: 10});
-    var start = new Date();
+  it('can overide default timeout', function () {
+    var browser = create()
+    var defaultTimeout = browser.get('timeout')
+    browser.set({timeout: 10})
+    var start = new Date()
 
-    return browser.find('.doesnt-exist').shouldExist().catch(function(){
-      var end = new Date();
-      var duration = end - start;
+    return browser.find('.doesnt-exist').shouldExist().catch(function () {
+      var end = new Date()
+      var duration = end - start
       demand(duration > browser.get('timeout')).to.equal(true)
       demand(duration < defaultTimeout).to.equal(true)
-    });
-  });
-});
+    })
+  })
+})
diff --git a/test/scopeSpec.js b/test/scopeSpec.js
index 56b2fc4..8938f10 100644
--- a/test/scopeSpec.js
+++ b/test/scopeSpec.js
@@ -1,31 +1,30 @@
 var demand = require('must')
-var domTest = require('./domTest');
+var domTest = require('./domTest')
 
 describe('scope', function () {
   domTest('can scope with an element', function (browser, dom, $) {
-    var red = dom.insert('<div><div class="element">red</div></div>');
-    var blue = dom.insert('<div><div class="element">blue</div></div>');
+    var red = dom.insert('<div><div class="element">red</div></div>')
+    var blue = dom.insert('<div><div class="element">blue</div></div>')
 
     return browser.scope(red).find('.element').element().then(function (element) {
-      demand($(element).text()).to.equal('red');
+      demand($(element).text()).to.equal('red')
     }).then(function () {
-      return browser.scope(blue).find('.element').element();
+      return browser.scope(blue).find('.element').element()
     }).then(function (element) {
-      demand($(element).text()).to.equal('blue');
-    });
-  });
+      demand($(element).text()).to.equal('blue')
+    })
+  })
 
   domTest('can scope with another finder', function (browser, dom, $) {
-    var red = dom.insert('<div class="red"><div class="element">red</div></div>');
-    var blue = dom.insert('<div class="blue"><div class="element">blue</div></div>');
+    dom.insert('<div class="red"><div class="element">red</div></div>')
+    dom.insert('<div class="blue"><div class="element">blue</div></div>')
 
     return browser.scope(browser.find('.red')).find('.element').element().then(function (element) {
-      demand($(element).text()).to.equal('red');
+      demand($(element).text()).to.equal('red')
     }).then(function () {
-      return browser.scope(browser.find('.blue')).find('.element').element();
+      return browser.scope(browser.find('.blue')).find('.element').element()
     }).then(function (element) {
-      demand($(element).text()).to.equal('blue');
-    });
-  });
-});
-
+      demand($(element).text()).to.equal('blue')
+    })
+  })
+})
diff --git a/yarn.lock b/yarn.lock
index 2d45957..f6fcf71 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -32,14 +32,28 @@ accepts@1.3.3, accepts@~1.3.3:
     mime-types "~2.1.11"
     negotiator "0.6.1"
 
+acorn-jsx@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-3.0.1.tgz#afdf9488fb1ecefc8348f6fb22f464e32a58b36b"
+  dependencies:
+    acorn "^3.0.4"
+
 acorn@^2.7.0:
   version "2.7.0"
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-2.7.0.tgz#ab6e7d9d886aaca8b085bc3312b79a198433f0e7"
 
+acorn@^3.0.4:
+  version "3.3.0"
+  resolved "https://registry.yarnpkg.com/acorn/-/acorn-3.3.0.tgz#45e37fb39e8da3f25baee3ff5369e2bb5f22017a"
+
 acorn@^4.0.3:
   version "4.0.11"
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-4.0.11.tgz#edcda3bd937e7556410d42ed5860f67399c794c0"
 
+acorn@^5.0.1:
+  version "5.0.3"
+  resolved "https://registry.yarnpkg.com/acorn/-/acorn-5.0.3.tgz#c460df08491463f028ccb82eab3730bf01087b3d"
+
 after@0.8.1:
   version "0.8.1"
   resolved "https://registry.yarnpkg.com/after/-/after-0.8.1.tgz#ab5d4fb883f596816d3515f8f791c0af486dd627"
@@ -55,7 +69,11 @@ agent-base@2:
     extend "~3.0.0"
     semver "~5.0.1"
 
-ajv@^4.9.1:
+ajv-keywords@^1.0.0:
+  version "1.5.1"
+  resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-1.5.1.tgz#314dd0a4b3368fad3dfcdc54ede6171b886daf3c"
+
+ajv@^4.7.0, ajv@^4.9.1:
   version "4.11.4"
   resolved "https://registry.yarnpkg.com/ajv/-/ajv-4.11.4.tgz#ebf3a55d4b132ea60ff5847ae85d2ef069960b45"
   dependencies:
@@ -70,6 +88,10 @@ angular@^1.6.0:
   version "1.6.3"
   resolved "https://registry.yarnpkg.com/angular/-/angular-1.6.3.tgz#5d34b799234e8fa17c6a3a14e0258733935f43e7"
 
+ansi-escapes@^1.1.0:
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-1.4.0.tgz#d3a8a83b319aa67793662b13e761c7911422306e"
+
 ansi-regex@^2.0.0:
   version "2.1.1"
   resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-2.1.1.tgz#c3b33ab5ee360d86e0e628f0468ae7ef27d654df"
@@ -96,6 +118,12 @@ are-we-there-yet@~1.1.2:
     delegates "^1.0.0"
     readable-stream "^2.0.0 || ^1.1.13"
 
+argparse@^1.0.7:
+  version "1.0.9"
+  resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.9.tgz#73d83bc263f86e97f8cc4f6bae1b0e90a7d22c86"
+  dependencies:
+    sprintf-js "~1.0.2"
+
 arr-diff@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-2.0.0.tgz#8f3b827f955a8bd669697e4a4256ac3ceae356cf"
@@ -126,11 +154,21 @@ array-slice@^0.2.3:
   version "0.2.3"
   resolved "https://registry.yarnpkg.com/array-slice/-/array-slice-0.2.3.tgz#dd3cfb80ed7973a75117cdac69b0b99ec86186f5"
 
+array-union@^1.0.1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/array-union/-/array-union-1.0.2.tgz#9a34410e4f4e3da23dea375be5be70f24778ec39"
+  dependencies:
+    array-uniq "^1.0.1"
+
+array-uniq@^1.0.1:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/array-uniq/-/array-uniq-1.0.3.tgz#af6ac877a25cc7f74e058894753858dfdb24fdb6"
+
 array-unique@^0.2.1:
   version "0.2.1"
   resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.2.1.tgz#a1d97ccafcbc2625cc70fadceb36a50c58b01a53"
 
-array.prototype.find@^2.0.3:
+array.prototype.find@^2.0.1, array.prototype.find@^2.0.3:
   version "2.0.3"
   resolved "https://registry.yarnpkg.com/array.prototype.find/-/array.prototype.find-2.0.3.tgz#08c3ec33e32ec4bab362a2958e686ae92f59271d"
   dependencies:
@@ -234,7 +272,7 @@ babel-cli@^6.24.0:
   optionalDependencies:
     chokidar "^1.6.1"
 
-babel-code-frame@^6.22.0:
+babel-code-frame@^6.16.0, babel-code-frame@^6.22.0:
   version "6.22.0"
   resolved "https://registry.yarnpkg.com/babel-code-frame/-/babel-code-frame-6.22.0.tgz#027620bee567a88c32561574e7fd0801d33118e4"
   dependencies:
@@ -1132,6 +1170,10 @@ buffers@~0.1.1:
   version "0.1.1"
   resolved "https://registry.yarnpkg.com/buffers/-/buffers-0.1.1.tgz#b24579c3bed4d6d396aeee6d9a8ae7f5482ab7bb"
 
+builtin-modules@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/builtin-modules/-/builtin-modules-1.1.1.tgz#270f076c5a72c02f5b65a47df94c5fe3a278892f"
+
 builtin-status-codes@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz#85982878e21b98e1c66425e03d0174788f569ee8"
@@ -1144,10 +1186,20 @@ cached-path-relative@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/cached-path-relative/-/cached-path-relative-1.0.1.tgz#d09c4b52800aa4c078e2dd81a869aac90d2e54e7"
 
+caller-path@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.yarnpkg.com/caller-path/-/caller-path-0.1.0.tgz#94085ef63581ecd3daa92444a8fe94e82577751f"
+  dependencies:
+    callsites "^0.2.0"
+
 callsite@1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/callsite/-/callsite-1.0.0.tgz#280398e5d664bd74038b6f0905153e6e8af1bc20"
 
+callsites@^0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/callsites/-/callsites-0.2.0.tgz#afab96262910a7f33c19a5775825c69f34e350ca"
+
 camelize@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/camelize/-/camelize-1.0.0.tgz#164a5483e630fa4321e5af07020e531831b2609b"
@@ -1156,12 +1208,6 @@ caseless@~0.12.0:
   version "0.12.0"
   resolved "https://registry.yarnpkg.com/caseless/-/caseless-0.12.0.tgz#1b681c21ff84033c826543090689420d187151dc"
 
-chai-as-promised@6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/chai-as-promised/-/chai-as-promised-6.0.0.tgz#1a02a433a6f24dafac63b9c96fa1684db1aa8da6"
-  dependencies:
-    check-error "^1.0.2"
-
 chai@3.5.0:
   version "3.5.0"
   resolved "https://registry.yarnpkg.com/chai/-/chai-3.5.0.tgz#4d02637b067fe958bdbfdd3a40ec56fef7373247"
@@ -1176,7 +1222,7 @@ chainsaw@~0.1.0:
   dependencies:
     traverse ">=0.3.0 <0.4"
 
-chalk@1.1.3, chalk@^1.1.0:
+chalk@1.1.3, chalk@^1.0.0, chalk@^1.1.0, chalk@^1.1.1, chalk@^1.1.3:
   version "1.1.3"
   resolved "https://registry.yarnpkg.com/chalk/-/chalk-1.1.3.tgz#a8115c55e4a702fe4d150abd3872822a7e09fc98"
   dependencies:
@@ -1186,10 +1232,6 @@ chalk@1.1.3, chalk@^1.1.0:
     strip-ansi "^3.0.0"
     supports-color "^2.0.0"
 
-check-error@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/check-error/-/check-error-1.0.2.tgz#574d312edd88bb5dd8912e9286dd6c0aed4aac82"
-
 chokidar@^1.0.0, chokidar@^1.4.1, chokidar@^1.6.1:
   version "1.6.1"
   resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-1.6.1.tgz#2f4447ab5e96e50fb3d789fd90d4c72e0e4c70c2"
@@ -1211,6 +1253,20 @@ cipher-base@^1.0.0, cipher-base@^1.0.1:
   dependencies:
     inherits "^2.0.1"
 
+circular-json@^0.3.1:
+  version "0.3.1"
+  resolved "https://registry.yarnpkg.com/circular-json/-/circular-json-0.3.1.tgz#be8b36aefccde8b3ca7aa2d6afc07a37242c0d2d"
+
+cli-cursor@^1.0.1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-1.0.2.tgz#64da3f7d56a54412e59794bd62dc35295e8f2987"
+  dependencies:
+    restore-cursor "^1.0.1"
+
+cli-width@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/cli-width/-/cli-width-2.1.0.tgz#b234ca209b29ef66fc518d9b98d5847b00edf00a"
+
 co@^4.6.0:
   version "4.6.0"
   resolved "https://registry.yarnpkg.com/co/-/co-4.6.0.tgz#6ea6bdf3d853ae54ccb8e47bfa0bf3f9031fb184"
@@ -1284,7 +1340,7 @@ concat-map@0.0.1:
   version "0.0.1"
   resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
 
-concat-stream@~1.5.0, concat-stream@~1.5.1:
+concat-stream@^1.5.2, concat-stream@~1.5.0, concat-stream@~1.5.1:
   version "1.5.2"
   resolved "https://registry.yarnpkg.com/concat-stream/-/concat-stream-1.5.2.tgz#708978624d856af41a5a741defdd261da752c266"
   dependencies:
@@ -1315,6 +1371,10 @@ constants-browserify@~1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/constants-browserify/-/constants-browserify-1.0.0.tgz#c20b96d8c617748aaf1c16021760cd27fcb8cb75"
 
+contains-path@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.yarnpkg.com/contains-path/-/contains-path-0.1.0.tgz#fe8cf184ff6670b6baef01a9d4861a5cbec4120a"
+
 content-disposition@0.5.2:
   version "0.5.2"
   resolved "https://registry.yarnpkg.com/content-disposition/-/content-disposition-0.5.2.tgz#0cf68bb9ddf5f2be7961c3a85178cb85dba78cb4"
@@ -1405,6 +1465,12 @@ custom-event@~1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/custom-event/-/custom-event-1.0.1.tgz#5d02a46850adf1b4a317946a3928fccb5bfd0425"
 
+d@1:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/d/-/d-1.0.0.tgz#754bb5bfe55451da69a58b94d45f4c5b0462d58f"
+  dependencies:
+    es5-ext "^0.10.9"
+
 dashdash@^1.12.0:
   version "1.14.1"
   resolved "https://registry.yarnpkg.com/dashdash/-/dashdash-1.14.1.tgz#853cfa0f7cbe2fed5de20326b8dd581035f6e2f0"
@@ -1415,6 +1481,10 @@ date-now@^0.1.4:
   version "0.1.4"
   resolved "https://registry.yarnpkg.com/date-now/-/date-now-0.1.4.tgz#eaf439fd4d4848ad74e5cc7dbef200672b9e345b"
 
+debug-log@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/debug-log/-/debug-log-1.0.1.tgz#2307632d4c04382b8df8a32f70b895046d52745f"
+
 debug@2, debug@^2.1.1, debug@^2.2.0, debug@^2.6.3:
   version "2.6.3"
   resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.3.tgz#0f7eb8c30965ec08c72accfa0130c8b79984141d"
@@ -1453,6 +1523,10 @@ deep-extend@~0.4.0:
   version "0.4.1"
   resolved "https://registry.yarnpkg.com/deep-extend/-/deep-extend-0.4.1.tgz#efe4113d08085f4e6f9687759810f807469e2253"
 
+deep-is@~0.1.3:
+  version "0.1.3"
+  resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.3.tgz#b369d6fb5dbc13eecf524f91b070feedc357cf34"
+
 define-properties@^1.1.2:
   version "1.1.2"
   resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.1.2.tgz#83a73f2fea569898fb737193c8f873caf6d45c94"
@@ -1470,6 +1544,29 @@ defined@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/defined/-/defined-1.0.0.tgz#c98d9bcef75674188e110969151199e39b1fa693"
 
+deglob@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/deglob/-/deglob-2.1.0.tgz#4d44abe16ef32c779b4972bd141a80325029a14a"
+  dependencies:
+    find-root "^1.0.0"
+    glob "^7.0.5"
+    ignore "^3.0.9"
+    pkg-config "^1.1.0"
+    run-parallel "^1.1.2"
+    uniq "^1.0.1"
+
+del@^2.0.2:
+  version "2.2.2"
+  resolved "https://registry.yarnpkg.com/del/-/del-2.2.2.tgz#c12c981d067846c84bcaf862cff930d907ffd1a8"
+  dependencies:
+    globby "^5.0.0"
+    is-path-cwd "^1.0.0"
+    is-path-in-cwd "^1.0.0"
+    object-assign "^4.0.1"
+    pify "^2.0.0"
+    pinkie-promise "^2.0.0"
+    rimraf "^2.2.8"
+
 delayed-stream@~1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619"
@@ -1539,6 +1636,20 @@ diffie-hellman@^5.0.0:
     miller-rabin "^4.0.0"
     randombytes "^2.0.0"
 
+doctrine@1.5.0, doctrine@^1.2.2:
+  version "1.5.0"
+  resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-1.5.0.tgz#379dce730f6166f76cefa4e6707a159b02c5a6fa"
+  dependencies:
+    esutils "^2.0.2"
+    isarray "^1.0.0"
+
+doctrine@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-2.0.0.tgz#c73d8d2909d22291e1a007a395804da8b665fe63"
+  dependencies:
+    esutils "^2.0.2"
+    isarray "^1.0.0"
+
 dom-serialize@^2.2.0:
   version "2.2.1"
   resolved "https://registry.yarnpkg.com/dom-serialize/-/dom-serialize-2.2.1.tgz#562ae8999f44be5ea3076f5419dcd59eb43ac95b"
@@ -1703,6 +1814,12 @@ entities@^1.1.1, entities@~1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/entities/-/entities-1.1.1.tgz#6e5c2d0a5621b5dadaecef80b90edfb5cd7772f0"
 
+error-ex@^1.2.0:
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/error-ex/-/error-ex-1.3.1.tgz#f855a86ce61adc4e8621c3cda21e7a7612c3a8dc"
+  dependencies:
+    is-arrayish "^0.2.1"
+
 error@^4.3.0:
   version "4.4.0"
   resolved "https://registry.yarnpkg.com/error/-/error-4.4.0.tgz#bf69ff251fb4a279c19adccdaa6b61e90d9bf12a"
@@ -1728,11 +1845,63 @@ es-to-primitive@^1.1.1:
     is-date-object "^1.0.1"
     is-symbol "^1.0.1"
 
+es5-ext@^0.10.14, es5-ext@^0.10.9, es5-ext@~0.10.14:
+  version "0.10.15"
+  resolved "https://registry.yarnpkg.com/es5-ext/-/es5-ext-0.10.15.tgz#c330a5934c1ee21284a7c081a86e5fd937c91ea6"
+  dependencies:
+    es6-iterator "2"
+    es6-symbol "~3.1"
+
+es6-iterator@2, es6-iterator@^2.0.1, es6-iterator@~2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/es6-iterator/-/es6-iterator-2.0.1.tgz#8e319c9f0453bf575d374940a655920e59ca5512"
+  dependencies:
+    d "1"
+    es5-ext "^0.10.14"
+    es6-symbol "^3.1"
+
+es6-map@^0.1.3:
+  version "0.1.5"
+  resolved "https://registry.yarnpkg.com/es6-map/-/es6-map-0.1.5.tgz#9136e0503dcc06a301690f0bb14ff4e364e949f0"
+  dependencies:
+    d "1"
+    es5-ext "~0.10.14"
+    es6-iterator "~2.0.1"
+    es6-set "~0.1.5"
+    es6-symbol "~3.1.1"
+    event-emitter "~0.3.5"
+
+es6-set@~0.1.5:
+  version "0.1.5"
+  resolved "https://registry.yarnpkg.com/es6-set/-/es6-set-0.1.5.tgz#d2b3ec5d4d800ced818db538d28974db0a73ccb1"
+  dependencies:
+    d "1"
+    es5-ext "~0.10.14"
+    es6-iterator "~2.0.1"
+    es6-symbol "3.1.1"
+    event-emitter "~0.3.5"
+
+es6-symbol@3.1.1, es6-symbol@^3.1, es6-symbol@^3.1.1, es6-symbol@~3.1, es6-symbol@~3.1.1:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/es6-symbol/-/es6-symbol-3.1.1.tgz#bf00ef4fdab6ba1b46ecb7b629b4c7ed5715cc77"
+  dependencies:
+    d "1"
+    es5-ext "~0.10.14"
+
+es6-weak-map@^2.0.1:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/es6-weak-map/-/es6-weak-map-2.0.2.tgz#5e3ab32251ffd1538a1f8e5ffa1357772f92d96f"
+  dependencies:
+    d "1"
+    es5-ext "^0.10.14"
+    es6-iterator "^2.0.1"
+    es6-symbol "^3.1.1"
+
 escape-html@^1.0.1, escape-html@~1.0.3:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/escape-html/-/escape-html-1.0.3.tgz#0258eae4d3d0c0974de1c169188ef0051d1d1988"
 
-escape-string-regexp@1.0.5, escape-string-regexp@^1.0.2:
+escape-string-regexp@1.0.5, escape-string-regexp@^1.0.2, escape-string-regexp@^1.0.5:
   version "1.0.5"
   resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
 
@@ -1746,14 +1915,161 @@ escodegen@~1.2.0:
   optionalDependencies:
     source-map "~0.1.30"
 
+escope@^3.6.0:
+  version "3.6.0"
+  resolved "https://registry.yarnpkg.com/escope/-/escope-3.6.0.tgz#e01975e812781a163a6dadfdd80398dc64c889c3"
+  dependencies:
+    es6-map "^0.1.3"
+    es6-weak-map "^2.0.1"
+    esrecurse "^4.1.0"
+    estraverse "^4.1.1"
+
+eslint-config-standard-jsx@3.3.0:
+  version "3.3.0"
+  resolved "https://registry.yarnpkg.com/eslint-config-standard-jsx/-/eslint-config-standard-jsx-3.3.0.tgz#cab0801a15a360bf63facb97ab22fbdd88d8a5e0"
+
+eslint-config-standard@10.0.0:
+  version "10.0.0"
+  resolved "https://registry.yarnpkg.com/eslint-config-standard/-/eslint-config-standard-10.0.0.tgz#29f3625eafc490b89592506d25e3f4477770b973"
+
+eslint-import-resolver-node@^0.2.0:
+  version "0.2.3"
+  resolved "https://registry.yarnpkg.com/eslint-import-resolver-node/-/eslint-import-resolver-node-0.2.3.tgz#5add8106e8c928db2cba232bcd9efa846e3da16c"
+  dependencies:
+    debug "^2.2.0"
+    object-assign "^4.0.1"
+    resolve "^1.1.6"
+
+eslint-module-utils@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/eslint-module-utils/-/eslint-module-utils-2.0.0.tgz#a6f8c21d901358759cdc35dbac1982ae1ee58bce"
+  dependencies:
+    debug "2.2.0"
+    pkg-dir "^1.0.0"
+
+eslint-plugin-import@~2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-import/-/eslint-plugin-import-2.2.0.tgz#72ba306fad305d67c4816348a4699a4229ac8b4e"
+  dependencies:
+    builtin-modules "^1.1.1"
+    contains-path "^0.1.0"
+    debug "^2.2.0"
+    doctrine "1.5.0"
+    eslint-import-resolver-node "^0.2.0"
+    eslint-module-utils "^2.0.0"
+    has "^1.0.1"
+    lodash.cond "^4.3.0"
+    minimatch "^3.0.3"
+    pkg-up "^1.0.0"
+
+eslint-plugin-node@~4.2.2:
+  version "4.2.2"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-node/-/eslint-plugin-node-4.2.2.tgz#82959ca9aed79fcbd28bb1b188d05cac04fb3363"
+  dependencies:
+    ignore "^3.0.11"
+    minimatch "^3.0.2"
+    object-assign "^4.0.1"
+    resolve "^1.1.7"
+    semver "5.3.0"
+
+eslint-plugin-promise@~3.5.0:
+  version "3.5.0"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-promise/-/eslint-plugin-promise-3.5.0.tgz#78fbb6ffe047201627569e85a6c5373af2a68fca"
+
+eslint-plugin-react@~6.10.0:
+  version "6.10.3"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-react/-/eslint-plugin-react-6.10.3.tgz#c5435beb06774e12c7db2f6abaddcbf900cd3f78"
+  dependencies:
+    array.prototype.find "^2.0.1"
+    doctrine "^1.2.2"
+    has "^1.0.1"
+    jsx-ast-utils "^1.3.4"
+    object.assign "^4.0.4"
+
+eslint-plugin-standard@~2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-standard/-/eslint-plugin-standard-2.2.0.tgz#61273ddbab958ccc88d94d6bb5b2db63ffbd368e"
+
+eslint@~3.19.0:
+  version "3.19.0"
+  resolved "https://registry.yarnpkg.com/eslint/-/eslint-3.19.0.tgz#c8fc6201c7f40dd08941b87c085767386a679acc"
+  dependencies:
+    babel-code-frame "^6.16.0"
+    chalk "^1.1.3"
+    concat-stream "^1.5.2"
+    debug "^2.1.1"
+    doctrine "^2.0.0"
+    escope "^3.6.0"
+    espree "^3.4.0"
+    esquery "^1.0.0"
+    estraverse "^4.2.0"
+    esutils "^2.0.2"
+    file-entry-cache "^2.0.0"
+    glob "^7.0.3"
+    globals "^9.14.0"
+    ignore "^3.2.0"
+    imurmurhash "^0.1.4"
+    inquirer "^0.12.0"
+    is-my-json-valid "^2.10.0"
+    is-resolvable "^1.0.0"
+    js-yaml "^3.5.1"
+    json-stable-stringify "^1.0.0"
+    levn "^0.3.0"
+    lodash "^4.0.0"
+    mkdirp "^0.5.0"
+    natural-compare "^1.4.0"
+    optionator "^0.8.2"
+    path-is-inside "^1.0.1"
+    pluralize "^1.2.1"
+    progress "^1.1.8"
+    require-uncached "^1.0.2"
+    shelljs "^0.7.5"
+    strip-bom "^3.0.0"
+    strip-json-comments "~2.0.1"
+    table "^3.7.8"
+    text-table "~0.2.0"
+    user-home "^2.0.0"
+
+espree@^3.4.0:
+  version "3.4.1"
+  resolved "https://registry.yarnpkg.com/espree/-/espree-3.4.1.tgz#28a83ab4aaed71ed8fe0f5efe61b76a05c13c4d2"
+  dependencies:
+    acorn "^5.0.1"
+    acorn-jsx "^3.0.0"
+
+esprima@^3.1.1:
+  version "3.1.3"
+  resolved "https://registry.yarnpkg.com/esprima/-/esprima-3.1.3.tgz#fdca51cee6133895e3c88d535ce49dbff62a4633"
+
 esprima@~1.0.4:
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/esprima/-/esprima-1.0.4.tgz#9f557e08fc3b4d26ece9dd34f8fbf476b62585ad"
 
+esquery@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.0.0.tgz#cfba8b57d7fba93f17298a8a006a04cda13d80fa"
+  dependencies:
+    estraverse "^4.0.0"
+
+esrecurse@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.1.0.tgz#4713b6536adf7f2ac4f327d559e7756bff648220"
+  dependencies:
+    estraverse "~4.1.0"
+    object-assign "^4.0.1"
+
+estraverse@^4.0.0, estraverse@^4.1.1, estraverse@^4.2.0:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.2.0.tgz#0dee3fed31fcd469618ce7342099fc1afa0bdb13"
+
 estraverse@~1.5.0:
   version "1.5.1"
   resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-1.5.1.tgz#867a3e8e58a9f84618afb6c2ddbcd916b7cbaf71"
 
+estraverse@~4.1.0:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.1.1.tgz#f6caca728933a850ef90661d0e17982ba47111a2"
+
 esutils@^2.0.0, esutils@^2.0.2:
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.2.tgz#0abf4f1caa5bcb1f7a9d8acc6dea4faaa04bac9b"
@@ -1772,6 +2088,13 @@ ev-store@^7.0.0:
   dependencies:
     individual "^3.0.0"
 
+event-emitter@~0.3.5:
+  version "0.3.5"
+  resolved "https://registry.yarnpkg.com/event-emitter/-/event-emitter-0.3.5.tgz#df8c69eef1647923c7157b9ce83840610b02cc39"
+  dependencies:
+    d "1"
+    es5-ext "~0.10.14"
+
 eventemitter3@1.x.x:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-1.2.0.tgz#1c86991d816ad1e504750e73874224ecf3bec508"
@@ -1786,6 +2109,10 @@ evp_bytestokey@^1.0.0:
   dependencies:
     create-hash "^1.1.1"
 
+exit-hook@^1.0.0:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/exit-hook/-/exit-hook-1.1.1.tgz#f05ca233b48c05d54fff07765df8507e95c02ff8"
+
 expand-braces@^0.1.1:
   version "0.1.2"
   resolved "https://registry.yarnpkg.com/expand-braces/-/expand-braces-0.1.2.tgz#488b1d1d2451cb3d3a6b192cfc030f44c5855fea"
@@ -1860,6 +2187,10 @@ extsprintf@1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.0.2.tgz#e1080e0658e300b06294990cc70e1502235fd550"
 
+fast-levenshtein@~2.0.4:
+  version "2.0.6"
+  resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917"
+
 fbjs@^0.8.1, fbjs@^0.8.4:
   version "0.8.9"
   resolved "https://registry.yarnpkg.com/fbjs/-/fbjs-0.8.9.tgz#180247fbd347dcc9004517b904f865400a0c8f14"
@@ -1872,6 +2203,20 @@ fbjs@^0.8.1, fbjs@^0.8.4:
     setimmediate "^1.0.5"
     ua-parser-js "^0.7.9"
 
+figures@^1.3.5:
+  version "1.7.0"
+  resolved "https://registry.yarnpkg.com/figures/-/figures-1.7.0.tgz#cbe1e3affcf1cd44b80cadfed28dc793a9701d2e"
+  dependencies:
+    escape-string-regexp "^1.0.5"
+    object-assign "^4.1.0"
+
+file-entry-cache@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-2.0.0.tgz#c392990c3e684783d838b8c84a45d8a048458361"
+  dependencies:
+    flat-cache "^1.2.1"
+    object-assign "^4.0.1"
+
 filename-regex@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/filename-regex/-/filename-regex-2.0.0.tgz#996e3e80479b98b9897f15a8a58b3d084e926775"
@@ -1898,10 +2243,36 @@ finalhandler@1.0.0, finalhandler@~1.0.0:
     statuses "~1.3.1"
     unpipe "~1.0.0"
 
+find-root@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/find-root/-/find-root-1.0.0.tgz#962ff211aab25c6520feeeb8d6287f8f6e95807a"
+
+find-up@^1.0.0:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/find-up/-/find-up-1.1.2.tgz#6b2e9822b1a2ce0a60ab64d610eccad53cb24d0f"
+  dependencies:
+    path-exists "^2.0.0"
+    pinkie-promise "^2.0.0"
+
+find-up@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/find-up/-/find-up-2.1.0.tgz#45d1b7e506c717ddd482775a2b77920a3c0c57a7"
+  dependencies:
+    locate-path "^2.0.0"
+
 finished-promise@0.0.2:
   version "0.0.2"
   resolved "https://registry.yarnpkg.com/finished-promise/-/finished-promise-0.0.2.tgz#89316e0e2d9990c9f669a0d520aaf3a9df7188cb"
 
+flat-cache@^1.2.1:
+  version "1.2.2"
+  resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-1.2.2.tgz#fa86714e72c21db88601761ecf2f555d1abc6b96"
+  dependencies:
+    circular-json "^0.3.1"
+    del "^2.0.2"
+    graceful-fs "^4.1.2"
+    write "^0.2.1"
+
 for-in@^1.0.1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/for-in/-/for-in-1.0.2.tgz#81068d295a8142ec0ac726c6e2200c30fb6d5e80"
@@ -2000,6 +2371,20 @@ gauge@~2.7.1:
     strip-ansi "^3.0.1"
     wide-align "^1.1.0"
 
+generate-function@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/generate-function/-/generate-function-2.0.0.tgz#6858fe7c0969b7d4e9093337647ac79f60dfbe74"
+
+generate-object-property@^1.1.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/generate-object-property/-/generate-object-property-1.2.0.tgz#9c0e1c40308ce804f4783618b937fa88f99d50d0"
+  dependencies:
+    is-property "^1.0.0"
+
+get-stdin@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/get-stdin/-/get-stdin-5.0.1.tgz#122e161591e21ff4c52530305693f20e6393a398"
+
 getpass@^0.1.1:
   version "0.1.6"
   resolved "https://registry.yarnpkg.com/getpass/-/getpass-0.1.6.tgz#283ffd9fc1256840875311c1b60e8c40187110e6"
@@ -2030,7 +2415,7 @@ glob@7.0.5:
     once "^1.3.0"
     path-is-absolute "^1.0.0"
 
-glob@^7.0.0, glob@^7.0.5, glob@^7.1.0, glob@^7.1.1:
+glob@^7.0.0, glob@^7.0.3, glob@^7.0.5, glob@^7.1.0, glob@^7.1.1:
   version "7.1.1"
   resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.1.tgz#805211df04faaf1c63a3600306cdf5ade50b2ec8"
   dependencies:
@@ -2055,10 +2440,21 @@ global@^4.3.0, global@^4.3.1:
     min-document "^2.19.0"
     process "~0.5.1"
 
-globals@^9.0.0:
+globals@^9.0.0, globals@^9.14.0:
   version "9.16.0"
   resolved "https://registry.yarnpkg.com/globals/-/globals-9.16.0.tgz#63e903658171ec2d9f51b1d31de5e2b8dc01fb80"
 
+globby@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/globby/-/globby-5.0.0.tgz#ebd84667ca0dbb330b99bcfc68eac2bc54370e0d"
+  dependencies:
+    array-union "^1.0.1"
+    arrify "^1.0.0"
+    glob "^7.0.3"
+    object-assign "^4.0.1"
+    pify "^2.0.0"
+    pinkie-promise "^2.0.0"
+
 graceful-fs@^4.1.2, graceful-fs@^4.1.4:
   version "4.1.11"
   resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.1.11.tgz#0e8bdfe4d1ddb8854d64e04ea7c00e2a026e5658"
@@ -2255,10 +2651,18 @@ ieee754@^1.1.4:
   version "1.1.8"
   resolved "https://registry.yarnpkg.com/ieee754/-/ieee754-1.1.8.tgz#be33d40ac10ef1926701f6f08a2d86fbfd1ad3e4"
 
+ignore@^3.0.11, ignore@^3.0.9, ignore@^3.2.0:
+  version "3.2.6"
+  resolved "https://registry.yarnpkg.com/ignore/-/ignore-3.2.6.tgz#26e8da0644be0bb4cb39516f6c79f0e0f4ffe48c"
+
 immediate@~3.0.5:
   version "3.0.6"
   resolved "https://registry.yarnpkg.com/immediate/-/immediate-3.0.6.tgz#9db1dbd0faf8de6fbe0f5dd5e56bb606280de69b"
 
+imurmurhash@^0.1.4:
+  version "0.1.4"
+  resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea"
+
 indexof@0.0.1:
   version "0.0.1"
   resolved "https://registry.yarnpkg.com/indexof/-/indexof-0.0.1.tgz#82dc336d232b9062179d05ab3293a66059fd435d"
@@ -2292,6 +2696,24 @@ inline-source-map@~0.6.0:
   dependencies:
     source-map "~0.5.3"
 
+inquirer@^0.12.0:
+  version "0.12.0"
+  resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-0.12.0.tgz#1ef2bfd63504df0bc75785fff8c2c41df12f077e"
+  dependencies:
+    ansi-escapes "^1.1.0"
+    ansi-regex "^2.0.0"
+    chalk "^1.0.0"
+    cli-cursor "^1.0.1"
+    cli-width "^2.0.0"
+    figures "^1.3.5"
+    lodash "^4.3.0"
+    readline2 "^1.0.1"
+    run-async "^0.1.0"
+    rx-lite "^3.1.2"
+    string-width "^1.0.1"
+    strip-ansi "^3.0.0"
+    through "^2.3.6"
+
 insert-module-globals@^7.0.0:
   version "7.0.1"
   resolved "https://registry.yarnpkg.com/insert-module-globals/-/insert-module-globals-7.0.1.tgz#c03bf4e01cb086d5b5e5ace8ad0afe7889d638c3"
@@ -2305,6 +2727,10 @@ insert-module-globals@^7.0.0:
     through2 "^2.0.0"
     xtend "^4.0.0"
 
+interpret@^1.0.0:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/interpret/-/interpret-1.0.2.tgz#f4f623f0bb7122f15f5717c8e254b8161b5c5b2d"
+
 invariant@^2.2.0:
   version "2.2.2"
   resolved "https://registry.yarnpkg.com/invariant/-/invariant-2.2.2.tgz#9e1f56ac0acdb6bf303306f338be3b204ae60360"
@@ -2321,6 +2747,10 @@ is-accessor-descriptor@^0.1.6:
   dependencies:
     kind-of "^3.0.2"
 
+is-arrayish@^0.2.1:
+  version "0.2.1"
+  resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d"
+
 is-binary-path@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-1.0.1.tgz#75f16642b480f187a711c814161fd3a4a7655898"
@@ -2384,12 +2814,25 @@ is-fullwidth-code-point@^1.0.0:
   dependencies:
     number-is-nan "^1.0.0"
 
+is-fullwidth-code-point@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz#a3b30a5c4f199183167aaab93beefae3ddfb654f"
+
 is-glob@^2.0.0, is-glob@^2.0.1:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-2.0.1.tgz#d096f926a3ded5600f3fdfd91198cb0888c2d863"
   dependencies:
     is-extglob "^1.0.0"
 
+is-my-json-valid@^2.10.0:
+  version "2.16.0"
+  resolved "https://registry.yarnpkg.com/is-my-json-valid/-/is-my-json-valid-2.16.0.tgz#f079dd9bfdae65ee2038aae8acbc86ab109e3693"
+  dependencies:
+    generate-function "^2.0.0"
+    generate-object-property "^1.1.0"
+    jsonpointer "^4.0.0"
+    xtend "^4.0.0"
+
 is-node@^1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/is-node/-/is-node-1.0.2.tgz#d7d002745ef7debbb7477e988956ab0a4fccb653"
@@ -2408,6 +2851,22 @@ is-object@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/is-object/-/is-object-1.0.1.tgz#8952688c5ec2ffd6b03ecc85e769e02903083470"
 
+is-path-cwd@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/is-path-cwd/-/is-path-cwd-1.0.0.tgz#d225ec23132e89edd38fda767472e62e65f1106d"
+
+is-path-in-cwd@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/is-path-in-cwd/-/is-path-in-cwd-1.0.0.tgz#6477582b8214d602346094567003be8a9eac04dc"
+  dependencies:
+    is-path-inside "^1.0.0"
+
+is-path-inside@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-1.0.0.tgz#fc06e5a1683fbda13de667aff717bbc10a48f37f"
+  dependencies:
+    path-is-inside "^1.0.1"
+
 is-posix-bracket@^0.1.0:
   version "0.1.1"
   resolved "https://registry.yarnpkg.com/is-posix-bracket/-/is-posix-bracket-0.1.1.tgz#3334dc79774368e92f016e6fbc0a88f5cd6e6bc4"
@@ -2416,12 +2875,22 @@ is-primitive@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/is-primitive/-/is-primitive-2.0.0.tgz#207bab91638499c07b2adf240a41a87210034575"
 
+is-property@^1.0.0:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/is-property/-/is-property-1.0.2.tgz#57fe1c4e48474edd65b09911f26b1cd4095dda84"
+
 is-regex@^1.0.3:
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.0.4.tgz#5517489b547091b0930e095654ced25ee97e9491"
   dependencies:
     has "^1.0.1"
 
+is-resolvable@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/is-resolvable/-/is-resolvable-1.0.0.tgz#8df57c61ea2e3c501408d100fb013cf8d6e0cc62"
+  dependencies:
+    tryit "^1.0.1"
+
 is-stream@^1.0.1:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-1.1.0.tgz#12d4a3dd4e68e0b79ceb8dbc84173ae80d91ca44"
@@ -2485,6 +2954,13 @@ js-tokens@^3.0.0:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-3.0.1.tgz#08e9f132484a2c45a30907e9dc4d5567b7f114d7"
 
+js-yaml@^3.5.1:
+  version "3.8.3"
+  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.8.3.tgz#33a05ec481c850c8875929166fe1beb61c728766"
+  dependencies:
+    argparse "^1.0.7"
+    esprima "^3.1.1"
+
 jsbn@~0.1.0:
   version "0.1.1"
   resolved "https://registry.yarnpkg.com/jsbn/-/jsbn-0.1.1.tgz#a5e654c2e5a2deb5f201d96cefbca80c0ef2f513"
@@ -2501,7 +2977,7 @@ json-schema@0.2.3:
   version "0.2.3"
   resolved "https://registry.yarnpkg.com/json-schema/-/json-schema-0.2.3.tgz#b480c892e59a2f05954ce727bd3f2a4e882f9e13"
 
-json-stable-stringify@^1.0.1:
+json-stable-stringify@^1.0.0, json-stable-stringify@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/json-stable-stringify/-/json-stable-stringify-1.0.1.tgz#9a759d39c5f2ff503fd5300646ed445f88c4f9af"
   dependencies:
@@ -2533,6 +3009,10 @@ jsonparse@^1.2.0:
   version "1.3.0"
   resolved "https://registry.yarnpkg.com/jsonparse/-/jsonparse-1.3.0.tgz#85fc245b1d9259acc6941960b905adf64e7de0e8"
 
+jsonpointer@^4.0.0:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/jsonpointer/-/jsonpointer-4.0.1.tgz#4fd92cb34e0e9db3c89c8622ecf51f9b978c6cb9"
+
 jsprim@^1.2.2:
   version "1.3.1"
   resolved "https://registry.yarnpkg.com/jsprim/-/jsprim-1.3.1.tgz#2a7256f70412a29ee3670aaca625994c4dcff252"
@@ -2541,6 +3021,12 @@ jsprim@^1.2.2:
     json-schema "0.2.3"
     verror "1.3.6"
 
+jsx-ast-utils@^1.3.4:
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/jsx-ast-utils/-/jsx-ast-utils-1.4.0.tgz#5afe38868f56bc8cc7aeaef0100ba8c75bd12591"
+  dependencies:
+    object-assign "^4.1.0"
+
 karma-browserify@^5.1.1:
   version "5.1.1"
   resolved "https://registry.yarnpkg.com/karma-browserify/-/karma-browserify-5.1.1.tgz#f642d70d776d9ab3b73526c5732abcfea2400319"
@@ -2667,6 +3153,13 @@ lazy-cache@^2.0.2:
   dependencies:
     set-getter "^0.1.0"
 
+levn@^0.3.0, levn@~0.3.0:
+  version "0.3.0"
+  resolved "https://registry.yarnpkg.com/levn/-/levn-0.3.0.tgz#3b09924edf9f083c0490fdd4c0bc4421e04764ee"
+  dependencies:
+    prelude-ls "~1.1.2"
+    type-check "~0.3.2"
+
 lexical-scope@^1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/lexical-scope/-/lexical-scope-1.2.0.tgz#fcea5edc704a4b3a8796cdca419c3a0afaf22df4"
@@ -2679,6 +3172,22 @@ lie@3.1.1:
   dependencies:
     immediate "~3.0.5"
 
+load-json-file@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-2.0.0.tgz#7947e42149af80d696cbf797bcaabcfe1fe29ca8"
+  dependencies:
+    graceful-fs "^4.1.2"
+    parse-json "^2.2.0"
+    pify "^2.0.0"
+    strip-bom "^3.0.0"
+
+locate-path@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-2.0.0.tgz#2b568b265eec944c6d9c0de9c3dbbbca0354cd8e"
+  dependencies:
+    p-locate "^2.0.0"
+    path-exists "^3.0.0"
+
 lodash._baseassign@^3.0.0:
   version "3.2.0"
   resolved "https://registry.yarnpkg.com/lodash._baseassign/-/lodash._baseassign-3.2.0.tgz#8c38a099500f215ad09e59f1722fd0c52bfe0a4e"
@@ -2712,6 +3221,10 @@ lodash._root@^3.0.0:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/lodash._root/-/lodash._root-3.0.1.tgz#fba1c4524c19ee9a5f8136b4609f017cf4ded692"
 
+lodash.cond@^4.3.0:
+  version "4.5.2"
+  resolved "https://registry.yarnpkg.com/lodash.cond/-/lodash.cond-4.5.2.tgz#f471a1da486be60f6ab955d17115523dd1d255d5"
+
 lodash.create@3.1.1:
   version "3.1.1"
   resolved "https://registry.yarnpkg.com/lodash.create/-/lodash.create-3.1.1.tgz#d7f2849f0dbda7e04682bb8cd72ab022461debe7"
@@ -2750,7 +3263,7 @@ lodash@^3.10.1, lodash@^3.8.0:
   version "3.10.1"
   resolved "https://registry.yarnpkg.com/lodash/-/lodash-3.10.1.tgz#5bf45e8e49ba4189e17d482789dfd15bd140b7b6"
 
-lodash@^4.2.0, lodash@^4.5.0:
+lodash@^4.0.0, lodash@^4.2.0, lodash@^4.3.0, lodash@^4.5.0:
   version "4.17.4"
   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.4.tgz#78203a4d1c328ae1d86dca6460e369b57f4055ae"
 
@@ -2865,7 +3378,7 @@ minimalistic-crypto-utils@^1.0.0, minimalistic-crypto-utils@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz#f6c00c1c0b082246e5c4d99dfb8c7c083b2b582a"
 
-minimatch@^3.0.0, minimatch@^3.0.2:
+minimatch@^3.0.0, minimatch@^3.0.2, minimatch@^3.0.3:
   version "3.0.3"
   resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.3.tgz#2a4e4090b96b2db06a9d7df01055a62a77c9b774"
   dependencies:
@@ -2879,7 +3392,7 @@ minimist@1.2.0, minimist@^1.1.0, minimist@^1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.0.tgz#a35008b20f41383eec1fb914f4cd5df79a264284"
 
-mkdirp@0.5, mkdirp@0.5.1, "mkdirp@>=0.5 0", mkdirp@^0.5.1, mkdirp@~0.5.1:
+mkdirp@0.5, mkdirp@0.5.1, "mkdirp@>=0.5 0", mkdirp@^0.5.0, mkdirp@^0.5.1, mkdirp@~0.5.1:
   version "0.5.1"
   resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.1.tgz#30057438eac6cf7f8c4767f38648d6697d75c903"
   dependencies:
@@ -2943,6 +3456,10 @@ must@^0.13.4:
     lodash.wrap ">= 3 < 4"
     oolong ">= 1.11.0 < 2"
 
+mute-stream@0.0.5:
+  version "0.0.5"
+  resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.5.tgz#8fbfabb0a98a253d3184331f9e8deb7372fac6c0"
+
 nan@^2.3.0:
   version "2.5.1"
   resolved "https://registry.yarnpkg.com/nan/-/nan-2.5.1.tgz#d5b01691253326a97a2bbee9e61c55d8d60351e2"
@@ -2951,6 +3468,10 @@ natives@^1.1.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/natives/-/natives-1.1.0.tgz#e9ff841418a6b2ec7a495e939984f78f163e6e31"
 
+natural-compare@^1.4.0:
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7"
+
 negotiator@0.6.1:
   version "0.6.1"
   resolved "https://registry.yarnpkg.com/negotiator/-/negotiator-0.6.1.tgz#2b327184e8992101177b28563fb5e7102acd0ca9"
@@ -3015,7 +3536,7 @@ object-assign@4.1.0:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.0.tgz#7a3b3d0e98063d43f4c03f2e8ae6cd51a86883a0"
 
-object-assign@^4.0.0, object-assign@^4.1.0:
+object-assign@^4.0.0, object-assign@^4.0.1, object-assign@^4.1.0:
   version "4.1.1"
   resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
 
@@ -3023,10 +3544,18 @@ object-component@0.0.3:
   version "0.0.3"
   resolved "https://registry.yarnpkg.com/object-component/-/object-component-0.0.3.tgz#f0c69aa50efc95b866c186f400a33769cb2f1291"
 
-object-keys@^1.0.8:
+object-keys@^1.0.10, object-keys@^1.0.8:
   version "1.0.11"
   resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.0.11.tgz#c54601778ad560f1142ce0e01bcca8b56d13426d"
 
+object.assign@^4.0.4:
+  version "4.0.4"
+  resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.0.4.tgz#b1c9cc044ef1b9fe63606fc141abbb32e14730cc"
+  dependencies:
+    define-properties "^1.1.2"
+    function-bind "^1.1.0"
+    object-keys "^1.0.10"
+
 object.omit@^2.0.0:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/object.omit/-/object.omit-2.0.1.tgz#1a9c744829f39dbb858c76ca3579ae2a54ebd1fa"
@@ -3052,6 +3581,10 @@ once@~1.3.3:
   dependencies:
     wrappy "1"
 
+onetime@^1.0.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/onetime/-/onetime-1.1.0.tgz#a1f7838f8314c516f05ecefcbc4ccfe04b4ed789"
+
 "oolong@>= 1.11.0 < 2":
   version "1.15.1"
   resolved "https://registry.yarnpkg.com/oolong/-/oolong-1.15.1.tgz#90bac9e7ce52f60906ab2228d9e2b115f1086cea"
@@ -3063,6 +3596,17 @@ optimist@^0.6.1:
     minimist "~0.0.1"
     wordwrap "~0.0.2"
 
+optionator@^0.8.2:
+  version "0.8.2"
+  resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.8.2.tgz#364c5e409d3f4d6301d6c0b4c05bba50180aeb64"
+  dependencies:
+    deep-is "~0.1.3"
+    fast-levenshtein "~2.0.4"
+    levn "~0.3.0"
+    prelude-ls "~1.1.2"
+    type-check "~0.3.2"
+    wordwrap "~1.0.0"
+
 options@>=0.0.5:
   version "0.0.6"
   resolved "https://registry.yarnpkg.com/options/-/options-0.0.6.tgz#ec22d312806bb53e731773e7cdaefcf1c643128f"
@@ -3101,6 +3645,16 @@ output-file-sync@^1.1.0:
   version "0.0.5"
   resolved "https://registry.yarnpkg.com/over/-/over-0.0.5.tgz#f29852e70fd7e25f360e013a8ec44c82aedb5708"
 
+p-limit@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-1.1.0.tgz#b07ff2d9a5d88bec806035895a2bab66a27988bc"
+
+p-locate@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-2.0.0.tgz#20a0103b222a70c8fd39cc2e580680f3dde5ec43"
+  dependencies:
+    p-limit "^1.1.0"
+
 pako@~0.2.0:
   version "0.2.9"
   resolved "https://registry.yarnpkg.com/pako/-/pako-0.2.9.tgz#f3f7522f4ef782348da8161bad9ecfd51bf83a75"
@@ -3143,6 +3697,12 @@ parse-glob@^3.0.4:
     is-extglob "^1.0.0"
     is-glob "^2.0.0"
 
+parse-json@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-2.2.0.tgz#f480f40434ef80741f8469099f8dea18f55a4dc9"
+  dependencies:
+    error-ex "^1.2.0"
+
 parsejson@0.0.1:
   version "0.0.1"
   resolved "https://registry.yarnpkg.com/parsejson/-/parsejson-0.0.1.tgz#9b10c6c0d825ab589e685153826de0a3ba278bcc"
@@ -3187,10 +3747,24 @@ path-browserify@~0.0.0:
   version "0.0.0"
   resolved "https://registry.yarnpkg.com/path-browserify/-/path-browserify-0.0.0.tgz#a0b870729aae214005b7d5032ec2cbbb0fb4451a"
 
+path-exists@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-2.1.0.tgz#0feb6c64f0fc518d9a754dd5efb62c7022761f4b"
+  dependencies:
+    pinkie-promise "^2.0.0"
+
+path-exists@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-3.0.0.tgz#ce0ebeaa5f78cb18925ea7d810d7b59b010fd515"
+
 path-is-absolute@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
 
+path-is-inside@^1.0.1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/path-is-inside/-/path-is-inside-1.0.2.tgz#365417dede44430d1c11af61027facf074bdfc53"
+
 path-parse@^1.0.5:
   version "1.0.5"
   resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.5.tgz#3c1adf871ea9cd6c9431b6ea2bd74a0ff055c4c1"
@@ -3213,6 +3787,55 @@ performance-now@^0.2.0:
   version "0.2.0"
   resolved "https://registry.yarnpkg.com/performance-now/-/performance-now-0.2.0.tgz#33ef30c5c77d4ea21c5a53869d91b56d8f2555e5"
 
+pify@^2.0.0:
+  version "2.3.0"
+  resolved "https://registry.yarnpkg.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c"
+
+pinkie-promise@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/pinkie-promise/-/pinkie-promise-2.0.1.tgz#2135d6dfa7a358c069ac9b178776288228450ffa"
+  dependencies:
+    pinkie "^2.0.0"
+
+pinkie@^2.0.0:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/pinkie/-/pinkie-2.0.4.tgz#72556b80cfa0d48a974e80e77248e80ed4f7f870"
+
+pkg-conf@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/pkg-conf/-/pkg-conf-2.0.0.tgz#071c87650403bccfb9c627f58751bfe47c067279"
+  dependencies:
+    find-up "^2.0.0"
+    load-json-file "^2.0.0"
+
+pkg-config@^1.1.0:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/pkg-config/-/pkg-config-1.1.1.tgz#557ef22d73da3c8837107766c52eadabde298fe4"
+  dependencies:
+    debug-log "^1.0.0"
+    find-root "^1.0.0"
+    xtend "^4.0.1"
+
+pkg-dir@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-1.0.0.tgz#7a4b508a8d5bb2d629d447056ff4e9c9314cf3d4"
+  dependencies:
+    find-up "^1.0.0"
+
+pkg-up@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/pkg-up/-/pkg-up-1.0.0.tgz#3e08fb461525c4421624a33b9f7e6d0af5b05a26"
+  dependencies:
+    find-up "^1.0.0"
+
+pluralize@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/pluralize/-/pluralize-1.2.1.tgz#d1a21483fd22bb41e58a12fa3421823140897c45"
+
+prelude-ls@~1.1.2:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.1.2.tgz#21932a549f5e52ffd9a827f570e04be62a97da54"
+
 preserve@^0.2.0:
   version "0.2.0"
   resolved "https://registry.yarnpkg.com/preserve/-/preserve-0.2.0.tgz#815ed1f6ebc65926f865b310c0713bcb3315ce4b"
@@ -3233,6 +3856,10 @@ process@~0.5.1:
   version "0.5.2"
   resolved "https://registry.yarnpkg.com/process/-/process-0.5.2.tgz#1638d8a8e34c2f440a91db95ab9aeb677fc185cf"
 
+progress@^1.1.8:
+  version "1.1.8"
+  resolved "https://registry.yarnpkg.com/progress/-/progress-1.1.8.tgz#e260c78f6161cdd9b0e56cc3e0a85de17c7a57be"
+
 promise@^7.1.1:
   version "7.1.1"
   resolved "https://registry.yarnpkg.com/promise/-/promise-7.1.1.tgz#489654c692616b8aa55b0724fa809bb7db49c5bf"
@@ -3408,6 +4035,20 @@ readdirp@^2.0.0:
     readable-stream "^2.0.2"
     set-immediate-shim "^1.0.1"
 
+readline2@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/readline2/-/readline2-1.0.1.tgz#41059608ffc154757b715d9989d199ffbf372e35"
+  dependencies:
+    code-point-at "^1.0.0"
+    is-fullwidth-code-point "^1.0.0"
+    mute-stream "0.0.5"
+
+rechoir@^0.6.2:
+  version "0.6.2"
+  resolved "https://registry.yarnpkg.com/rechoir/-/rechoir-0.6.2.tgz#85204b54dba82d5742e28c96756ef43af50e3384"
+  dependencies:
+    resolve "^1.1.6"
+
 regenerate@^1.2.1:
   version "1.3.2"
   resolved "https://registry.yarnpkg.com/regenerate/-/regenerate-1.3.2.tgz#d1941c67bad437e1be76433add5b385f95b19260"
@@ -3494,21 +4135,39 @@ request@^2.79.0:
     tunnel-agent "^0.6.0"
     uuid "^3.0.0"
 
+require-uncached@^1.0.2:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/require-uncached/-/require-uncached-1.0.3.tgz#4e0d56d6c9662fd31e43011c4b95aa49955421d3"
+  dependencies:
+    caller-path "^0.1.0"
+    resolve-from "^1.0.0"
+
 requires-port@1.x.x:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/requires-port/-/requires-port-1.0.0.tgz#925d2601d39ac485e091cf0da5c6e694dc3dcaff"
 
+resolve-from@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-1.0.1.tgz#26cbfe935d1aeeeabb29bc3fe5aeb01e93d44226"
+
 resolve@1.1.7:
   version "1.1.7"
   resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.1.7.tgz#203114d82ad2c5ed9e8e0411b3932875e889e97b"
 
-resolve@^1.1.3, resolve@^1.1.4, resolve@^1.1.6:
+resolve@^1.1.3, resolve@^1.1.4, resolve@^1.1.6, resolve@^1.1.7:
   version "1.3.2"
   resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.3.2.tgz#1f0442c9e0cbb8136e87b9305f932f46c7f28235"
   dependencies:
     path-parse "^1.0.5"
 
-rimraf@2, rimraf@^2.6.0:
+restore-cursor@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-1.0.1.tgz#34661f46886327fed2991479152252df92daa541"
+  dependencies:
+    exit-hook "^1.0.0"
+    onetime "^1.0.0"
+
+rimraf@2, rimraf@^2.2.8, rimraf@^2.6.0:
   version "2.6.1"
   resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.6.1.tgz#c2338ec643df7a1b7fe5c54fa86f57428a55f33d"
   dependencies:
@@ -3524,10 +4183,28 @@ ripemd160@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/ripemd160/-/ripemd160-1.0.1.tgz#93a4bbd4942bc574b69a8fa57c71de10ecca7d6e"
 
+run-async@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.yarnpkg.com/run-async/-/run-async-0.1.0.tgz#c8ad4a5e110661e402a7d21b530e009f25f8e389"
+  dependencies:
+    once "^1.3.0"
+
+run-parallel@^1.1.2:
+  version "1.1.6"
+  resolved "https://registry.yarnpkg.com/run-parallel/-/run-parallel-1.1.6.tgz#29003c9a2163e01e2d2dfc90575f2c6c1d61a039"
+
+rx-lite@^3.1.2:
+  version "3.1.2"
+  resolved "https://registry.yarnpkg.com/rx-lite/-/rx-lite-3.1.2.tgz#19ce502ca572665f3b647b10939f97fd1615f102"
+
 safe-buffer@^5.0.1:
   version "5.0.1"
   resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.0.1.tgz#d263ca54696cd8a306b5ca6551e92de57918fbe7"
 
+semver@5.3.0, semver@~5.3.0:
+  version "5.3.0"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-5.3.0.tgz#9b2ce5d3de02d17c6012ad326aa6b4d0cf54f94f"
+
 semver@~4.3.3:
   version "4.3.6"
   resolved "https://registry.yarnpkg.com/semver/-/semver-4.3.6.tgz#300bc6e0e86374f7ba61068b5b1ecd57fc6532da"
@@ -3536,10 +4213,6 @@ semver@~5.0.1:
   version "5.0.3"
   resolved "https://registry.yarnpkg.com/semver/-/semver-5.0.3.tgz#77466de589cd5d3c95f138aa78bc569a3cb5d27a"
 
-semver@~5.3.0:
-  version "5.3.0"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-5.3.0.tgz#9b2ce5d3de02d17c6012ad326aa6b4d0cf54f94f"
-
 send@0.15.1:
   version "0.15.1"
   resolved "https://registry.yarnpkg.com/send/-/send-0.15.1.tgz#8a02354c26e6f5cca700065f5f0cdeba90ec7b5f"
@@ -3621,6 +4294,14 @@ shell-quote@^1.4.2, shell-quote@^1.6.1:
     array-reduce "~0.0.0"
     jsonify "~0.0.0"
 
+shelljs@^0.7.5:
+  version "0.7.7"
+  resolved "https://registry.yarnpkg.com/shelljs/-/shelljs-0.7.7.tgz#b2f5c77ef97148f4b4f6e22682e10bba8667cff1"
+  dependencies:
+    glob "^7.0.0"
+    interpret "^1.0.0"
+    rechoir "^0.6.2"
+
 signal-exit@^3.0.0:
   version "3.0.2"
   resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.2.tgz#b5fdc08f1287ea1178628e415e25132b73646c6d"
@@ -3629,6 +4310,10 @@ slash@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/slash/-/slash-1.0.0.tgz#c41f2f6c39fc16d1cd17ad4b5d896114ae470d55"
 
+slice-ansi@0.0.4:
+  version "0.0.4"
+  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-0.0.4.tgz#edbf8903f66f7ce2f8eafd6ceed65e264c831b35"
+
 "slice-stream@>= 1.0.0 < 2":
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/slice-stream/-/slice-stream-1.0.0.tgz#5b33bd66f013b1a7f86460b03d463dec39ad3ea0"
@@ -3727,6 +4412,10 @@ source-map@~0.1.30:
   dependencies:
     amdefine ">=0.0.4"
 
+sprintf-js@~1.0.2:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
+
 sshpk@^1.7.0:
   version "1.11.0"
   resolved "https://registry.yarnpkg.com/sshpk/-/sshpk-1.11.0.tgz#2d8d5ebb4a6fab28ffba37fa62a90f4a3ea59d77"
@@ -3742,6 +4431,29 @@ sshpk@^1.7.0:
     jsbn "~0.1.0"
     tweetnacl "~0.14.0"
 
+standard-engine@~7.0.0:
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/standard-engine/-/standard-engine-7.0.0.tgz#ebb77b9c8fc2c8165ffa353bd91ba0dff41af690"
+  dependencies:
+    deglob "^2.1.0"
+    get-stdin "^5.0.1"
+    minimist "^1.1.0"
+    pkg-conf "^2.0.0"
+
+standard@^10.0.0:
+  version "10.0.0"
+  resolved "https://registry.yarnpkg.com/standard/-/standard-10.0.0.tgz#913c77df56c294d9c4dff60dce6f307b2c779d0f"
+  dependencies:
+    eslint "~3.19.0"
+    eslint-config-standard "10.0.0"
+    eslint-config-standard-jsx "3.3.0"
+    eslint-plugin-import "~2.2.0"
+    eslint-plugin-node "~4.2.2"
+    eslint-plugin-promise "~3.5.0"
+    eslint-plugin-react "~6.10.0"
+    eslint-plugin-standard "~2.2.0"
+    standard-engine "~7.0.0"
+
 "statuses@>= 1.3.1 < 2", statuses@~1.3.1:
   version "1.3.1"
   resolved "https://registry.yarnpkg.com/statuses/-/statuses-1.3.1.tgz#faf51b9eb74aaef3b3acf4ad5f61abf24cb7b93e"
@@ -3789,6 +4501,13 @@ string-width@^1.0.1:
     is-fullwidth-code-point "^1.0.0"
     strip-ansi "^3.0.0"
 
+string-width@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-2.0.0.tgz#635c5436cc72a6e0c387ceca278d4e2eec52687e"
+  dependencies:
+    is-fullwidth-code-point "^2.0.0"
+    strip-ansi "^3.0.0"
+
 string_decoder@~0.10.0, string_decoder@~0.10.x:
   version "0.10.31"
   resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-0.10.31.tgz#62e203bc41766c6c28c9fc84301dab1c5310fa94"
@@ -3803,6 +4522,10 @@ strip-ansi@^3.0.0, strip-ansi@^3.0.1:
   dependencies:
     ansi-regex "^2.0.0"
 
+strip-bom@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-3.0.0.tgz#2334c18e9c759f7bdd56fdef7e9ae3d588e68ed3"
+
 strip-json-comments@~2.0.1:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz#3c531942e908c2697c0ec344858c286c7ca0a60a"
@@ -3829,6 +4552,17 @@ syntax-error@^1.1.1:
   dependencies:
     acorn "^4.0.3"
 
+table@^3.7.8:
+  version "3.8.3"
+  resolved "https://registry.yarnpkg.com/table/-/table-3.8.3.tgz#2bbc542f0fda9861a755d3947fefd8b3f513855f"
+  dependencies:
+    ajv "^4.7.0"
+    ajv-keywords "^1.0.0"
+    chalk "^1.1.1"
+    lodash "^4.0.0"
+    slice-ansi "0.0.4"
+    string-width "^2.0.0"
+
 tar-pack@~3.3.0:
   version "3.3.0"
   resolved "https://registry.yarnpkg.com/tar-pack/-/tar-pack-3.3.0.tgz#30931816418f55afc4d21775afdd6720cee45dae"
@@ -3850,6 +4584,10 @@ tar@~2.2.1:
     fstream "^1.0.2"
     inherits "2"
 
+text-table@~0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/text-table/-/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4"
+
 through2@^2.0.0:
   version "2.0.3"
   resolved "https://registry.yarnpkg.com/through2/-/through2-2.0.3.tgz#0004569b37c7c74ba39c43f3ced78d1ad94140be"
@@ -3857,7 +4595,7 @@ through2@^2.0.0:
     readable-stream "^2.1.5"
     xtend "~4.0.1"
 
-"through@>=2.2.7 <3", through@X.X.X, through@~2.3.4:
+"through@>=2.2.7 <3", through@X.X.X, through@^2.3.6, through@~2.3.4:
   version "2.3.8"
   resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5"
 
@@ -3903,6 +4641,10 @@ trim-right@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/trim-right/-/trim-right-1.0.1.tgz#cb2e1203067e0c8de1f614094b9fe45704ea6003"
 
+tryit@^1.0.1:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/tryit/-/tryit-1.0.3.tgz#393be730a9446fd1ead6da59a014308f36c289cb"
+
 trytryagain@1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/trytryagain/-/trytryagain-1.2.0.tgz#5be62b5c9c2622a58d47de4271c120554dd09212"
@@ -3921,6 +4663,12 @@ tweetnacl@^0.14.3, tweetnacl@~0.14.0:
   version "0.14.5"
   resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-0.14.5.tgz#5ae68177f192d4456269d108afa93ff8743f4f64"
 
+type-check@~0.3.2:
+  version "0.3.2"
+  resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.3.2.tgz#5884cab512cf1d355e3fb784f30804b2b520db72"
+  dependencies:
+    prelude-ls "~1.1.2"
+
 type-detect@0.1.1:
   version "0.1.1"
   resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-0.1.1.tgz#0ba5ec2a885640e470ea4e8505971900dac58822"
@@ -3960,6 +4708,10 @@ underscore@1.8.3:
   version "1.8.3"
   resolved "https://registry.yarnpkg.com/underscore/-/underscore-1.8.3.tgz#4f3fb53b106e6097fcf9cb4109f2a5e9bdfa5022"
 
+uniq@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/uniq/-/uniq-1.0.1.tgz#b31c5ae8254844a3a8281541ce2b04b865a734ff"
+
 unpipe@1.0.0, unpipe@~1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/unpipe/-/unpipe-1.0.0.tgz#b2bf4ee8514aae6165b4817829d21b2ef49904ec"
@@ -3986,6 +4738,12 @@ user-home@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/user-home/-/user-home-1.1.1.tgz#2b5be23a32b63a7c9deb8d0f28d485724a3df190"
 
+user-home@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/user-home/-/user-home-2.0.0.tgz#9c70bfd8169bc1dcbf48604e0f04b8b49cde9e9f"
+  dependencies:
+    os-homedir "^1.0.0"
+
 useragent@^2.1.12:
   version "2.1.13"
   resolved "https://registry.yarnpkg.com/useragent/-/useragent-2.1.13.tgz#bba43e8aa24d5ceb83c2937473e102e21df74c10"
@@ -4105,10 +4863,20 @@ wordwrap@~0.0.2:
   version "0.0.3"
   resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-0.0.3.tgz#a3d5da6cd5c0bc0008d37234bbaf1bed63059107"
 
+wordwrap@~1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-1.0.0.tgz#27584810891456a4171c8d0226441ade90cbcaeb"
+
 wrappy@1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
 
+write@^0.2.1:
+  version "0.2.1"
+  resolved "https://registry.yarnpkg.com/write/-/write-0.2.1.tgz#5fc03828e264cea3fe91455476f7a3c566cb0757"
+  dependencies:
+    mkdirp "^0.5.1"
+
 ws@1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/ws/-/ws-1.0.1.tgz#7d0b2a2e58cddd819039c29c9de65045e1b310e9"
@@ -4143,7 +4911,7 @@ xmlhttprequest-ssl@1.5.3:
   version "1.5.3"
   resolved "https://registry.yarnpkg.com/xmlhttprequest-ssl/-/xmlhttprequest-ssl-1.5.3.tgz#185a888c04eca46c3e4070d99f7b49de3528992d"
 
-xtend@^4.0.0, xtend@~4.0.0, xtend@~4.0.1:
+xtend@^4.0.0, xtend@^4.0.1, xtend@~4.0.0, xtend@~4.0.1:
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.1.tgz#a5c6d532be656e23db820efb943a1f04998d63af"