diff --git a/index.js b/index.js
index efb0599..acae773 100644
--- a/index.js
+++ b/index.js
@@ -1,10 +1,10 @@
-var assert = require('assert')
-var morph = require('./lib/morph')
+var assert = require('assert').strict;
+var morph = require('./lib/morph');
 
-var TEXT_NODE = 3
+var TEXT_NODE = 3;
 // var DEBUG = false
 
-module.exports = nanomorph
+(module.exports = nanomorph).default = nanomorph;
 
 // Morph one tree into another tree
 //
@@ -27,11 +27,11 @@ function nanomorph (oldTree, newTree) {
   //   newTree && newTree.outerHTML
   // )
   // }
-  assert.equal(typeof oldTree, 'object', 'nanomorph: oldTree should be an object')
-  assert.equal(typeof newTree, 'object', 'nanomorph: newTree should be an object')
-  var tree = walk(newTree, oldTree)
+  assert.equal(typeof oldTree, 'object', 'nanomorph: oldTree should be an object');
+  assert.equal(typeof newTree, 'object', 'nanomorph: newTree should be an object');
+  var tree = walk(newTree, oldTree);
   // if (DEBUG) console.log('=> morphed\n  %s', tree.outerHTML)
-  return tree
+  return tree;
 }
 
 // Walk and morph a dom tree
@@ -44,17 +44,17 @@ function walk (newNode, oldNode) {
   // )
   // }
   if (!oldNode) {
-    return newNode
+    return newNode;
   } else if (!newNode) {
-    return null
+    return null;
   } else if (newNode.isSameNode && newNode.isSameNode(oldNode)) {
-    return oldNode
+    return oldNode;
   } else if (newNode.tagName !== oldNode.tagName) {
-    return newNode
+    return newNode;
   } else {
-    morph(newNode, oldNode)
-    updateChildren(newNode, oldNode)
-    return oldNode
+    morph(newNode, oldNode);
+    updateChildren(newNode, oldNode);
+    return oldNode;
   }
 }
 
@@ -68,14 +68,14 @@ function updateChildren (newNode, oldNode) {
   //   newNode && newNode.outerHTML
   // )
   // }
-  var oldChild, newChild, morphed, oldMatch
+  var oldChild, newChild, morphed, oldMatch;
 
   // The offset is only ever increased, and used for [i - offset] in the loop
-  var offset = 0
+  var offset = 0;
 
   for (var i = 0; ; i++) {
-    oldChild = oldNode.childNodes[i]
-    newChild = newNode.childNodes[i - offset]
+    oldChild = oldNode.childNodes[i];
+    newChild = newNode.childNodes[i - offset];
     // if (DEBUG) {
     //   console.log(
     //   '===\n- old\n  %s\n- new\n  %s',
@@ -85,65 +85,65 @@ function updateChildren (newNode, oldNode) {
     // }
     // Both nodes are empty, do nothing
     if (!oldChild && !newChild) {
-      break
+      break;
 
     // There is no new child, remove old
     } else if (!newChild) {
-      oldNode.removeChild(oldChild)
-      i--
+      oldNode.removeChild(oldChild);
+      i--;
 
     // There is no old child, add new
     } else if (!oldChild) {
-      oldNode.appendChild(newChild)
-      offset++
+      oldNode.appendChild(newChild);
+      offset++;
 
     // Both nodes are the same, morph
     } else if (same(newChild, oldChild)) {
-      morphed = walk(newChild, oldChild)
+      morphed = walk(newChild, oldChild);
       if (morphed !== oldChild) {
-        oldNode.replaceChild(morphed, oldChild)
-        offset++
+        oldNode.replaceChild(morphed, oldChild);
+        offset++;
       }
 
     // Both nodes do not share an ID or a placeholder, try reorder
     } else {
-      oldMatch = null
+      oldMatch = null;
 
       // Try and find a similar node somewhere in the tree
       for (var j = i; j < oldNode.childNodes.length; j++) {
         if (same(oldNode.childNodes[j], newChild)) {
-          oldMatch = oldNode.childNodes[j]
-          break
+          oldMatch = oldNode.childNodes[j];
+          break;
         }
       }
 
       // If there was a node with the same ID or placeholder in the old list
       if (oldMatch) {
-        morphed = walk(newChild, oldMatch)
-        if (morphed !== oldMatch) offset++
-        oldNode.insertBefore(morphed, oldChild)
+        morphed = walk(newChild, oldMatch);
+        if (morphed !== oldMatch) offset++;
+        oldNode.insertBefore(morphed, oldChild);
 
       // It's safe to morph two nodes in-place if neither has an ID
       } else if (!newChild.id && !oldChild.id) {
-        morphed = walk(newChild, oldChild)
+        morphed = walk(newChild, oldChild);
         if (morphed !== oldChild) {
-          oldNode.replaceChild(morphed, oldChild)
-          offset++
+          oldNode.replaceChild(morphed, oldChild);
+          offset++;
         }
 
       // Insert the node at the index if we couldn't morph or find a matching node
       } else {
-        oldNode.insertBefore(newChild, oldChild)
-        offset++
+        oldNode.insertBefore(newChild, oldChild);
+        offset++;
       }
     }
   }
 }
 
 function same (a, b) {
-  if (a.id) return a.id === b.id
-  if (a.isSameNode) return a.isSameNode(b)
-  if (a.tagName !== b.tagName) return false
-  if (a.type === TEXT_NODE) return a.nodeValue === b.nodeValue
-  return false
+  if (a.id) return a.id === b.id;
+  if (a.isSameNode) return a.isSameNode(b);
+  if (a.tagName !== b.tagName) return false;
+  if (a.type === TEXT_NODE) return a.nodeValue === b.nodeValue;
+  return false;
 }
diff --git a/lib/events.js b/lib/events.js
index dea06fe..bbcff00 100644
--- a/lib/events.js
+++ b/lib/events.js
@@ -39,4 +39,4 @@ module.exports = [
   'oncontextmenu',
   'onfocusin',
   'onfocusout'
-]
+];
diff --git a/lib/morph.js b/lib/morph.js
index ccc20cf..1d982c6 100644
--- a/lib/morph.js
+++ b/lib/morph.js
@@ -1,68 +1,68 @@
-var events = require('./events')
-var eventsLength = events.length
+var events = require('./events');
+var eventsLength = events.length;
 
-var ELEMENT_NODE = 1
-var TEXT_NODE = 3
-var COMMENT_NODE = 8
+var ELEMENT_NODE = 1;
+var TEXT_NODE = 3;
+var COMMENT_NODE = 8;
 
-module.exports = morph
+module.exports = morph;
 
 // diff elements and apply the resulting patch to the old node
 // (obj, obj) -> null
 function morph (newNode, oldNode) {
-  var nodeType = newNode.nodeType
-  var nodeName = newNode.nodeName
+  var nodeType = newNode.nodeType;
+  var nodeName = newNode.nodeName;
 
   if (nodeType === ELEMENT_NODE) {
-    copyAttrs(newNode, oldNode)
+    copyAttrs(newNode, oldNode);
   }
 
   if (nodeType === TEXT_NODE || nodeType === COMMENT_NODE) {
     if (oldNode.nodeValue !== newNode.nodeValue) {
-      oldNode.nodeValue = newNode.nodeValue
+      oldNode.nodeValue = newNode.nodeValue;
     }
   }
 
   // Some DOM nodes are weird
   // https://github.com/patrick-steele-idem/morphdom/blob/master/src/specialElHandlers.js
-  if (nodeName === 'INPUT') updateInput(newNode, oldNode)
-  else if (nodeName === 'OPTION') updateOption(newNode, oldNode)
-  else if (nodeName === 'TEXTAREA') updateTextarea(newNode, oldNode)
+  if (nodeName === 'INPUT') updateInput(newNode, oldNode);
+  else if (nodeName === 'OPTION') updateOption(newNode, oldNode);
+  else if (nodeName === 'TEXTAREA') updateTextarea(newNode, oldNode);
 
-  copyEvents(newNode, oldNode)
+  copyEvents(newNode, oldNode);
 }
 
 function copyAttrs (newNode, oldNode) {
-  var oldAttrs = oldNode.attributes
-  var newAttrs = newNode.attributes
-  var attrNamespaceURI = null
-  var attrValue = null
-  var fromValue = null
-  var attrName = null
-  var attr = null
+  var oldAttrs = oldNode.attributes;
+  var newAttrs = newNode.attributes;
+  var attrNamespaceURI = null;
+  var attrValue = null;
+  var fromValue = null;
+  var attrName = null;
+  var attr = null;
 
   for (var i = newAttrs.length - 1; i >= 0; --i) {
-    attr = newAttrs[i]
-    attrName = attr.name
-    attrNamespaceURI = attr.namespaceURI
-    attrValue = attr.value
+    attr = newAttrs[i];
+    attrName = attr.name;
+    attrNamespaceURI = attr.namespaceURI;
+    attrValue = attr.value;
     if (attrNamespaceURI) {
-      attrName = attr.localName || attrName
-      fromValue = oldNode.getAttributeNS(attrNamespaceURI, attrName)
+      attrName = attr.localName || attrName;
+      fromValue = oldNode.getAttributeNS(attrNamespaceURI, attrName);
       if (fromValue !== attrValue) {
-        oldNode.setAttributeNS(attrNamespaceURI, attrName, attrValue)
+        oldNode.setAttributeNS(attrNamespaceURI, attrName, attrValue);
       }
     } else {
       if (!oldNode.hasAttribute(attrName)) {
-        oldNode.setAttribute(attrName, attrValue)
+        oldNode.setAttribute(attrName, attrValue);
       } else {
-        fromValue = oldNode.getAttribute(attrName)
+        fromValue = oldNode.getAttribute(attrName);
         if (fromValue !== attrValue) {
           // apparently values are always cast to strings, ah well
           if (attrValue === 'null' || attrValue === 'undefined') {
-            oldNode.removeAttribute(attrName)
+            oldNode.removeAttribute(attrName);
           } else {
-            oldNode.setAttribute(attrName, attrValue)
+            oldNode.setAttribute(attrName, attrValue);
           }
         }
       }
@@ -72,19 +72,19 @@ function copyAttrs (newNode, oldNode) {
   // Remove any extra attributes found on the original DOM element that
   // weren't found on the target element.
   for (var j = oldAttrs.length - 1; j >= 0; --j) {
-    attr = oldAttrs[j]
+    attr = oldAttrs[j];
     if (attr.specified !== false) {
-      attrName = attr.name
-      attrNamespaceURI = attr.namespaceURI
+      attrName = attr.name;
+      attrNamespaceURI = attr.namespaceURI;
 
       if (attrNamespaceURI) {
-        attrName = attr.localName || attrName
+        attrName = attr.localName || attrName;
         if (!newNode.hasAttributeNS(attrNamespaceURI, attrName)) {
-          oldNode.removeAttributeNS(attrNamespaceURI, attrName)
+          oldNode.removeAttributeNS(attrNamespaceURI, attrName);
         }
       } else {
         if (!newNode.hasAttributeNS(null, attrName)) {
-          oldNode.removeAttribute(attrName)
+          oldNode.removeAttribute(attrName);
         }
       }
     }
@@ -93,17 +93,17 @@ function copyAttrs (newNode, oldNode) {
 
 function copyEvents (newNode, oldNode) {
   for (var i = 0; i < eventsLength; i++) {
-    var ev = events[i]
-    if (newNode[ev]) {           // if new element has a whitelisted attribute
-      oldNode[ev] = newNode[ev]  // update existing element
-    } else if (oldNode[ev]) {    // if existing element has it and new one doesnt
-      oldNode[ev] = undefined    // remove it from existing element
+    var ev = events[i];
+    if (newNode[ev]) { // if new element has a whitelisted attribute
+      oldNode[ev] = newNode[ev]; // update existing element
+    } else if (oldNode[ev]) { // if existing element has it and new one doesnt
+      oldNode[ev] = undefined; // remove it from existing element
     }
   }
 }
 
 function updateOption (newNode, oldNode) {
-  updateAttribute(newNode, oldNode, 'selected')
+  updateAttribute(newNode, oldNode, 'selected');
 }
 
 // The "value" attribute is special for the <input> element since it sets the
@@ -111,54 +111,54 @@ function updateOption (newNode, oldNode) {
 // property will have no effect since it is only used to the set the initial
 // value. Similar for the "checked" attribute, and "disabled".
 function updateInput (newNode, oldNode) {
-  var newValue = newNode.value
-  var oldValue = oldNode.value
+  var newValue = newNode.value;
+  var oldValue = oldNode.value;
 
-  updateAttribute(newNode, oldNode, 'checked')
-  updateAttribute(newNode, oldNode, 'disabled')
+  updateAttribute(newNode, oldNode, 'checked');
+  updateAttribute(newNode, oldNode, 'disabled');
 
   if (newValue !== oldValue) {
-    oldNode.setAttribute('value', newValue)
-    oldNode.value = newValue
+    oldNode.setAttribute('value', newValue);
+    oldNode.value = newValue;
   }
 
   if (newValue === 'null') {
-    oldNode.value = ''
-    oldNode.removeAttribute('value')
+    oldNode.value = '';
+    oldNode.removeAttribute('value');
   }
 
   if (!newNode.hasAttributeNS(null, 'value')) {
-    oldNode.removeAttribute('value')
+    oldNode.removeAttribute('value');
   } else if (oldNode.type === 'range') {
     // this is so elements like slider move their UI thingy
-    oldNode.value = newValue
+    oldNode.value = newValue;
   }
 }
 
 function updateTextarea (newNode, oldNode) {
-  var newValue = newNode.value
+  var newValue = newNode.value;
   if (newValue !== oldNode.value) {
-    oldNode.value = newValue
+    oldNode.value = newValue;
   }
 
   if (oldNode.firstChild && oldNode.firstChild.nodeValue !== newValue) {
     // Needed for IE. Apparently IE sets the placeholder as the
     // node value and vise versa. This ignores an empty update.
     if (newValue === '' && oldNode.firstChild.nodeValue === oldNode.placeholder) {
-      return
+      return;
     }
 
-    oldNode.firstChild.nodeValue = newValue
+    oldNode.firstChild.nodeValue = newValue;
   }
 }
 
 function updateAttribute (newNode, oldNode, name) {
   if (newNode[name] !== oldNode[name]) {
-    oldNode[name] = newNode[name]
+    oldNode[name] = newNode[name];
     if (newNode[name]) {
-      oldNode.setAttribute(name, '')
+      oldNode.setAttribute(name, '');
     } else {
-      oldNode.removeAttribute(name)
+      oldNode.removeAttribute(name);
     }
   }
 }
diff --git a/test/diff.js b/test/diff.js
index 0fda9fd..66b34bf 100644
--- a/test/diff.js
+++ b/test/diff.js
@@ -1,273 +1,273 @@
-var tape = require('tape')
-var html = require('bel')
-var nanomorph = require('../')
+var tape = require('tape');
+var html = require('bel');
+var nanomorph = require('../');
 
-module.exports = abstractMorph
+module.exports = abstractMorph;
 
 function abstractMorph (morph) {
   tape('abstract morph', function (t) {
     t.test('root level', function (t) {
       t.test('should replace a node', function (t) {
-        t.plan(1)
-        var a = html`<p>hello world</p>`
-        var b = html`<div>hello world</div>`
-        var expected = b.outerHTML
-        var res = morph(a, b)
-        t.equal(res.outerHTML, expected, 'result was expected')
-      })
+        t.plan(1);
+        var a = html`<p>hello world</p>`;
+        var b = html`<div>hello world</div>`;
+        var expected = b.outerHTML;
+        var res = morph(a, b);
+        t.equal(res.outerHTML, expected, 'result was expected');
+      });
 
       t.test('should morph a node', function (t) {
-        t.plan(1)
-        var a = html`<p>hello world</p>`
-        var b = html`<p>hello you</p>`
-        var expected = b.outerHTML
-        var res = morph(a, b)
-        t.equal(res.outerHTML, expected, 'result was expected')
-      })
+        t.plan(1);
+        var a = html`<p>hello world</p>`;
+        var b = html`<p>hello you</p>`;
+        var expected = b.outerHTML;
+        var res = morph(a, b);
+        t.equal(res.outerHTML, expected, 'result was expected');
+      });
 
       t.test('should morph a node with namespaced attribute', function (t) {
-        t.plan(1)
-        var a = html`<svg><use xlink:href="#heybooboo"></use></svg>`
-        var b = html`<svg><use xlink:href="#boobear"></use></svg>`
-        var expected = b.outerHTML
-        var res = morph(a, b)
-        t.equal(res.outerHTML, expected, 'result was expected')
-      })
+        t.plan(1);
+        var a = html`<svg><use xlink:href="#heybooboo"></use></svg>`;
+        var b = html`<svg><use xlink:href="#boobear"></use></svg>`;
+        var expected = b.outerHTML;
+        var res = morph(a, b);
+        t.equal(res.outerHTML, expected, 'result was expected');
+      });
 
       t.test('should ignore if node is same', function (t) {
-        t.plan(1)
-        var a = html`<p>hello world</p>`
-        var expected = a.outerHTML
-        var res = morph(a, a)
-        t.equal(res.outerHTML, expected, 'result was expected')
-      })
-    })
+        t.plan(1);
+        var a = html`<p>hello world</p>`;
+        var expected = a.outerHTML;
+        var res = morph(a, a);
+        t.equal(res.outerHTML, expected, 'result was expected');
+      });
+    });
 
     t.test('nested', function (t) {
       t.test('should replace a node', function (t) {
-        t.plan(1)
-        var a = html`<main><p>hello world</p></main>`
-        var b = html`<main><div>hello world</div></main>`
-        var expected = b.outerHTML
-        var res = morph(a, b)
-        t.equal(res.outerHTML, expected, 'result was expected')
-      })
+        t.plan(1);
+        var a = html`<main><p>hello world</p></main>`;
+        var b = html`<main><div>hello world</div></main>`;
+        var expected = b.outerHTML;
+        var res = morph(a, b);
+        t.equal(res.outerHTML, expected, 'result was expected');
+      });
 
       t.test('should replace a node', function (t) {
-        t.plan(1)
-        var a = html`<main><p>hello world</p></main>`
-        var b = html`<main><p>hello you</p></main>`
-        var expected = b.outerHTML
-        var res = morph(a, b)
-        t.equal(res.outerHTML, expected, 'result was expected')
-      })
+        t.plan(1);
+        var a = html`<main><p>hello world</p></main>`;
+        var b = html`<main><p>hello you</p></main>`;
+        var expected = b.outerHTML;
+        var res = morph(a, b);
+        t.equal(res.outerHTML, expected, 'result was expected');
+      });
 
       t.test('should replace a node', function (t) {
-        t.plan(1)
-        var a = html`<main><p>hello world</p></main>`
-        var res = morph(a, a)
-        var expected = a.outerHTML
-        t.equal(res.outerHTML, expected, 'result was expected')
-      })
+        t.plan(1);
+        var a = html`<main><p>hello world</p></main>`;
+        var res = morph(a, a);
+        var expected = a.outerHTML;
+        t.equal(res.outerHTML, expected, 'result was expected');
+      });
 
       t.test('should append a node', function (t) {
-        t.plan(1)
-        var a = html`<main></main>`
-        var b = html`<main><p>hello you</p></main>`
-        var expected = b.outerHTML
-        var res = morph(a, b)
-        t.equal(res.outerHTML, expected, 'result was expected')
-      })
+        t.plan(1);
+        var a = html`<main></main>`;
+        var b = html`<main><p>hello you</p></main>`;
+        var expected = b.outerHTML;
+        var res = morph(a, b);
+        t.equal(res.outerHTML, expected, 'result was expected');
+      });
 
       t.test('should remove a node', function (t) {
-        t.plan(1)
-        var a = html`<main><p>hello you</p></main>`
-        var b = html`<main></main>`
-        var expected = b.outerHTML
-        var res = morph(a, b)
-        t.equal(res.outerHTML, expected, 'result was expected')
-      })
-    })
+        t.plan(1);
+        var a = html`<main><p>hello you</p></main>`;
+        var b = html`<main></main>`;
+        var expected = b.outerHTML;
+        var res = morph(a, b);
+        t.equal(res.outerHTML, expected, 'result was expected');
+      });
+    });
 
     t.test('values', function (t) {
       t.test('if new tree has no value and old tree does, remove value', function (t) {
-        t.plan(4)
-        var a = html`<input type="text" value="howdy" />`
-        var b = html`<input type="text" />`
-        var res = morph(a, b)
-        t.equal(res.getAttribute('value'), null)
-        t.equal(res.value, '')
-
-        a = html`<input type="text" value="howdy" />`
-        b = html`<input type="text" value=${null} />`
-        res = morph(a, b)
-        t.equal(res.getAttribute('value'), null)
-        t.equal(res.value, '')
-      })
+        t.plan(4);
+        var a = html`<input type="text" value="howdy" />`;
+        var b = html`<input type="text" />`;
+        var res = morph(a, b);
+        t.equal(res.getAttribute('value'), null);
+        t.equal(res.value, '');
+
+        a = html`<input type="text" value="howdy" />`;
+        b = html`<input type="text" value=${null} />`;
+        res = morph(a, b);
+        t.equal(res.getAttribute('value'), null);
+        t.equal(res.value, '');
+      });
 
       t.test('if new tree has value and old tree does too, set value from new tree', function (t) {
-        t.plan(4)
-        var a = html`<input type="text" value="howdy" />`
-        var b = html`<input type="text" value="hi" />`
-        var res = morph(a, b)
-        t.equal(res.value, 'hi')
-
-        a = html`<input type="text"/>`
-        a.value = 'howdy'
-        b = html`<input type="text"/>`
-        b.value = 'hi'
-        res = morph(a, b)
-        t.equal(res.value, 'hi')
-
-        a = html`<input type="text" value="howdy"/>`
-        b = html`<input type="text"/>`
-        b.value = 'hi'
-        res = morph(a, b)
-        t.equal(res.value, 'hi')
-
-        a = html`<input type="text"/>`
-        a.value = 'howdy'
-        b = html`<input type="text" value="hi"/>`
-        res = morph(a, b)
-        t.equal(res.value, 'hi')
-      })
-    })
+        t.plan(4);
+        var a = html`<input type="text" value="howdy" />`;
+        var b = html`<input type="text" value="hi" />`;
+        var res = morph(a, b);
+        t.equal(res.value, 'hi');
+
+        a = html`<input type="text"/>`;
+        a.value = 'howdy';
+        b = html`<input type="text"/>`;
+        b.value = 'hi';
+        res = morph(a, b);
+        t.equal(res.value, 'hi');
+
+        a = html`<input type="text" value="howdy"/>`;
+        b = html`<input type="text"/>`;
+        b.value = 'hi';
+        res = morph(a, b);
+        t.equal(res.value, 'hi');
+
+        a = html`<input type="text"/>`;
+        a.value = 'howdy';
+        b = html`<input type="text" value="hi"/>`;
+        res = morph(a, b);
+        t.equal(res.value, 'hi');
+      });
+    });
 
     t.test('isSameNode', function (t) {
       t.test('should return a if true', function (t) {
-        t.plan(1)
-        var a = html`<div>YOLO</div>`
-        var b = html`<div>FOMO</div>`
+        t.plan(1);
+        var a = html`<div>YOLO</div>`;
+        var b = html`<div>FOMO</div>`;
         b.isSameNode = function (el) {
-          return true
-        }
-        var res = morph(a, b)
-        t.equal(res.childNodes[0].data, 'YOLO')
-      })
+          return true;
+        };
+        var res = morph(a, b);
+        t.equal(res.childNodes[0].data, 'YOLO');
+      });
 
       t.test('should return b if false', function (t) {
-        t.plan(1)
-        var a = html`<div>YOLO</div>`
-        var b = html`<div>FOMO</div>`
+        t.plan(1);
+        var a = html`<div>YOLO</div>`;
+        var b = html`<div>FOMO</div>`;
         b.isSameNode = function (el) {
-          return false
-        }
-        var res = morph(a, b)
-        t.equal(res.childNodes[0].data, 'FOMO')
-      })
-    })
+          return false;
+        };
+        var res = morph(a, b);
+        t.equal(res.childNodes[0].data, 'FOMO');
+      });
+    });
 
     t.test('lists', function (t) {
       t.test('should append nodes', function (t) {
-        t.plan(1)
-        var a = html`<ul></ul>`
-        var b = html`<ul><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li></ul>`
-        var expected = b.outerHTML
-        var res = morph(a, b)
-        t.equal(res.outerHTML, expected, 'result was expected')
-      })
+        t.plan(1);
+        var a = html`<ul></ul>`;
+        var b = html`<ul><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li></ul>`;
+        var expected = b.outerHTML;
+        var res = morph(a, b);
+        t.equal(res.outerHTML, expected, 'result was expected');
+      });
 
       t.test('should remove nodes', function (t) {
-        t.plan(1)
-        var a = html`<ul><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li></ul>`
-        var b = html`<ul></ul>`
-        var res = morph(a, b)
-        var expected = b.outerHTML
-        t.equal(res.outerHTML, expected, 'result was expected')
-      })
-    })
+        t.plan(1);
+        var a = html`<ul><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li></ul>`;
+        var b = html`<ul></ul>`;
+        var res = morph(a, b);
+        var expected = b.outerHTML;
+        t.equal(res.outerHTML, expected, 'result was expected');
+      });
+    });
 
     t.test('selectables', function (t) {
       t.test('should append nodes', function (t) {
-        t.plan(1)
-        var a = html`<select></select>`
-        var b = html`<select><option>1</option><option>2</option><option>3</option><option>4</option></select>`
-        var expected = b.outerHTML
-        var res = morph(a, b)
-        t.equal(res.outerHTML, expected, 'result was expected')
-      })
+        t.plan(1);
+        var a = html`<select></select>`;
+        var b = html`<select><option>1</option><option>2</option><option>3</option><option>4</option></select>`;
+        var expected = b.outerHTML;
+        var res = morph(a, b);
+        t.equal(res.outerHTML, expected, 'result was expected');
+      });
 
       t.test('should append nodes (including optgroups)', function (t) {
-        t.plan(1)
-        var a = html`<select></select>`
-        var b = html`<select><optgroup><option>1</option><option>2</option></optgroup><option>3</option><option>4</option></select>`
-        var expected = b.outerHTML
-        var res = morph(a, b)
-        t.equal(res.outerHTML, expected, 'result was expected')
-      })
+        t.plan(1);
+        var a = html`<select></select>`;
+        var b = html`<select><optgroup><option>1</option><option>2</option></optgroup><option>3</option><option>4</option></select>`;
+        var expected = b.outerHTML;
+        var res = morph(a, b);
+        t.equal(res.outerHTML, expected, 'result was expected');
+      });
 
       t.test('should remove nodes', function (t) {
-        t.plan(1)
-        var a = html`<select><option>1</option><option>2</option><option>3</option><option>4</option></select>`
-        var b = html`<select></select>`
-        var expected = b.outerHTML
-        var res = morph(a, b)
-        t.equal(res.outerHTML, expected, 'result was expected')
-      })
+        t.plan(1);
+        var a = html`<select><option>1</option><option>2</option><option>3</option><option>4</option></select>`;
+        var b = html`<select></select>`;
+        var expected = b.outerHTML;
+        var res = morph(a, b);
+        t.equal(res.outerHTML, expected, 'result was expected');
+      });
 
       t.test('should remove nodes (including optgroups)', function (t) {
-        t.plan(1)
-        var a = html`<select><optgroup><option>1</option><option>2</option></optgroup><option>3</option><option>4</option></select>`
-        var b = html`<select></select>`
-        var expected = b.outerHTML
-        var res = morph(a, b)
-        t.equal(res.outerHTML, expected, 'result was expected')
-      })
+        t.plan(1);
+        var a = html`<select><optgroup><option>1</option><option>2</option></optgroup><option>3</option><option>4</option></select>`;
+        var b = html`<select></select>`;
+        var expected = b.outerHTML;
+        var res = morph(a, b);
+        t.equal(res.outerHTML, expected, 'result was expected');
+      });
 
       t.test('should add selected', function (t) {
-        t.plan(1)
-        var a = html`<select><option>1</option><option>2</option></select>`
-        var b = html`<select><option>1</option><option selected>2</option></select>`
-        var expected = b.outerHTML
-        var res = morph(a, b)
-        t.equal(res.outerHTML, expected, 'result was expected')
-      })
+        t.plan(1);
+        var a = html`<select><option>1</option><option>2</option></select>`;
+        var b = html`<select><option>1</option><option selected>2</option></select>`;
+        var expected = b.outerHTML;
+        var res = morph(a, b);
+        t.equal(res.outerHTML, expected, 'result was expected');
+      });
 
       t.test('should add selected (xhtml)', function (t) {
-        t.plan(1)
-        var a = html`<select><option>1</option><option>2</option></select>`
-        var b = html`<select><option>1</option><option selected="selected">2</option></select>`
-        var expected = b.outerHTML
-        var res = morph(a, b)
-        t.equal(res.outerHTML, expected, 'result was expected')
-      })
+        t.plan(1);
+        var a = html`<select><option>1</option><option>2</option></select>`;
+        var b = html`<select><option>1</option><option selected="selected">2</option></select>`;
+        var expected = b.outerHTML;
+        var res = morph(a, b);
+        t.equal(res.outerHTML, expected, 'result was expected');
+      });
 
       t.test('should switch selected', function (t) {
-        t.plan(1)
-        var a = html`<select><option selected="selected">1</option><option>2</option></select>`
-        var b = html`<select><option>1</option><option selected="selected">2</option></select>`
-        var expected = b.outerHTML
-        var res = morph(a, b)
-        t.equal(res.outerHTML, expected, 'result was expected')
-      })
-    })
+        t.plan(1);
+        var a = html`<select><option selected="selected">1</option><option>2</option></select>`;
+        var b = html`<select><option>1</option><option selected="selected">2</option></select>`;
+        var expected = b.outerHTML;
+        var res = morph(a, b);
+        t.equal(res.outerHTML, expected, 'result was expected');
+      });
+    });
 
     t.test('should replace nodes', function (t) {
-      t.plan(1)
-      var a = html`<ul><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li></ul>`
-      var b = html`<ul><div>1</div><li>2</li><p>3</p><li>4</li><li>5</li></ul>`
-      var expected = b.outerHTML
-      a = morph(a, b)
-      t.equal(a.outerHTML, expected, 'result was expected')
-    })
+      t.plan(1);
+      var a = html`<ul><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li></ul>`;
+      var b = html`<ul><div>1</div><li>2</li><p>3</p><li>4</li><li>5</li></ul>`;
+      var expected = b.outerHTML;
+      a = morph(a, b);
+      t.equal(a.outerHTML, expected, 'result was expected');
+    });
 
     t.test('should replace nodes after multiple iterations', function (t) {
-      t.plan(2)
+      t.plan(2);
 
-      var a = html`<ul></ul>`
-      var b = html`<ul><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li></ul>`
-      var expected = b.outerHTML
+      var a = html`<ul></ul>`;
+      var b = html`<ul><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li></ul>`;
+      var expected = b.outerHTML;
 
-      a = morph(a, b)
-      t.equal(a.outerHTML, expected, 'result was expected')
+      a = morph(a, b);
+      t.equal(a.outerHTML, expected, 'result was expected');
 
-      b = html`<ul><div>1</div><li>2</li><p>3</p><li>4</li><li>5</li></ul>`
-      expected = b.outerHTML
+      b = html`<ul><div>1</div><li>2</li><p>3</p><li>4</li><li>5</li></ul>`;
+      expected = b.outerHTML;
 
-      a = morph(a, b)
-      t.equal(a.outerHTML, expected, 'result was expected')
-    })
-  })
+      a = morph(a, b);
+      t.equal(a.outerHTML, expected, 'result was expected');
+    });
+  });
 }
 
 tape('use id as a key hint', function (t) {
@@ -276,26 +276,26 @@ tape('use id as a key hint', function (t) {
       <li id="a"></li>
       <li id="b"></li>
       <li id="c"></li>
-    </ul>`
+    </ul>`;
     var b = html`<ul>
       <li id="a"></li>
       <li id="new"></li>
       <li id="b"></li>
       <li id="c"></li>
-    </ul>`
-    var target = b.outerHTML
+    </ul>`;
+    var target = b.outerHTML;
 
-    var oldFirst = a.children[0]
-    var oldSecond = a.children[1]
-    var oldThird = a.children[2]
+    var oldFirst = a.children[0];
+    var oldSecond = a.children[1];
+    var oldThird = a.children[2];
 
-    var c = nanomorph(a, b)
-    t.equal(oldFirst, c.children[0], 'first is equal')
-    t.equal(oldSecond, c.children[2], 'moved second is equal')
-    t.equal(oldThird, c.children[3], 'moved third is equal')
-    t.equal(c.outerHTML, target)
-    t.end()
-  })
+    var c = nanomorph(a, b);
+    t.equal(oldFirst, c.children[0], 'first is equal');
+    t.equal(oldSecond, c.children[2], 'moved second is equal');
+    t.equal(oldThird, c.children[3], 'moved third is equal');
+    t.equal(c.outerHTML, target);
+    t.end();
+  });
 
   t.test('handle non-id elements', function (t) {
     var a = html`<ul>
@@ -304,7 +304,7 @@ tape('use id as a key hint', function (t) {
       <li id="b"></li>
       <li id="c"></li>
       <li></li>
-    </ul>`
+    </ul>`;
     var b = html`<ul>
       <li></li>
       <li id="a"></li>
@@ -312,77 +312,77 @@ tape('use id as a key hint', function (t) {
       <li id="b"></li>
       <li id="c"></li>
       <li></li>
-    </ul>`
-    var target = b.outerHTML
+    </ul>`;
+    var target = b.outerHTML;
 
-    var oldSecond = a.children[1]
-    var oldThird = a.children[2]
-    var oldForth = a.children[3]
+    var oldSecond = a.children[1];
+    var oldThird = a.children[2];
+    var oldForth = a.children[3];
 
-    var c = nanomorph(a, b)
-    t.equal(oldSecond, c.children[1], 'second is equal')
-    t.equal(oldThird, c.children[3], 'moved third is equal')
-    t.equal(oldForth, c.children[4], 'moved forth is equal')
-    t.equal(c.outerHTML, target)
-    t.end()
-  })
+    var c = nanomorph(a, b);
+    t.equal(oldSecond, c.children[1], 'second is equal');
+    t.equal(oldThird, c.children[3], 'moved third is equal');
+    t.equal(oldForth, c.children[4], 'moved forth is equal');
+    t.equal(c.outerHTML, target);
+    t.end();
+  });
 
   t.test('copy over children', function (t) {
-    var a = html`<section>'hello'<section>`
-    var b = html`<section><div></div><section>`
-    var expected = b.outerHTML
+    var a = html`<section>'hello'<section>`;
+    var b = html`<section><div></div><section>`;
+    var expected = b.outerHTML;
 
-    var c = nanomorph(a, b)
-    t.equal(c.outerHTML, expected, expected)
-    t.end()
-  })
+    var c = nanomorph(a, b);
+    t.equal(c.outerHTML, expected, expected);
+    t.end();
+  });
 
   t.test('remove an element', function (t) {
-    var a = html`<ul><li id="a"></li><li id="b"></li><li id="c"></li></ul>`
-    var b = html`<ul><li id="a"></li><li id="c"></li></ul>`
+    var a = html`<ul><li id="a"></li><li id="b"></li><li id="c"></li></ul>`;
+    var b = html`<ul><li id="a"></li><li id="c"></li></ul>`;
 
-    var oldFirst = a.children[0]
-    var oldThird = a.children[2]
-    var expected = b.outerHTML
+    var oldFirst = a.children[0];
+    var oldThird = a.children[2];
+    var expected = b.outerHTML;
 
-    var c = nanomorph(a, b)
+    var c = nanomorph(a, b);
 
-    t.equal(c.children[0], oldFirst, 'first is equal')
-    t.equal(c.children[1], oldThird, 'second untouched')
-    t.equal(c.outerHTML, expected)
-    t.end()
-  })
+    t.equal(c.children[0], oldFirst, 'first is equal');
+    t.equal(c.children[1], oldThird, 'second untouched');
+    t.equal(c.outerHTML, expected);
+    t.end();
+  });
 
   t.test('swap proxy elements', function (t) {
-    var nodeA = html`<li id="a"></li>`
-    var placeholderA = html`<div id="a" data-placeholder=true></div>`
+    var nodeA = html`<li id="a"></li>`;
+    var placeholderA = html`<div id="a" data-placeholder=true></div>`;
     placeholderA.isSameNode = function (el) {
-      return el === nodeA
-    }
+      return el === nodeA;
+    };
 
-    var nodeB = html`<li id="b"></li>`
-    var placeholderB = html`<div id="b" data-placeholder=true></div>`
+    var nodeB = html`<li id="b"></li>`;
+    var placeholderB = html`<div id="b" data-placeholder=true></div>`;
     placeholderB.isSameNode = function (el) {
-      return el === nodeB
-    }
+      return el === nodeB;
+    };
 
-    var a = html`<ul>${nodeA}${nodeB}</ul>`
-    var b = html`<ul>${placeholderB}${placeholderA}</ul>`
-    var c = nanomorph(a, b)
+    var a = html`<ul>${nodeA}${nodeB}</ul>`;
+    var b = html`<ul>${placeholderB}${placeholderA}</ul>`;
+    var c = nanomorph(a, b);
 
-    t.equal(c.children[0], nodeB, 'c.children[0] === nodeB')
-    t.equal(c.children[1], nodeA, 'c.children[1] === nodeA')
-    t.end()
-  })
+    t.equal(c.children[0], nodeB, 'c.children[0] === nodeB');
+    t.equal(c.children[1], nodeA, 'c.children[1] === nodeA');
+    t.end();
+  });
 
   t.test('id match still morphs', function (t) {
-    var a = html`<li id="12">FOO</li>`
-    var b = html`<li id="12">BAR</li>`
-    var target = b.outerHTML
-    var c = nanomorph(a, b)
-    t.equal(c.outerHTML, target)
-    t.end()
-  })
+    var a = html`<li id="12">FOO</li>`;
+    var b = html`<li id="12">BAR</li>`;
+    var target = b.outerHTML;
+    var c = nanomorph(a, b);
+    t.equal(c.outerHTML, target);
+    t.end();
+  });
 
   t.test('remove orphaned keyed nodes', function (t) {
     var a = html`
@@ -390,53 +390,53 @@ tape('use id as a key hint', function (t) {
         <div>1</div>
         <li id="a">a</li>
       </div>
-    `
+    `;
     var b = html`
       <div>
         <div>2</div>
         <li id="b">b</li>
       </div>
-    `
-    var expected = b.outerHTML
-    var c = nanomorph(a, b)
-    t.equal(c.outerHTML, expected)
-    t.end()
-  })
+    `;
+    var expected = b.outerHTML;
+    var c = nanomorph(a, b);
+    t.equal(c.outerHTML, expected);
+    t.end();
+  });
 
   t.test('whitespace', function (t) {
     var a = html`<ul>
-</ul>`
+</ul>`;
     var b = html`<ul><li></li><li></li>
-</ul>`
-    var expected = b.outerHTML
-    var c = nanomorph(a, b)
-    t.equal(c.outerHTML, expected)
-    t.end()
-  })
+</ul>`;
+    var expected = b.outerHTML;
+    var c = nanomorph(a, b);
+    t.equal(c.outerHTML, expected);
+    t.end();
+  });
 
   t.test('nested with id', function (t) {
-    var child = html`<div id="child"></div>`
-    var placeholder = html`<div id="child"></div>`
-    placeholder.isSameNode = function (el) { return el === child }
+    var child = html`<div id="child"></div>`;
+    var placeholder = html`<div id="child"></div>`;
+    placeholder.isSameNode = function (el) { return el === child; };
 
-    var a = html`<div><div id="parent">${child}</div></div>`
-    var b = html`<div><div id="parent">${placeholder}</div></div>`
+    var a = html`<div><div id="parent">${child}</div></div>`;
+    var b = html`<div><div id="parent">${placeholder}</div></div>`;
 
-    var c = nanomorph(a, b)
-    t.equal(c.children[0].children[0], child, 'is the same node')
-    t.end()
-  })
+    var c = nanomorph(a, b);
+    t.equal(c.children[0].children[0], child, 'is the same node');
+    t.end();
+  });
 
   t.test('nested without id', function (t) {
-    var child = html`<div id="child">child</div>`
-    var placeholder = html`<div id="child">placeholder</div>`
-    placeholder.isSameNode = function (el) { return el === child }
-
-    var a = html`<div><div>${child}</div></div>`
-    var b = html`<div><div>${placeholder}</div></div>`
-
-    var c = nanomorph(a, b)
-    t.equal(c.children[0].children[0], child, 'is the same node')
-    t.end()
-  })
-})
+    var child = html`<div id="child">child</div>`;
+    var placeholder = html`<div id="child">placeholder</div>`;
+    placeholder.isSameNode = function (el) { return el === child; };
+
+    var a = html`<div><div>${child}</div></div>`;
+    var b = html`<div><div>${placeholder}</div></div>`;
+
+    var c = nanomorph(a, b);
+    t.equal(c.children[0].children[0], child, 'is the same node');
+    t.end();
+  });
+});
diff --git a/test/events.js b/test/events.js
index 309d29d..6f8d319 100644
--- a/test/events.js
+++ b/test/events.js
@@ -1,12 +1,12 @@
-let tape = require('tape')
-let html = require('bel')
+let tape = require('tape');
+let html = require('bel');
 
-module.exports = abstractMorphEvents
+module.exports = abstractMorphEvents;
 
 function raiseEvent (element, eventName) {
-  let event = document.createEvent('Event')
-  event.initEvent(eventName, true, true)
-  element.dispatchEvent(event)
+  let event = document.createEvent('Event');
+  event.initEvent(eventName, true, true);
+  element.dispatchEvent(event);
 }
 /* Note:
 Failing tests have been commented. They include the following:
@@ -23,695 +23,695 @@ function abstractMorphEvents (morph) {
   tape('events', function (t) {
     t.test('events', function (t) {
       t.test('should have onabort events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onabort=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onabort=${pass}></input>`;
 
-        raiseEvent(res, 'abort')
+        raiseEvent(res, 'abort');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onabort events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onabort=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onabort=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'abort')
+        raiseEvent(res, 'abort');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onabort events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onabort=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onabort=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'abort')
+        raiseEvent(res, 'abort');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onblur events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onblur=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onblur=${pass}></input>`;
 
-        raiseEvent(res, 'blur')
+        raiseEvent(res, 'blur');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onblur events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onblur=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onblur=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'blur')
+        raiseEvent(res, 'blur');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onblur events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onblur=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onblur=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'blur')
+        raiseEvent(res, 'blur');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onchange events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onchange=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onchange=${pass}></input>`;
 
-        raiseEvent(res, 'change')
+        raiseEvent(res, 'change');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onchange events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onchange=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onchange=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'change')
+        raiseEvent(res, 'change');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onchange events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onchange=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onchange=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'change')
+        raiseEvent(res, 'change');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onclick events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onclick=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onclick=${pass}></input>`;
 
-        raiseEvent(res, 'click')
+        raiseEvent(res, 'click');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onclick events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onclick=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onclick=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'click')
+        raiseEvent(res, 'click');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onclick events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onclick=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onclick=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'click')
+        raiseEvent(res, 'click');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have oncontextmenu events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input oncontextmenu=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input oncontextmenu=${pass}></input>`;
 
-        raiseEvent(res, 'contextmenu')
+        raiseEvent(res, 'contextmenu');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy oncontextmenu events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input oncontextmenu=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input oncontextmenu=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'contextmenu')
+        raiseEvent(res, 'contextmenu');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy oncontextmenu events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input oncontextmenu=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input oncontextmenu=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'contextmenu')
+        raiseEvent(res, 'contextmenu');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have ondblclick events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input ondblclick=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input ondblclick=${pass}></input>`;
 
-        raiseEvent(res, 'dblclick')
+        raiseEvent(res, 'dblclick');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy ondblclick events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input ondblclick=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input ondblclick=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'dblclick')
+        raiseEvent(res, 'dblclick');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy ondblclick events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input ondblclick=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input ondblclick=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'dblclick')
+        raiseEvent(res, 'dblclick');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have ondrag events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input ondrag=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input ondrag=${pass}></input>`;
 
-        raiseEvent(res, 'drag')
+        raiseEvent(res, 'drag');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy ondrag events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input ondrag=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input ondrag=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'drag')
+        raiseEvent(res, 'drag');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy ondrag events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input ondrag=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input ondrag=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'drag')
+        raiseEvent(res, 'drag');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have ondragend events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input ondragend=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input ondragend=${pass}></input>`;
 
-        raiseEvent(res, 'dragend')
+        raiseEvent(res, 'dragend');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy ondragend events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input ondragend=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input ondragend=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'dragend')
+        raiseEvent(res, 'dragend');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy ondragend events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input ondragend=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input ondragend=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'dragend')
+        raiseEvent(res, 'dragend');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have ondragenter events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input ondragenter=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input ondragenter=${pass}></input>`;
 
-        raiseEvent(res, 'dragenter')
+        raiseEvent(res, 'dragenter');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy ondragenter events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input ondragenter=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input ondragenter=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'dragenter')
+        raiseEvent(res, 'dragenter');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy ondragenter events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input ondragenter=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input ondragenter=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'dragenter')
+        raiseEvent(res, 'dragenter');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have ondragleave events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input ondragleave=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input ondragleave=${pass}></input>`;
 
-        raiseEvent(res, 'dragleave')
+        raiseEvent(res, 'dragleave');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy ondragleave events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input ondragleave=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input ondragleave=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'dragleave')
+        raiseEvent(res, 'dragleave');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy ondragleave events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input ondragleave=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input ondragleave=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'dragleave')
+        raiseEvent(res, 'dragleave');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have ondragover events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input ondragover=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input ondragover=${pass}></input>`;
 
-        raiseEvent(res, 'dragover')
+        raiseEvent(res, 'dragover');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy ondragover events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input ondragover=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input ondragover=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'dragover')
+        raiseEvent(res, 'dragover');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy ondragover events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input ondragover=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input ondragover=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'dragover')
+        raiseEvent(res, 'dragover');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have ondragstart events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input ondragstart=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input ondragstart=${pass}></input>`;
 
-        raiseEvent(res, 'dragstart')
+        raiseEvent(res, 'dragstart');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy ondragstart events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input ondragstart=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input ondragstart=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'dragstart')
+        raiseEvent(res, 'dragstart');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy ondragstart events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input ondragstart=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input ondragstart=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'dragstart')
+        raiseEvent(res, 'dragstart');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have ondrop events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input ondrop=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input ondrop=${pass}></input>`;
 
-        raiseEvent(res, 'drop')
+        raiseEvent(res, 'drop');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy ondrop events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input ondrop=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input ondrop=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'drop')
+        raiseEvent(res, 'drop');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy ondrop events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input ondrop=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input ondrop=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'drop')
+        raiseEvent(res, 'drop');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onerror events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onerror=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onerror=${pass}></input>`;
 
-        raiseEvent(res, 'error')
+        raiseEvent(res, 'error');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onerror events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onerror=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onerror=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'error')
+        raiseEvent(res, 'error');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onerror events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onerror=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onerror=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'error')
+        raiseEvent(res, 'error');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onfocus events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onfocus=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onfocus=${pass}></input>`;
 
-        raiseEvent(res, 'focus')
+        raiseEvent(res, 'focus');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onfocus events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onfocus=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onfocus=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'focus')
+        raiseEvent(res, 'focus');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onfocus events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onfocus=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onfocus=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'focus')
+        raiseEvent(res, 'focus');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       /*
       t.test('should have onfocusin events(html attribute) ', function (t) {
         t.plan(1)
@@ -809,741 +809,741 @@ function abstractMorphEvents (morph) {
       })
       */
       t.test('should have oninput events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input oninput=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input oninput=${pass}></input>`;
 
-        raiseEvent(res, 'input')
+        raiseEvent(res, 'input');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy oninput events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input oninput=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input oninput=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'input')
+        raiseEvent(res, 'input');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy oninput events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input oninput=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input oninput=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'input')
+        raiseEvent(res, 'input');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onkeydown events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onkeydown=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onkeydown=${pass}></input>`;
 
-        raiseEvent(res, 'keydown')
+        raiseEvent(res, 'keydown');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onkeydown events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onkeydown=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onkeydown=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'keydown')
+        raiseEvent(res, 'keydown');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onkeydown events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onkeydown=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onkeydown=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'keydown')
+        raiseEvent(res, 'keydown');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onkeypress events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onkeypress=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onkeypress=${pass}></input>`;
 
-        raiseEvent(res, 'keypress')
+        raiseEvent(res, 'keypress');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onkeypress events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onkeypress=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onkeypress=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'keypress')
+        raiseEvent(res, 'keypress');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onkeypress events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onkeypress=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onkeypress=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'keypress')
+        raiseEvent(res, 'keypress');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onkeyup events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onkeyup=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onkeyup=${pass}></input>`;
 
-        raiseEvent(res, 'keyup')
+        raiseEvent(res, 'keyup');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onkeyup events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onkeyup=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onkeyup=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'keyup')
+        raiseEvent(res, 'keyup');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onkeyup events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onkeyup=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onkeyup=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'keyup')
+        raiseEvent(res, 'keyup');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onmousedown events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onmousedown=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onmousedown=${pass}></input>`;
 
-        raiseEvent(res, 'mousedown')
+        raiseEvent(res, 'mousedown');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onmousedown events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onmousedown=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onmousedown=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'mousedown')
+        raiseEvent(res, 'mousedown');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onmousedown events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onmousedown=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onmousedown=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'mousedown')
+        raiseEvent(res, 'mousedown');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onmouseenter events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onmouseenter=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onmouseenter=${pass}></input>`;
 
-        raiseEvent(res, 'mouseenter')
+        raiseEvent(res, 'mouseenter');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onmouseenter events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onmouseenter=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onmouseenter=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'mouseenter')
+        raiseEvent(res, 'mouseenter');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onmouseenter events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onmouseenter=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onmouseenter=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'mouseenter')
+        raiseEvent(res, 'mouseenter');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onmouseleave events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onmouseleave=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onmouseleave=${pass}></input>`;
 
-        raiseEvent(res, 'mouseleave')
+        raiseEvent(res, 'mouseleave');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onmouseleave events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onmouseleave=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onmouseleave=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'mouseleave')
+        raiseEvent(res, 'mouseleave');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onmouseleave events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onmouseleave=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onmouseleave=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'mouseleave')
+        raiseEvent(res, 'mouseleave');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onmousemove events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onmousemove=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onmousemove=${pass}></input>`;
 
-        raiseEvent(res, 'mousemove')
+        raiseEvent(res, 'mousemove');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onmousemove events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onmousemove=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onmousemove=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'mousemove')
+        raiseEvent(res, 'mousemove');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onmousemove events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onmousemove=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onmousemove=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'mousemove')
+        raiseEvent(res, 'mousemove');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onmouseout events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onmouseout=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onmouseout=${pass}></input>`;
 
-        raiseEvent(res, 'mouseout')
+        raiseEvent(res, 'mouseout');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onmouseout events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onmouseout=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onmouseout=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'mouseout')
+        raiseEvent(res, 'mouseout');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onmouseout events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onmouseout=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onmouseout=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'mouseout')
+        raiseEvent(res, 'mouseout');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onmouseover events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onmouseover=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onmouseover=${pass}></input>`;
 
-        raiseEvent(res, 'mouseover')
+        raiseEvent(res, 'mouseover');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onmouseover events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onmouseover=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onmouseover=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'mouseover')
+        raiseEvent(res, 'mouseover');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onmouseover events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onmouseover=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onmouseover=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'mouseover')
+        raiseEvent(res, 'mouseover');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onmouseup events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onmouseup=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onmouseup=${pass}></input>`;
 
-        raiseEvent(res, 'mouseup')
+        raiseEvent(res, 'mouseup');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onmouseup events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onmouseup=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onmouseup=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'mouseup')
+        raiseEvent(res, 'mouseup');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onmouseup events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onmouseup=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onmouseup=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'mouseup')
+        raiseEvent(res, 'mouseup');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onreset events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onreset=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onreset=${pass}></input>`;
 
-        raiseEvent(res, 'reset')
+        raiseEvent(res, 'reset');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onreset events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onreset=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onreset=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'reset')
+        raiseEvent(res, 'reset');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onreset events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onreset=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onreset=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'reset')
+        raiseEvent(res, 'reset');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onresize events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onresize=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onresize=${pass}></input>`;
 
-        raiseEvent(res, 'resize')
+        raiseEvent(res, 'resize');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onresize events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onresize=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onresize=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'resize')
+        raiseEvent(res, 'resize');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onresize events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onresize=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onresize=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'resize')
+        raiseEvent(res, 'resize');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onscroll events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onscroll=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onscroll=${pass}></input>`;
 
-        raiseEvent(res, 'scroll')
+        raiseEvent(res, 'scroll');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onscroll events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onscroll=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onscroll=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'scroll')
+        raiseEvent(res, 'scroll');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onscroll events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onscroll=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onscroll=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'scroll')
+        raiseEvent(res, 'scroll');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onselect events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onselect=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onselect=${pass}></input>`;
 
-        raiseEvent(res, 'select')
+        raiseEvent(res, 'select');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onselect events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onselect=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onselect=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'select')
+        raiseEvent(res, 'select');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onselect events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onselect=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onselect=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'select')
+        raiseEvent(res, 'select');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should have onsubmit events(html attribute) ', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let res = html`<input onsubmit=${pass}></input>`
+        t.plan(1);
+        let expectationMet = false;
+        let res = html`<input onsubmit=${pass}></input>`;
 
-        raiseEvent(res, 'submit')
+        raiseEvent(res, 'submit');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should not copy onsubmit events', function (t) {
-        t.plan(1)
-        let expectationMet = true
-        let a = html`<input onsubmit=${fail}></input>`
-        let b = html`<input></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = true;
+        let a = html`<input onsubmit=${fail}></input>`;
+        let b = html`<input></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'submit')
+        raiseEvent(res, 'submit');
 
         function fail (e) {
-          e.preventDefault()
-          expectationMet = false
+          e.preventDefault();
+          expectationMet = false;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       t.test('should copy onsubmit events(html arrtibute)', function (t) {
-        t.plan(1)
-        let expectationMet = false
-        let a = html`<input></input>`
-        let b = html`<input onsubmit=${pass}></input>`
-        let res = morph(a, b)
+        t.plan(1);
+        let expectationMet = false;
+        let a = html`<input></input>`;
+        let b = html`<input onsubmit=${pass}></input>`;
+        let res = morph(a, b);
 
-        raiseEvent(res, 'submit')
+        raiseEvent(res, 'submit');
 
         function pass (e) {
-          e.preventDefault()
-          expectationMet = true
+          e.preventDefault();
+          expectationMet = true;
         }
 
-        t.equal(expectationMet, true, 'result was expected')
-      })
+        t.equal(expectationMet, true, 'result was expected');
+      });
       /*
       t.test('should have ontouchcancel events(html attribute) ', function (t) {
         t.plan(1)
@@ -1783,6 +1783,6 @@ function abstractMorphEvents (morph) {
         t.equal(expectationMet, true, 'result was expected')
       })
       */
-    })
-  })
+    });
+  });
 }
diff --git a/test/fuzz.js b/test/fuzz.js
index fbe2713..47388f7 100644
--- a/test/fuzz.js
+++ b/test/fuzz.js
@@ -1,69 +1,69 @@
-var seed = require('math-random-seed')
-var tape = require('tape')
-var html = require('bel')
+var seed = require('math-random-seed');
+var tape = require('tape');
+var html = require('bel');
 
-var nanomorph = require('../')
+var nanomorph = require('../');
 
 tape('chaos monkey #1', function (t) {
-  var a, b
-  a = html`<div r="r"><div></div></div>`
-  b = html`<div io="iO" vq="Vq"><div></div></div>`
-  compare(a, b, t)
-  t.end()
-})
+  var a, b;
+  a = html`<div r="r"><div></div></div>`;
+  b = html`<div io="iO" vq="Vq"><div></div></div>`;
+  compare(a, b, t);
+  t.end();
+});
 
 // modeled after
 // https://github.com/mafintosh/hypercore/blob/master/test/tree-index.js
-var random = seed('choo choo')
-var props = null
+var random = seed('choo choo');
+var props = null;
 tape('fuzz tests', function (t) {
-  var a, b
+  var a, b;
   for (var i = 0; i < 7; i++) {
     for (var j = 0; j < 5; j++) {
-      a = create(i, j, 0)
+      a = create(i, j, 0);
       for (var k = 0; k < 3; k++) {
-        b = create(i, k, 1)
-        props = { depth: i, propCount: j, offset: k }
-        compare(a, b, t, props)
+        b = create(i, k, 1);
+        props = { depth: i, propCount: j, offset: k };
+        compare(a, b, t, props);
       }
     }
   }
-  t.end()
-})
+  t.end();
+});
 
 function create (depth, propCount, offset) {
-  var chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
-  var root = document.createElement('div')
-  var el = root
-  var _el = null
-  var str = ''
-  offset += 100
+  var chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+  var root = document.createElement('div');
+  var el = root;
+  var _el = null;
+  var str = '';
+  offset += 100;
   for (var i = 0; i < depth; i++) {
-    _el = document.createElement('div')
-    el.appendChild(_el)
+    _el = document.createElement('div');
+    el.appendChild(_el);
     for (var j = 0; j < propCount; j++) {
-      str = ''
+      str = '';
       for (var k = propCount; k > 0; --k) {
-        str += chars[Math.floor(random() * 100) % chars.length]
+        str += chars[Math.floor(random() * 100) % chars.length];
       }
-      el.setAttribute(str, str)
-      offset++
+      el.setAttribute(str, str);
+      offset++;
     }
-    el = _el
+    el = _el;
   }
-  return root
+  return root;
 }
 
 function compare (a, b, t, props) {
-  props = props ? JSON.stringify(props) : undefined
-  var expected = b.cloneNode(true)
-  var res = nanomorph(a, b)
-  deepEqualNode(res, expected, t, props)
+  props = props ? JSON.stringify(props) : undefined;
+  var expected = b.cloneNode(true);
+  var res = nanomorph(a, b);
+  deepEqualNode(res, expected, t, props);
 }
 
 function deepEqualNode (a, b, t, props) {
-  t.ok(a.isEqualNode(b), props)
+  t.ok(a.isEqualNode(b), props);
   for (var i = a.childNodes.length - 1; i >= 0; --i) {
-    deepEqualNode(a.childNodes[i], a.childNodes[i], t, props)
+    deepEqualNode(a.childNodes[i], a.childNodes[i], t, props);
   }
 }
diff --git a/test/index.js b/test/index.js
index bc05bee..71e6a74 100644
--- a/test/index.js
+++ b/test/index.js
@@ -1,24 +1,24 @@
-var tape = require('tape')
+var tape = require('tape');
 
-var abstractMorph = require('./diff')
-var nanomorph = require('../')
-var abstractMorphEvents = require('./events')
+var abstractMorph = require('./diff');
+var nanomorph = require('../');
+var abstractMorphEvents = require('./events');
 
 if (!module.parent) {
-  require('./fuzz')
-  specificTests(nanomorph)
-  abstractMorph(nanomorph)
-  abstractMorphEvents(nanomorph)
+  require('./fuzz');
+  specificTests(nanomorph);
+  abstractMorph(nanomorph);
+  abstractMorphEvents(nanomorph);
 } else {
-  module.exports = abstractMorph
+  module.exports = abstractMorph;
 }
 
 function specificTests (morph) {
   tape('nanomorph', function (t) {
     t.test('should assert input types', function (t) {
-      t.plan(2)
-      t.throws(morph, /a/)
-      t.throws(morph.bind(null, {}), /b/)
-    })
-  })
+      t.plan(2);
+      t.throws(morph, /a/);
+      t.throws(morph.bind(null, {}), /b/);
+    });
+  });
 }