diff --git a/bench.js b/bench.js
index 7ec6a87..9503cf2 100644
--- a/bench.js
+++ b/bench.js
@@ -1,109 +1,110 @@
+'use strict';
 
-var mpath = require('./')
-var Bench = require('benchmark');
-var sha = require('child_process').exec("git log --pretty=format:'%h' -n 1", function (err, sha) {
+const mpath = require('./');
+const Bench = require('benchmark');
+require('child_process').exec('git log --pretty=format:\'%h\' -n 1', function(err, sha) {
   if (err) throw err;
 
-  var fs = require('fs')
-  var filename = __dirname + '/bench.out';
-  var out = fs.createWriteStream(filename, { flags: 'a', encoding: 'utf8' });
+  const fs = require('fs');
+  const filename = __dirname + '/bench.out';
+  const out = fs.createWriteStream(filename, { flags: 'a', encoding: 'utf8' });
 
   /**
    * test doc creator
    */
 
-  function doc () {
-    var o = { first: { second: { third: [3,{ name: 'aaron' }, 9] }}};
+  function doc() {
+    const o = { first: { second: { third: [3, { name: 'aaron' }, 9] } } };
     o.comments = [
-        { name: 'one' }
-      , { name: 'two', _doc: { name: '2' }}
-      , { name: 'three'
-          , comments: [{},{ comments: [{val: 'twoo'}]}]
-          , _doc: { name: '3', comments: [{},{ _doc: { comments: [{ val: 2 }] }}]  }}
+      { name: 'one' },
+      { name: 'two', _doc: { name: '2' } },
+      { name: 'three',
+        comments: [{}, { comments: [{ val: 'twoo' }] }],
+        _doc: { name: '3', comments: [{}, { _doc: { comments: [{ val: 2 }] } }] } }
     ];
     o.name = 'jiro';
     o.array = [
-        { o: { array: [{x: {b: [4,6,8]}}, { y: 10} ] }}
-      , { o: { array: [{x: {b: [1,2,3]}}, { x: {z: 10 }}, { x: {b: 'hi'}}] }}
-      , { o: { array: [{x: {b: null }}, { x: { b: [null, 1]}}] }}
-      , { o: { array: [{x: null }] }}
-      , { o: { array: [{y: 3 }] }}
-      , { o: { array: [3, 0, null] }}
-      , { o: { name: 'ha' }}
+      { o: { array: [{ x: { b: [4, 6, 8] } }, { y: 10 }] } },
+      { o: { array: [{ x: { b: [1, 2, 3] } }, { x: { z: 10 } }, { x: { b: 'hi' } }] } },
+      { o: { array: [{ x: { b: null } }, { x: { b: [null, 1] } }] } },
+      { o: { array: [{ x: null }] } },
+      { o: { array: [{ y: 3 }] } },
+      { o: { array: [3, 0, null] } },
+      { o: { name: 'ha' } }
     ];
     o.arr = [
-        { arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-      , { yep: true }
-    ]
+      { arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+      { yep: true }
+    ];
     return o;
   }
 
-  var o = doc();
+  const o = doc();
 
-  var s = new Bench.Suite;
-  s.add('mpath.get("first", obj)', function () {
+  const s = new Bench.Suite;
+  s.add('mpath.get("first", obj)', function() {
     mpath.get('first', o);
-  })
-  s.add('mpath.get("first.second", obj)', function () {
+  });
+  s.add('mpath.get("first.second", obj)', function() {
     mpath.get('first.second', o);
-  })
-  s.add('mpath.get("first.second.third.1.name", obj)', function () {
+  });
+  s.add('mpath.get("first.second.third.1.name", obj)', function() {
     mpath.get('first.second.third.1.name', o);
-  })
-  s.add('mpath.get("comments", obj)', function () {
+  });
+  s.add('mpath.get("comments", obj)', function() {
     mpath.get('comments', o);
-  })
-  s.add('mpath.get("comments.1", obj)', function () {
+  });
+  s.add('mpath.get("comments.1", obj)', function() {
     mpath.get('comments.1', o);
-  })
-  s.add('mpath.get("comments.2.name", obj)', function () {
+  });
+  s.add('mpath.get("comments.2.name", obj)', function() {
     mpath.get('comments.2.name', o);
-  })
-  s.add('mpath.get("comments.2.comments.1.comments.0.val", obj)', function () {
+  });
+  s.add('mpath.get("comments.2.comments.1.comments.0.val", obj)', function() {
     mpath.get('comments.2.comments.1.comments.0.val', o);
-  })
-  s.add('mpath.get("comments.name", obj)', function () {
+  });
+  s.add('mpath.get("comments.name", obj)', function() {
     mpath.get('comments.name', o);
-  })
+  });
 
-  s.add('mpath.set("first", obj, val)', function () {
+  s.add('mpath.set("first", obj, val)', function() {
     mpath.set('first', o, 1);
-  })
-  s.add('mpath.set("first.second", obj, val)', function () {
+  });
+  s.add('mpath.set("first.second", obj, val)', function() {
     mpath.set('first.second', o, 1);
-  })
-  s.add('mpath.set("first.second.third.1.name", obj, val)', function () {
+  });
+  s.add('mpath.set("first.second.third.1.name", obj, val)', function() {
     mpath.set('first.second.third.1.name', o, 1);
-  })
-  s.add('mpath.set("comments", obj, val)', function () {
+  });
+  s.add('mpath.set("comments", obj, val)', function() {
     mpath.set('comments', o, 1);
-  })
-  s.add('mpath.set("comments.1", obj, val)', function () {
+  });
+  s.add('mpath.set("comments.1", obj, val)', function() {
     mpath.set('comments.1', o, 1);
-  })
-  s.add('mpath.set("comments.2.name", obj, val)', function () {
+  });
+  s.add('mpath.set("comments.2.name", obj, val)', function() {
     mpath.set('comments.2.name', o, 1);
-  })
-  s.add('mpath.set("comments.2.comments.1.comments.0.val", obj, val)', function () {
+  });
+  s.add('mpath.set("comments.2.comments.1.comments.0.val", obj, val)', function() {
     mpath.set('comments.2.comments.1.comments.0.val', o, 1);
-  })
-  s.add('mpath.set("comments.name", obj, val)', function () {
+  });
+  s.add('mpath.set("comments.name", obj, val)', function() {
     mpath.set('comments.name', o, 1);
-  })
+  });
 
-  s.on('start', function () {
+  s.on('start', function() {
     console.log('starting...');
     out.write('*' + sha + ': ' + String(new Date()) + '\n');
   });
-  s.on('cycle', function (e) {
-    var s = String(e.target);
+  s.on('cycle', function(e) {
+    const s = String(e.target);
     console.log(s);
     out.write(s + '\n');
-  })
-  s.on('complete', function () {
-    console.log('done')
+  });
+  s.on('complete', function() {
+    console.log('done');
     out.end('');
-  })
-  s.run()
-})
+  });
+  s.run();
+});
 
diff --git a/index.js b/index.js
index f7b65dd..47c17cd 100644
--- a/index.js
+++ b/index.js
@@ -1 +1,3 @@
+'use strict';
+
 module.exports = exports = require('./lib');
diff --git a/lib/index.js b/lib/index.js
index 6b172b1..d905104 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -1,8 +1,10 @@
-var stringToParts = require('./stringToParts');
+/* eslint strict:off */
+
+const stringToParts = require('./stringToParts');
 
 // These properties are special and can open client libraries to security
 // issues
-var ignoreProperties = ['__proto__', 'constructor', 'prototype'];
+const ignoreProperties = ['__proto__', 'constructor', 'prototype'];
 
 /**
  * Returns the value of object `o` at the given `path`.
@@ -32,8 +34,8 @@ var ignoreProperties = ['__proto__', 'constructor', 'prototype'];
  * @param {Function} [map] Optional function which receives each individual found value. The value returned from `map` is used in the original values place.
  */
 
-exports.get = function (path, o, special, map) {
-  var lookup;
+exports.get = function(path, o, special, map) {
+  let lookup;
 
   if ('function' == typeof special) {
     if (special.length < 2) {
@@ -47,27 +49,27 @@ exports.get = function (path, o, special, map) {
 
   map || (map = K);
 
-  var parts = 'string' == typeof path
+  const parts = 'string' == typeof path
     ? stringToParts(path)
-    : path
+    : path;
 
   if (!Array.isArray(parts)) {
     throw new TypeError('Invalid `path`. Must be either string or array');
   }
 
-  var obj = o
-    , part;
+  let obj = o,
+      part;
 
-  for (var i = 0; i < parts.length; ++i) {
+  for (let i = 0; i < parts.length; ++i) {
     part = parts[i];
 
     if (Array.isArray(obj) && !/^\d+$/.test(part)) {
       // reading a property from the array items
-      var paths = parts.slice(i);
+      const paths = parts.slice(i);
 
       // Need to `concat()` to avoid `map()` calling a constructor of an array
       // subclass
-      return [].concat(obj).map(function (item) {
+      return [].concat(obj).map(function(item) {
         return item
           ? exports.get(paths, item, special || lookup, map)
           : map(undefined);
@@ -77,7 +79,7 @@ exports.get = function (path, o, special, map) {
     if (lookup) {
       obj = lookup(obj, part);
     } else {
-      var _from = special && obj[special] ? obj[special] : obj;
+      const _from = special && obj[special] ? obj[special] : obj;
       obj = _from instanceof Map ?
         _from.get(part) :
         _from[part];
@@ -96,8 +98,8 @@ exports.get = function (path, o, special, map) {
  * @param {Object} o
  */
 
-exports.has = function (path, o) {
-  var parts = typeof path === 'string' ?
+exports.has = function(path, o) {
+  const parts = typeof path === 'string' ?
     stringToParts(path) :
     path;
 
@@ -105,9 +107,9 @@ exports.has = function (path, o) {
     throw new TypeError('Invalid `path`. Must be either string or array');
   }
 
-  var len = parts.length;
-  var cur = o;
-  for (var i = 0; i < len; ++i) {
+  const len = parts.length;
+  let cur = o;
+  for (let i = 0; i < len; ++i) {
     if (cur == null || typeof cur !== 'object' || !(parts[i] in cur)) {
       return false;
     }
@@ -124,8 +126,8 @@ exports.has = function (path, o) {
  * @param {Object} o
  */
 
-exports.unset = function (path, o) {
-  var parts = typeof path === 'string' ?
+exports.unset = function(path, o) {
+  const parts = typeof path === 'string' ?
     stringToParts(path) :
     path;
 
@@ -133,9 +135,9 @@ exports.unset = function (path, o) {
     throw new TypeError('Invalid `path`. Must be either string or array');
   }
 
-  var len = parts.length;
-  var cur = o;
-  for (var i = 0; i < len; ++i) {
+  const len = parts.length;
+  let cur = o;
+  for (let i = 0; i < len; ++i) {
     if (cur == null || typeof cur !== 'object' || !(parts[i] in cur)) {
       return false;
     }
@@ -163,8 +165,8 @@ exports.unset = function (path, o) {
  * @param {Function} [map] Optional function which is passed each individual value before setting it. The value returned from `map` is used in the original values place.
  */
 
-exports.set = function (path, val, o, special, map, _copying) {
-  var lookup;
+exports.set = function(path, val, o, special, map, _copying) {
+  let lookup;
 
   if ('function' == typeof special) {
     if (special.length < 2) {
@@ -178,9 +180,9 @@ exports.set = function (path, val, o, special, map, _copying) {
 
   map || (map = K);
 
-  var parts = 'string' == typeof path
+  const parts = 'string' == typeof path
     ? stringToParts(path)
-    : path
+    : path;
 
   if (!Array.isArray(parts)) {
     throw new TypeError('Invalid `path`. Must be either string or array');
@@ -188,7 +190,7 @@ exports.set = function (path, val, o, special, map, _copying) {
 
   if (null == o) return;
 
-  for (var i = 0; i < parts.length; ++i) {
+  for (let i = 0; i < parts.length; ++i) {
     // Silently ignore any updates to `__proto__`, these are potentially
     // dangerous if using mpath with unsanitized data.
     if (ignoreProperties.indexOf(parts[i]) !== -1) {
@@ -201,11 +203,12 @@ exports.set = function (path, val, o, special, map, _copying) {
   // the array to the one by one to matching positions of the
   // current array. Unless the user explicitly opted out by passing
   // false, see Automattic/mongoose#6273
-  var copy = _copying || (/\$/.test(path) && _copying !== false)
-    , obj = o
-    , part
+  const copy = _copying || (/\$/.test(path) && _copying !== false);
+  let obj = o;
+  let part;
+  const len = parts.length - 1;
 
-  for (var i = 0, len = parts.length - 1; i < len; ++i) {
+  for (let i = 0; i < len; ++i) {
     part = parts[i];
 
     if ('$' == part) {
@@ -217,14 +220,14 @@ exports.set = function (path, val, o, special, map, _copying) {
     }
 
     if (Array.isArray(obj) && !/^\d+$/.test(part)) {
-      var paths = parts.slice(i);
+      const paths = parts.slice(i);
       if (!copy && Array.isArray(val)) {
-        for (var j = 0; j < obj.length && j < val.length; ++j) {
+        for (let j = 0; j < obj.length && j < val.length; ++j) {
           // assignment of single values of array
           exports.set(paths, val[j], obj[j], special || lookup, map, copy);
         }
       } else {
-        for (var j = 0; j < obj.length; ++j) {
+        for (let j = 0; j < obj.length; ++j) {
           // assignment of entire value
           exports.set(paths, val, obj[j], special || lookup, map, copy);
         }
@@ -235,7 +238,7 @@ exports.set = function (path, val, o, special, map, _copying) {
     if (lookup) {
       obj = lookup(obj, part);
     } else {
-      var _to = special && obj[special] ? obj[special] : obj;
+      const _to = special && obj[special] ? obj[special] : obj;
       obj = _to instanceof Map ?
         _to.get(part) :
         _to[part];
@@ -258,8 +261,8 @@ exports.set = function (path, val, o, special, map, _copying) {
     if (!copy && Array.isArray(val)) {
       _setArray(obj, val, part, lookup, special, map);
     } else {
-      for (var j = 0; j < obj.length; ++j) {
-        item = obj[j];
+      for (let j = 0; j < obj.length; ++j) {
+        let item = obj[j];
         if (item) {
           if (lookup) {
             lookup(item, part, map(val));
@@ -279,15 +282,15 @@ exports.set = function (path, val, o, special, map, _copying) {
       obj[part] = map(val);
     }
   }
-}
+};
 
 /*!
  * Recursively set nested arrays
  */
 
 function _setArray(obj, val, part, lookup, special, map) {
-  for (var item, j = 0; j < obj.length && j < val.length; ++j) {
-    item = obj[j];
+  for (let j = 0; j < obj.length && j < val.length; ++j) {
+    let item = obj[j];
     if (Array.isArray(item) && Array.isArray(val[j])) {
       _setArray(item, val[j], part, lookup, special, map);
     } else if (item) {
@@ -305,6 +308,6 @@ function _setArray(obj, val, part, lookup, special, map) {
  * Returns the value passed to it.
  */
 
-function K (v) {
+function K(v) {
   return v;
 }
diff --git a/package.json b/package.json
index 0c2b468..8c850f8 100644
--- a/package.json
+++ b/package.json
@@ -4,6 +4,7 @@
   "description": "{G,S}et object values using MongoDB-like path notation",
   "main": "index.js",
   "scripts": {
+    "lint": "eslint .",
     "test": "mocha test/*"
   },
   "engines": {
@@ -20,6 +21,124 @@
   "license": "MIT",
   "devDependencies": {
     "mocha": "5.x",
-    "benchmark": "~1.0.0"
+    "benchmark": "~1.0.0",
+    "eslint": "7.16.0"
+  },
+  "eslintConfig": {
+    "extends": [
+      "eslint:recommended"
+    ],
+    "parserOptions": {
+      "ecmaVersion": 2015
+    },
+    "env": {
+      "node": true,
+      "es6": true
+    },
+    "rules": {
+      "comma-style": "error",
+      "indent": [
+        "error",
+        2,
+        {
+          "SwitchCase": 1,
+          "VariableDeclarator": 2
+        }
+      ],
+      "keyword-spacing": "error",
+      "no-whitespace-before-property": "error",
+      "no-buffer-constructor": "warn",
+      "no-console": "off",
+      "no-multi-spaces": "error",
+      "no-constant-condition": "off",
+      "func-call-spacing": "error",
+      "no-trailing-spaces": "error",
+      "no-undef": "error",
+      "no-unneeded-ternary": "error",
+      "no-const-assign": "error",
+      "no-useless-rename": "error",
+      "no-dupe-keys": "error",
+      "space-in-parens": [
+        "error",
+        "never"
+      ],
+      "spaced-comment": [
+        "error",
+        "always",
+        {
+          "block": {
+            "markers": [
+              "!"
+            ],
+            "balanced": true
+          }
+        }
+      ],
+      "key-spacing": [
+        "error",
+        {
+          "beforeColon": false,
+          "afterColon": true
+        }
+      ],
+      "comma-spacing": [
+        "error",
+        {
+          "before": false,
+          "after": true
+        }
+      ],
+      "array-bracket-spacing": 1,
+      "arrow-spacing": [
+        "error",
+        {
+          "before": true,
+          "after": true
+        }
+      ],
+      "object-curly-spacing": [
+        "error",
+        "always"
+      ],
+      "comma-dangle": [
+        "error",
+        "never"
+      ],
+      "no-unreachable": "error",
+      "quotes": [
+        "error",
+        "single"
+      ],
+      "quote-props": [
+        "error",
+        "as-needed"
+      ],
+      "semi": "error",
+      "no-extra-semi": "error",
+      "semi-spacing": "error",
+      "no-spaced-func": "error",
+      "no-throw-literal": "error",
+      "space-before-blocks": "error",
+      "space-before-function-paren": [
+        "error",
+        "never"
+      ],
+      "space-infix-ops": "error",
+      "space-unary-ops": "error",
+      "no-var": "warn",
+      "prefer-const": "warn",
+      "strict": [
+        "error",
+        "global"
+      ],
+      "no-restricted-globals": [
+        "error",
+        {
+          "name": "context",
+          "message": "Don't use Mocha's global context"
+        }
+      ],
+      "no-prototype-builtins": "off"
+    }
   }
 }
diff --git a/test/.eslintrc.yml b/test/.eslintrc.yml
new file mode 100644
index 0000000..c0c6803
--- /dev/null
+++ b/test/.eslintrc.yml
@@ -0,0 +1,4 @@
+env:
+  mocha: true
+rules:
+  no-unused-vars: off
\ No newline at end of file
diff --git a/test/index.js b/test/index.js
index f12bdc9..ce07b19 100644
--- a/test/index.js
+++ b/test/index.js
@@ -4,14 +4,14 @@
  * Test dependencies.
  */
 
-var mpath = require('../')
-var assert = require('assert')
+const mpath = require('../');
+const assert = require('assert');
 
 /**
  * logging helper
  */
 
-function log (o) {
+function log(o) {
   console.log();
   console.log(require('util').inspect(o, false, 1000));
 }
@@ -20,91 +20,91 @@ function log (o) {
  * special path for override tests
  */
 
-var special = '_doc';
+const special = '_doc';
 
 /**
  * Tests
  */
 
-describe('mpath', function(){
+describe('mpath', function() {
 
   /**
    * test doc creator
    */
 
-  function doc () {
-    var o = { first: { second: { third: [3,{ name: 'aaron' }, 9] }}};
+  function doc() {
+    const o = { first: { second: { third: [3, { name: 'aaron' }, 9] } } };
     o.comments = [
-        { name: 'one' }
-      , { name: 'two', _doc: { name: '2' }}
-      , { name: 'three'
-          , comments: [{},{ comments: [{val: 'twoo'}]}]
-          , _doc: { name: '3', comments: [{},{ _doc: { comments: [{ val: 2 }] }}]  }}
+      { name: 'one' },
+      { name: 'two', _doc: { name: '2' } },
+      { name: 'three',
+        comments: [{}, { comments: [{ val: 'twoo' }] }],
+        _doc: { name: '3', comments: [{}, { _doc: { comments: [{ val: 2 }] } }] } }
     ];
     o.name = 'jiro';
     o.array = [
-        { o: { array: [{x: {b: [4,6,8]}}, { y: 10} ] }}
-      , { o: { array: [{x: {b: [1,2,3]}}, { x: {z: 10 }}, { x: {b: 'hi'}}] }}
-      , { o: { array: [{x: {b: null }}, { x: { b: [null, 1]}}] }}
-      , { o: { array: [{x: null }] }}
-      , { o: { array: [{y: 3 }] }}
-      , { o: { array: [3, 0, null] }}
-      , { o: { name: 'ha' }}
+      { o: { array: [{ x: { b: [4, 6, 8] } }, { y: 10 }] } },
+      { o: { array: [{ x: { b: [1, 2, 3] } }, { x: { z: 10 } }, { x: { b: 'hi' } }] } },
+      { o: { array: [{ x: { b: null } }, { x: { b: [null, 1] } }] } },
+      { o: { array: [{ x: null }] } },
+      { o: { array: [{ y: 3 }] } },
+      { o: { array: [3, 0, null] } },
+      { o: { name: 'ha' } }
     ];
     o.arr = [
-        { arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-      , { yep: true }
-    ]
+      { arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+      { yep: true }
+    ];
     return o;
   }
 
-  describe('get', function(){
-    var o = doc();
+  describe('get', function() {
+    const o = doc();
 
-    it('`path` must be a string or array', function(done){
-      assert.throws(function () {
+    it('`path` must be a string or array', function(done) {
+      assert.throws(function() {
         mpath.get({}, o);
       }, /Must be either string or array/);
-      assert.throws(function () {
+      assert.throws(function() {
         mpath.get(4, o);
       }, /Must be either string or array/);
-      assert.throws(function () {
-        mpath.get(function(){}, o);
+      assert.throws(function() {
+        mpath.get(function() {}, o);
       }, /Must be either string or array/);
-      assert.throws(function () {
+      assert.throws(function() {
         mpath.get(/asdf/, o);
       }, /Must be either string or array/);
-      assert.throws(function () {
+      assert.throws(function() {
         mpath.get(Math, o);
       }, /Must be either string or array/);
-      assert.throws(function () {
+      assert.throws(function() {
         mpath.get(Buffer, o);
       }, /Must be either string or array/);
-      assert.doesNotThrow(function () {
+      assert.doesNotThrow(function() {
         mpath.get('string', o);
       });
-      assert.doesNotThrow(function () {
+      assert.doesNotThrow(function() {
         mpath.get([], o);
       });
       done();
-    })
+    });
 
-    describe('without `special`', function(){
-      it('works', function(done){
+    describe('without `special`', function() {
+      it('works', function(done) {
         assert.equal('jiro', mpath.get('name', o));
 
         assert.deepEqual(
-          { second: { third: [3,{ name: 'aaron' }, 9] }}
+          { second: { third: [3, { name: 'aaron' }, 9] } }
           , mpath.get('first', o)
         );
 
         assert.deepEqual(
-          { third: [3,{ name: 'aaron' }, 9] }
+          { third: [3, { name: 'aaron' }, 9] }
           , mpath.get('first.second', o)
         );
 
         assert.deepEqual(
-          [3,{ name: 'aaron' }, 9]
+          [3, { name: 'aaron' }, 9]
           , mpath.get('first.second.third', o)
         );
 
@@ -129,262 +129,262 @@ describe('mpath', function(){
         );
 
         assert.deepEqual([
-            { name: 'one' }
-          , { name: 'two', _doc: { name: '2' }}
-          , { name: 'three'
-            , comments: [{},{ comments: [{val: 'twoo'}]}]
-            , _doc: { name: '3', comments: [{},{ _doc: { comments: [{ val: 2 }] }}]}}],
-          mpath.get('comments', o));
+          { name: 'one' },
+          { name: 'two', _doc: { name: '2' } },
+          { name: 'three',
+            comments: [{}, { comments: [{ val: 'twoo' }] }],
+            _doc: { name: '3', comments: [{}, { _doc: { comments: [{ val: 2 }] } }] } }],
+        mpath.get('comments', o));
 
         assert.deepEqual({ name: 'one' }, mpath.get('comments.0', o));
         assert.deepEqual('one', mpath.get('comments.0.name', o));
         assert.deepEqual('two', mpath.get('comments.1.name', o));
         assert.deepEqual('three', mpath.get('comments.2.name', o));
 
-        assert.deepEqual([{},{ comments: [{val: 'twoo'}]}]
-            , mpath.get('comments.2.comments', o));
+        assert.deepEqual([{}, { comments: [{ val: 'twoo' }] }]
+          , mpath.get('comments.2.comments', o));
 
-        assert.deepEqual({ comments: [{val: 'twoo'}]}
-            , mpath.get('comments.2.comments.1', o));
+        assert.deepEqual({ comments: [{ val: 'twoo' }] }
+          , mpath.get('comments.2.comments.1', o));
 
         assert.deepEqual('twoo', mpath.get('comments.2.comments.1.comments.0.val', o));
 
         done();
-      })
+      });
 
-      it('handles array.property dot-notation', function(done){
+      it('handles array.property dot-notation', function(done) {
         assert.deepEqual(
-            ['one', 'two', 'three']
+          ['one', 'two', 'three']
           , mpath.get('comments.name', o)
         );
         done();
-      })
+      });
 
-      it('handles array.array notation', function(done){
+      it('handles array.array notation', function(done) {
         assert.deepEqual(
-            [undefined, undefined, [{}, {comments:[{val:'twoo'}]}]]
+          [undefined, undefined, [{}, { comments: [{ val: 'twoo' }] }]]
           , mpath.get('comments.comments', o)
         );
         done();
-      })
+      });
 
-      it('handles prop.prop.prop.arrayProperty notation', function(done){
+      it('handles prop.prop.prop.arrayProperty notation', function(done) {
         assert.deepEqual(
           [undefined, 'aaron', undefined]
           , mpath.get('first.second.third.name', o)
         );
         assert.deepEqual(
           [1, 'aaron', 1]
-          , mpath.get('first.second.third.name', o, function (v) {
+          , mpath.get('first.second.third.name', o, function(v) {
             return undefined === v ? 1 : v;
           })
         );
         done();
-      })
+      });
 
-      it('handles array.prop.array', function(done){
+      it('handles array.prop.array', function(done) {
         assert.deepEqual(
-            [ [{x: {b: [4,6,8]}}, { y: 10} ]
-            , [{x: {b: [1,2,3]}}, { x: {z: 10 }}, { x: {b: 'hi'}}]
-            , [{x: {b: null }}, { x: { b: [null, 1]}}]
-            , [{x: null }]
-            , [{y: 3 }]
-            , [3, 0, null]
-            , undefined
-            ]
+          [[{ x: { b: [4, 6, 8] } }, { y: 10 }],
+            [{ x: { b: [1, 2, 3] } }, { x: { z: 10 } }, { x: { b: 'hi' } }],
+            [{ x: { b: null } }, { x: { b: [null, 1] } }],
+            [{ x: null }],
+            [{ y: 3 }],
+            [3, 0, null],
+            undefined
+          ]
           , mpath.get('array.o.array', o)
         );
         done();
-      })
+      });
 
-      it('handles array.prop.array.index', function(done){
+      it('handles array.prop.array.index', function(done) {
         assert.deepEqual(
-            [ {x: {b: [4,6,8]}}
-            , {x: {b: [1,2,3]}}
-            , {x: {b: null }}
-            , {x: null }
-            , {y: 3 }
-            , 3
-            , undefined
-            ]
+          [{ x: { b: [4, 6, 8] } },
+            { x: { b: [1, 2, 3] } },
+            { x: { b: null } },
+            { x: null },
+            { y: 3 },
+            3,
+            undefined
+          ]
           , mpath.get('array.o.array.0', o)
         );
         done();
-      })
+      });
 
-      it('handles array.prop.array.index.prop', function(done){
+      it('handles array.prop.array.index.prop', function(done) {
         assert.deepEqual(
-            [ {b: [4,6,8]}
-            , {b: [1,2,3]}
-            , {b: null }
-            , null
-            , undefined
-            , undefined
-            , undefined
-            ]
+          [{ b: [4, 6, 8] },
+            { b: [1, 2, 3] },
+            { b: null },
+            null,
+            undefined,
+            undefined,
+            undefined
+          ]
           , mpath.get('array.o.array.0.x', o)
         );
         done();
-      })
+      });
 
-      it('handles array.prop.array.prop', function(done){
+      it('handles array.prop.array.prop', function(done) {
         assert.deepEqual(
-            [ [undefined, 10 ]
-            , [undefined, undefined, undefined]
-            , [undefined, undefined]
-            , [undefined]
-            , [3]
-            , [undefined, undefined, undefined]
-            , undefined
-            ]
+          [[undefined, 10],
+            [undefined, undefined, undefined],
+            [undefined, undefined],
+            [undefined],
+            [3],
+            [undefined, undefined, undefined],
+            undefined
+          ]
           , mpath.get('array.o.array.y', o)
         );
         assert.deepEqual(
-            [ [{b: [4,6,8]}, undefined]
-            , [{b: [1,2,3]},  {z: 10 }, {b: 'hi'}]
-            , [{b: null }, { b: [null, 1]}]
-            , [null]
-            , [undefined]
-            , [undefined, undefined, undefined]
-            , undefined
-            ]
+          [[{ b: [4, 6, 8] }, undefined],
+            [{ b: [1, 2, 3] }, { z: 10 }, { b: 'hi' }],
+            [{ b: null }, { b: [null, 1] }],
+            [null],
+            [undefined],
+            [undefined, undefined, undefined],
+            undefined
+          ]
           , mpath.get('array.o.array.x', o)
         );
         done();
-      })
+      });
 
-      it('handles array.prop.array.prop.prop', function(done){
+      it('handles array.prop.array.prop.prop', function(done) {
         assert.deepEqual(
-            [ [[4,6,8], undefined]
-            , [[1,2,3], undefined, 'hi']
-            , [null, [null, 1]]
-            , [null]
-            , [undefined]
-            , [undefined, undefined, undefined]
-            , undefined
-            ]
+          [[[4, 6, 8], undefined],
+            [[1, 2, 3], undefined, 'hi'],
+            [null, [null, 1]],
+            [null],
+            [undefined],
+            [undefined, undefined, undefined],
+            undefined
+          ]
           , mpath.get('array.o.array.x.b', o)
         );
         done();
-      })
+      });
 
-      it('handles array.prop.array.prop.prop.index', function(done){
+      it('handles array.prop.array.prop.prop.index', function(done) {
         assert.deepEqual(
-            [ [6, undefined]
-            , [2, undefined, 'i'] // undocumented feature (string indexing)
-            , [null, 1]
-            , [null]
-            , [undefined]
-            , [undefined, undefined, undefined]
-            , undefined
-            ]
+          [[6, undefined],
+            [2, undefined, 'i'], // undocumented feature (string indexing)
+            [null, 1],
+            [null],
+            [undefined],
+            [undefined, undefined, undefined],
+            undefined
+          ]
           , mpath.get('array.o.array.x.b.1', o)
         );
         assert.deepEqual(
-            [ [6, 0]
-            , [2, 0, 'i'] // undocumented feature (string indexing)
-            , [null, 1]
-            , [null]
-            , [0]
-            , [0, 0, 0]
-            , 0
-            ]
-          , mpath.get('array.o.array.x.b.1', o, function (v) {
+          [[6, 0],
+            [2, 0, 'i'], // undocumented feature (string indexing)
+            [null, 1],
+            [null],
+            [0],
+            [0, 0, 0],
+            0
+          ]
+          , mpath.get('array.o.array.x.b.1', o, function(v) {
             return undefined === v ? 0 : v;
           })
         );
         done();
-      })
+      });
 
-      it('handles array.index.prop.prop', function(done){
+      it('handles array.index.prop.prop', function(done) {
         assert.deepEqual(
-            [{x: {b: [1,2,3]}}, { x: {z: 10 }}, { x: {b: 'hi'}}]
+          [{ x: { b: [1, 2, 3] } }, { x: { z: 10 } }, { x: { b: 'hi' } }]
           , mpath.get('array.1.o.array', o)
         );
         assert.deepEqual(
-            ['hi','hi','hi']
-          , mpath.get('array.1.o.array', o, function (v) {
+          ['hi', 'hi', 'hi']
+          , mpath.get('array.1.o.array', o, function(v) {
             if (Array.isArray(v)) {
-              return v.map(function (val) {
+              return v.map(function(val) {
                 return 'hi';
-              })
+              });
             }
             return v;
           })
         );
         done();
-      })
+      });
 
-      it('handles array.array.index', function(done){
+      it('handles array.array.index', function(done) {
         assert.deepEqual(
-            [{ a: { c: 48 }}, undefined]
+          [{ a: { c: 48 } }, undefined]
           , mpath.get('arr.arr.1', o)
         );
         assert.deepEqual(
-            ['woot', undefined]
-          , mpath.get('arr.arr.1', o, function (v) {
+          ['woot', undefined]
+          , mpath.get('arr.arr.1', o, function(v) {
             if (v && v.a && v.a.c) return 'woot';
             return v;
           })
         );
         done();
-      })
+      });
 
-      it('handles array.array.index.prop', function(done){
+      it('handles array.array.index.prop', function(done) {
         assert.deepEqual(
-            [{ c: 48 }, 'woot']
-          , mpath.get('arr.arr.1.a', o, function (v) {
+          [{ c: 48 }, 'woot']
+          , mpath.get('arr.arr.1.a', o, function(v) {
             if (undefined === v) return 'woot';
             return v;
           })
         );
         assert.deepEqual(
-            [{ c: 48 }, undefined]
+          [{ c: 48 }, undefined]
           , mpath.get('arr.arr.1.a', o)
         );
-        mpath.set('arr.arr.1.a', [{c:49},undefined], o)
+        mpath.set('arr.arr.1.a', [{ c: 49 }, undefined], o);
         assert.deepEqual(
-            [{ c: 49 }, undefined]
+          [{ c: 49 }, undefined]
           , mpath.get('arr.arr.1.a', o)
         );
-        mpath.set('arr.arr.1.a', [{c:48},undefined], o)
+        mpath.set('arr.arr.1.a', [{ c: 48 }, undefined], o);
         done();
-      })
+      });
 
-      it('handles array.array.index.prop.prop', function(done){
+      it('handles array.array.index.prop.prop', function(done) {
         assert.deepEqual(
-            [48, undefined]
+          [48, undefined]
           , mpath.get('arr.arr.1.a.c', o)
         );
         assert.deepEqual(
-            [48, 'woot']
-          , mpath.get('arr.arr.1.a.c', o, function (v) {
+          [48, 'woot']
+          , mpath.get('arr.arr.1.a.c', o, function(v) {
             if (undefined === v) return 'woot';
             return v;
           })
         );
         done();
-      })
+      });
 
-    })
+    });
 
-    describe('with `special`', function(){
-      describe('that is a string', function(){
-        it('works', function(done){
+    describe('with `special`', function() {
+      describe('that is a string', function() {
+        it('works', function(done) {
           assert.equal('jiro', mpath.get('name', o, special));
 
           assert.deepEqual(
-            { second: { third: [3,{ name: 'aaron' }, 9] }}
+            { second: { third: [3, { name: 'aaron' }, 9] } }
             , mpath.get('first', o, special)
           );
 
           assert.deepEqual(
-            { third: [3,{ name: 'aaron' }, 9] }
+            { third: [3, { name: 'aaron' }, 9] }
             , mpath.get('first.second', o, special)
           );
 
           assert.deepEqual(
-            [3,{ name: 'aaron' }, 9]
+            [3, { name: 'aaron' }, 9]
             , mpath.get('first.second.third', o, special)
           );
 
@@ -395,7 +395,7 @@ describe('mpath', function(){
 
           assert.deepEqual(
             4
-            , mpath.get('first.second.third.0', o, special, function (v) {
+            , mpath.get('first.second.third.0', o, special, function(v) {
               return 3 === v ? 4 : v;
             })
           );
@@ -416,96 +416,96 @@ describe('mpath', function(){
           );
 
           assert.deepEqual([
-              { name: 'one' }
-            , { name: 'two', _doc: { name: '2' }}
-            , { name: 'three'
-              , comments: [{},{ comments: [{val: 'twoo'}]}]
-              , _doc: { name: '3', comments: [{},{ _doc: { comments: [{ val: 2 }] }}]}}],
-            mpath.get('comments', o, special));
+            { name: 'one' },
+            { name: 'two', _doc: { name: '2' } },
+            { name: 'three',
+              comments: [{}, { comments: [{ val: 'twoo' }] }],
+              _doc: { name: '3', comments: [{}, { _doc: { comments: [{ val: 2 }] } }] } }],
+          mpath.get('comments', o, special));
 
           assert.deepEqual({ name: 'one' }, mpath.get('comments.0', o, special));
           assert.deepEqual('one', mpath.get('comments.0.name', o, special));
           assert.deepEqual('2', mpath.get('comments.1.name', o, special));
           assert.deepEqual('3', mpath.get('comments.2.name', o, special));
-          assert.deepEqual('nice', mpath.get('comments.2.name', o, special, function (v) {
+          assert.deepEqual('nice', mpath.get('comments.2.name', o, special, function(v) {
             return '3' === v ? 'nice' : v;
           }));
 
-          assert.deepEqual([{},{ _doc: { comments: [{ val: 2 }] }}]
-              , mpath.get('comments.2.comments', o, special));
+          assert.deepEqual([{}, { _doc: { comments: [{ val: 2 }] } }]
+            , mpath.get('comments.2.comments', o, special));
 
-          assert.deepEqual({ _doc: { comments: [{val: 2}]}}
-              , mpath.get('comments.2.comments.1', o, special));
+          assert.deepEqual({ _doc: { comments: [{ val: 2 }] } }
+            , mpath.get('comments.2.comments.1', o, special));
 
           assert.deepEqual(2, mpath.get('comments.2.comments.1.comments.0.val', o, special));
           done();
-        })
+        });
 
-        it('handles array.property dot-notation', function(done){
+        it('handles array.property dot-notation', function(done) {
           assert.deepEqual(
             ['one', '2', '3']
             , mpath.get('comments.name', o, special)
           );
           assert.deepEqual(
             ['one', 2, '3']
-            , mpath.get('comments.name', o, special, function (v) {
-              return '2' === v ? 2 : v
+            , mpath.get('comments.name', o, special, function(v) {
+              return '2' === v ? 2 : v;
             })
           );
           done();
-        })
+        });
 
-        it('handles array.array notation', function(done){
+        it('handles array.array notation', function(done) {
           assert.deepEqual(
-              [undefined, undefined, [{}, {_doc: { comments:[{val:2}]}}]]
+            [undefined, undefined, [{}, { _doc: { comments: [{ val: 2 }] } }]]
             , mpath.get('comments.comments', o, special)
           );
           done();
-        })
+        });
 
-        it('handles array.array.index.array', function(done){
+        it('handles array.array.index.array', function(done) {
           assert.deepEqual(
-              [undefined, undefined, [{val:2}]]
+            [undefined, undefined, [{ val: 2 }]]
             , mpath.get('comments.comments.1.comments', o, special)
           );
           done();
-        })
+        });
 
-        it('handles array.array.index.array.prop', function(done){
+        it('handles array.array.index.array.prop', function(done) {
           assert.deepEqual(
-              [undefined, undefined, [2]]
+            [undefined, undefined, [2]]
             , mpath.get('comments.comments.1.comments.val', o, special)
           );
           assert.deepEqual(
-              ['nil', 'nil', [2]]
-            , mpath.get('comments.comments.1.comments.val', o, special, function (v) {
+            ['nil', 'nil', [2]]
+            , mpath.get('comments.comments.1.comments.val', o, special, function(v) {
               return undefined === v ? 'nil' : v;
             })
           );
           done();
-        })
-      })
+        });
+      });
 
-      describe('that is a function', function(){
-        var special = function (obj, key) {
-          return obj[key]
-        }
+      describe('that is a function', function() {
+        const special = function(obj, key) {
+          return obj[key];
+        };
 
-        it('works', function(done){
+        it('works', function(done) {
           assert.equal('jiro', mpath.get('name', o, special));
 
           assert.deepEqual(
-            { second: { third: [3,{ name: 'aaron' }, 9] }}
+            { second: { third: [3, { name: 'aaron' }, 9] } }
             , mpath.get('first', o, special)
           );
 
           assert.deepEqual(
-            { third: [3,{ name: 'aaron' }, 9] }
+            { third: [3, { name: 'aaron' }, 9] }
             , mpath.get('first.second', o, special)
           );
 
           assert.deepEqual(
-            [3,{ name: 'aaron' }, 9]
+            [3, { name: 'aaron' }, 9]
             , mpath.get('first.second.third', o, special)
           );
 
@@ -516,7 +516,7 @@ describe('mpath', function(){
 
           assert.deepEqual(
             4
-            , mpath.get('first.second.third.0', o, special, function (v) {
+            , mpath.get('first.second.third.0', o, special, function(v) {
               return 3 === v ? 4 : v;
             })
           );
@@ -537,31 +537,31 @@ describe('mpath', function(){
           );
 
           assert.deepEqual([
-              { name: 'one' }
-            , { name: 'two', _doc: { name: '2' }}
-            , { name: 'three'
-              , comments: [{},{ comments: [{val: 'twoo'}]}]
-              , _doc: { name: '3', comments: [{},{ _doc: { comments: [{ val: 2 }] }}]}}],
-            mpath.get('comments', o, special));
+            { name: 'one' },
+            { name: 'two', _doc: { name: '2' } },
+            { name: 'three',
+              comments: [{}, { comments: [{ val: 'twoo' }] }],
+              _doc: { name: '3', comments: [{}, { _doc: { comments: [{ val: 2 }] } }] } }],
+          mpath.get('comments', o, special));
 
           assert.deepEqual({ name: 'one' }, mpath.get('comments.0', o, special));
           assert.deepEqual('one', mpath.get('comments.0.name', o, special));
           assert.deepEqual('two', mpath.get('comments.1.name', o, special));
           assert.deepEqual('three', mpath.get('comments.2.name', o, special));
-          assert.deepEqual('nice', mpath.get('comments.2.name', o, special, function (v) {
+          assert.deepEqual('nice', mpath.get('comments.2.name', o, special, function(v) {
             return 'three' === v ? 'nice' : v;
           }));
 
-          assert.deepEqual([{},{ comments: [{ val: 'twoo' }] }]
-              , mpath.get('comments.2.comments', o, special));
+          assert.deepEqual([{}, { comments: [{ val: 'twoo' }] }]
+            , mpath.get('comments.2.comments', o, special));
 
-          assert.deepEqual({ comments: [{val: 'twoo'}]}
-              , mpath.get('comments.2.comments.1', o, special));
+          assert.deepEqual({ comments: [{ val: 'twoo' }] }
+            , mpath.get('comments.2.comments.1', o, special));
 
           assert.deepEqual('twoo', mpath.get('comments.2.comments.1.comments.0.val', o, special));
 
-          var overide = false;
-          assert.deepEqual('twoo', mpath.get('comments.8.comments.1.comments.0.val', o, function (obj, path) {
+          let overide = false;
+          assert.deepEqual('twoo', mpath.get('comments.8.comments.1.comments.0.val', o, function(obj, path) {
             if (Array.isArray(obj) && 8 == path) {
               overide = true;
               return obj[2];
@@ -571,30 +571,30 @@ describe('mpath', function(){
           assert.ok(overide);
 
           done();
-        })
+        });
 
-        it('in combination with map', function(done){
-          var special = function (obj, key) {
+        it('in combination with map', function(done) {
+          const special = function(obj, key) {
             if (Array.isArray(obj)) return obj[key];
             return obj.mpath;
-          }
-          var map = function (val) {
+          };
+          const map = function(val) {
             return 'convert' == val
               ? 'mpath'
               : val;
-          }
-          var o = { mpath: [{ mpath: 'converse' }, { mpath: 'convert' }] }
+          };
+          const o = { mpath: [{ mpath: 'converse' }, { mpath: 'convert' }] };
 
           assert.equal('mpath', mpath.get('something.1.kewl', o, special, map));
           done();
-        })
-      })
-    })
-  })
+        });
+      });
+    });
+  });
 
   describe('set', function() {
     it('prevents writing to __proto__', function() {
-      var obj = {};
+      const obj = {};
       mpath.set('__proto__.x', 'foobar', obj);
       assert.ok(!({}.x));
 
@@ -603,7 +603,7 @@ describe('mpath', function(){
     });
 
     describe('without `special`', function() {
-      var o = doc();
+      const o = doc();
 
       it('works', function(done) {
         mpath.set('name', 'a new val', o, function(v) {
@@ -614,435 +614,435 @@ describe('mpath', function(){
         mpath.set('name', 'changed', o);
         assert.deepEqual('changed', o.name);
 
-        mpath.set('first.second.third', [1,{name:'x'},9], o);
-        assert.deepEqual([1,{name:'x'},9], o.first.second.third);
+        mpath.set('first.second.third', [1, { name: 'x' }, 9], o);
+        assert.deepEqual([1, { name: 'x' }, 9], o.first.second.third);
 
-        mpath.set('first.second.third.1.name', 'y', o)
-        assert.deepEqual([1,{name:'y'},9], o.first.second.third);
+        mpath.set('first.second.third.1.name', 'y', o);
+        assert.deepEqual([1, { name: 'y' }, 9], o.first.second.third);
 
         mpath.set('comments.1.name', 'ttwwoo', o);
-        assert.deepEqual({ name: 'ttwwoo', _doc: { name: '2' }}, o.comments[1]);
+        assert.deepEqual({ name: 'ttwwoo', _doc: { name: '2' } }, o.comments[1]);
 
         mpath.set('comments.2.comments.1.comments.0.expand', 'added', o);
         assert.deepEqual(
-            { val: 'twoo', expand: 'added'}
+          { val: 'twoo', expand: 'added' }
           , o.comments[2].comments[1].comments[0]);
 
         mpath.set('comments.2.comments.1.comments.2', 'added', o);
         assert.equal(3, o.comments[2].comments[1].comments.length);
         assert.deepEqual(
-            { val: 'twoo', expand: 'added'}
+          { val: 'twoo', expand: 'added' }
           , o.comments[2].comments[1].comments[0]);
         assert.deepEqual(
-            undefined
+          undefined
           , o.comments[2].comments[1].comments[1]);
         assert.deepEqual(
-            'added'
+          'added'
           , o.comments[2].comments[1].comments[2]);
 
         done();
-      })
+      });
 
-      describe('array.path', function(){
-        describe('with single non-array value', function(){
-          it('works', function(done){
-            mpath.set('arr.yep', false, o, function (v) {
-              return false === v ? true: v;
+      describe('array.path', function() {
+        describe('with single non-array value', function() {
+          it('works', function(done) {
+            mpath.set('arr.yep', false, o, function(v) {
+              return false === v ? true : v;
             });
             assert.deepEqual([
-              { yep: true, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-            , { yep: true }
+              { yep: true, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+              { yep: true }
             ], o.arr);
 
             mpath.set('arr.yep', false, o);
 
             assert.deepEqual([
-              { yep: false, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-            , { yep: false }
+              { yep: false, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+              { yep: false }
             ], o.arr);
 
             done();
-          })
-        })
-        describe('with array of values', function(){
-          it('that are equal in length', function(done){
-            mpath.set('arr.yep', ['one',2], o, function (v) {
+          });
+        });
+        describe('with array of values', function() {
+          it('that are equal in length', function(done) {
+            mpath.set('arr.yep', ['one', 2], o, function(v) {
               return 'one' === v ? 1 : v;
             });
             assert.deepEqual([
-              { yep: 1, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-            , { yep: 2 }
+              { yep: 1, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+              { yep: 2 }
             ], o.arr);
-            mpath.set('arr.yep', ['one',2], o);
+            mpath.set('arr.yep', ['one', 2], o);
 
             assert.deepEqual([
-              { yep: 'one', arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-            , { yep: 2 }
+              { yep: 'one', arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+              { yep: 2 }
             ], o.arr);
 
             done();
-          })
+          });
 
-          it('that is less than length', function(done){
-            mpath.set('arr.yep', [47], o, function (v) {
+          it('that is less than length', function(done) {
+            mpath.set('arr.yep', [47], o, function(v) {
               return 47 === v ? 4 : v;
             });
             assert.deepEqual([
-              { yep: 4, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-            , { yep: 2 }
+              { yep: 4, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+              { yep: 2 }
             ], o.arr);
 
             mpath.set('arr.yep', [47], o);
             assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-            , { yep: 2 }
+              { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+              { yep: 2 }
             ], o.arr);
 
             done();
-          })
+          });
 
-          it('that is greater than length', function(done){
-            mpath.set('arr.yep', [5,6,7], o, function (v) {
+          it('that is greater than length', function(done) {
+            mpath.set('arr.yep', [5, 6, 7], o, function(v) {
               return 5 === v ? 'five' : v;
             });
             assert.deepEqual([
-              { yep: 'five', arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-            , { yep: 6 }
+              { yep: 'five', arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+              { yep: 6 }
             ], o.arr);
 
-            mpath.set('arr.yep', [5,6,7], o);
+            mpath.set('arr.yep', [5, 6, 7], o);
             assert.deepEqual([
-              { yep: 5, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-            , { yep: 6 }
+              { yep: 5, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+              { yep: 6 }
             ], o.arr);
 
             done();
-          })
-        })
-      })
+          });
+        });
+      });
 
-      describe('array.$.path', function(){
-        describe('with single non-array value', function(){
-          it('copies the value to each item in array', function(done){
-            mpath.set('arr.$.yep', {xtra: 'double good'}, o, function (v) {
+      describe('array.$.path', function() {
+        describe('with single non-array value', function() {
+          it('copies the value to each item in array', function(done) {
+            mpath.set('arr.$.yep', { xtra: 'double good' }, o, function(v) {
               return v && v.xtra ? 'hi' : v;
             });
             assert.deepEqual([
-              { yep: 'hi', arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-            , { yep: 'hi'}
+              { yep: 'hi', arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+              { yep: 'hi' }
             ], o.arr);
 
-            mpath.set('arr.$.yep', {xtra: 'double good'}, o);
+            mpath.set('arr.$.yep', { xtra: 'double good' }, o);
             assert.deepEqual([
-              { yep: {xtra:'double good'}, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-            , { yep: {xtra:'double good'}}
+              { yep: { xtra: 'double good' }, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+              { yep: { xtra: 'double good' } }
             ], o.arr);
 
             done();
-          })
-        })
-        describe('with array of values', function(){
-          it('copies the value to each item in array', function(done){
-            mpath.set('arr.$.yep', [15], o, function (v) {
+          });
+        });
+        describe('with array of values', function() {
+          it('copies the value to each item in array', function(done) {
+            mpath.set('arr.$.yep', [15], o, function(v) {
               return v.length === 1 ? [] : v;
             });
             assert.deepEqual([
-              { yep: [], arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-            , { yep: []}
+              { yep: [], arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+              { yep: [] }
             ], o.arr);
 
             mpath.set('arr.$.yep', [15], o);
             assert.deepEqual([
-              { yep: [15], arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-            , { yep: [15]}
+              { yep: [15], arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+              { yep: [15] }
             ], o.arr);
 
             done();
-          })
-        })
-      })
+          });
+        });
+      });
 
-      describe('array.index.path', function(){
-        it('works', function(done){
-          mpath.set('arr.1.yep', 0, o, function (v) {
+      describe('array.index.path', function() {
+        it('works', function(done) {
+          mpath.set('arr.1.yep', 0, o, function(v) {
             return 0 === v ? 'zero' : v;
           });
           assert.deepEqual([
-            { yep: [15] , arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-          , { yep: 'zero' }
+            { yep: [15], arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+            { yep: 'zero' }
           ], o.arr);
 
           mpath.set('arr.1.yep', 0, o);
           assert.deepEqual([
-            { yep: [15] , arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-          , { yep: 0 }
+            { yep: [15], arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+            { yep: 0 }
           ], o.arr);
 
           done();
-        })
-      })
+        });
+      });
 
-      describe('array.index.array.path', function(){
-        it('with single value', function(done){
-          mpath.set('arr.0.arr.e', 35, o, function (v) {
+      describe('array.index.array.path', function() {
+        it('with single value', function(done) {
+          mpath.set('arr.0.arr.e', 35, o, function(v) {
             return 35 === v ? 3 : v;
           });
           assert.deepEqual([
-            { yep: [15], arr: [{ a: { b: 47 }, e: 3}, { a: { c: 48 }, e: 3}, { d: 'yep', e: 3 }] }
-          , { yep: 0 }
+            { yep: [15], arr: [{ a: { b: 47 }, e: 3 }, { a: { c: 48 }, e: 3 }, { d: 'yep', e: 3 }] },
+            { yep: 0 }
           ], o.arr);
 
           mpath.set('arr.0.arr.e', 35, o);
           assert.deepEqual([
-            { yep: [15], arr: [{ a: { b: 47 }, e: 35}, { a: { c: 48 }, e: 35}, { d: 'yep', e: 35 }] }
-          , { yep: 0 }
+            { yep: [15], arr: [{ a: { b: 47 }, e: 35 }, { a: { c: 48 }, e: 35 }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
           done();
-        })
-        it('with array', function(done){
-          mpath.set('arr.0.arr.e', ['a','b'], o, function (v) {
+        });
+        it('with array', function(done) {
+          mpath.set('arr.0.arr.e', ['a', 'b'], o, function(v) {
             return 'a' === v ? 'x' : v;
           });
           assert.deepEqual([
-            { yep: [15], arr: [{ a: { b: 47 }, e: 'x'}, { a: { c: 48 }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0 }
+            { yep: [15], arr: [{ a: { b: 47 }, e: 'x' }, { a: { c: 48 }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
-          mpath.set('arr.0.arr.e', ['a','b'], o);
+          mpath.set('arr.0.arr.e', ['a', 'b'], o);
           assert.deepEqual([
-            { yep: [15], arr: [{ a: { b: 47 }, e: 'a'}, { a: { c: 48 }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0 }
+            { yep: [15], arr: [{ a: { b: 47 }, e: 'a' }, { a: { c: 48 }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
           done();
-        })
-      })
+        });
+      });
 
-      describe('array.index.array.path.path', function(){
-        it('with single value', function(done){
-          mpath.set('arr.0.arr.a.b', 36, o, function (v) {
+      describe('array.index.array.path.path', function() {
+        it('with single value', function(done) {
+          mpath.set('arr.0.arr.a.b', 36, o, function(v) {
             return 36 === v ? 3 : v;
           });
           assert.deepEqual([
-            { yep: [15], arr: [{ a: { b: 3 }, e: 'a'}, { a: { c: 48, b: 3 }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0 }
+            { yep: [15], arr: [{ a: { b: 3 }, e: 'a' }, { a: { c: 48, b: 3 }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
           mpath.set('arr.0.arr.a.b', 36, o);
           assert.deepEqual([
-            { yep: [15], arr: [{ a: { b: 36 }, e: 'a'}, { a: { c: 48, b: 36 }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0 }
+            { yep: [15], arr: [{ a: { b: 36 }, e: 'a' }, { a: { c: 48, b: 36 }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
           done();
-        })
-        it('with array', function(done){
-          mpath.set('arr.0.arr.a.b', [1,2,3,4], o, function (v) {
+        });
+        it('with array', function(done) {
+          mpath.set('arr.0.arr.a.b', [1, 2, 3, 4], o, function(v) {
             return 2 === v ? 'two' : v;
           });
           assert.deepEqual([
-            { yep: [15], arr: [{ a: { b: 1 }, e: 'a'}, { a: { c: 48, b: 'two' }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0 }
+            { yep: [15], arr: [{ a: { b: 1 }, e: 'a' }, { a: { c: 48, b: 'two' }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
-          mpath.set('arr.0.arr.a.b', [1,2,3,4], o);
+          mpath.set('arr.0.arr.a.b', [1, 2, 3, 4], o);
           assert.deepEqual([
-            { yep: [15], arr: [{ a: { b: 1 }, e: 'a'}, { a: { c: 48, b: 2 }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0 }
+            { yep: [15], arr: [{ a: { b: 1 }, e: 'a' }, { a: { c: 48, b: 2 }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
           done();
-        })
-      })
+        });
+      });
 
-      describe('array.index.array.$.path.path', function(){
-        it('with single value', function(done){
-          mpath.set('arr.0.arr.$.a.b', '$', o, function (v) {
+      describe('array.index.array.$.path.path', function() {
+        it('with single value', function(done) {
+          mpath.set('arr.0.arr.$.a.b', '$', o, function(v) {
             return '$' === v ? 'dolla billz' : v;
           });
           assert.deepEqual([
-            { yep: [15], arr: [{ a: { b: 'dolla billz' }, e: 'a'}, { a: { c: 48, b: 'dolla billz' }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0 }
+            { yep: [15], arr: [{ a: { b: 'dolla billz' }, e: 'a' }, { a: { c: 48, b: 'dolla billz' }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
           mpath.set('arr.0.arr.$.a.b', '$', o);
           assert.deepEqual([
-            { yep: [15], arr: [{ a: { b: '$' }, e: 'a'}, { a: { c: 48, b: '$' }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0 }
+            { yep: [15], arr: [{ a: { b: '$' }, e: 'a' }, { a: { c: 48, b: '$' }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
           done();
-        })
-        it('with array', function(done){
-          mpath.set('arr.0.arr.$.a.b', [1], o, function (v) {
+        });
+        it('with array', function(done) {
+          mpath.set('arr.0.arr.$.a.b', [1], o, function(v) {
             return Array.isArray(v) ? {} : v;
           });
           assert.deepEqual([
-            { yep: [15], arr: [{ a: { b: {} }, e: 'a'}, { a: { c: 48, b: {} }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0 }
+            { yep: [15], arr: [{ a: { b: {} }, e: 'a' }, { a: { c: 48, b: {} }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
           mpath.set('arr.0.arr.$.a.b', [1], o);
           assert.deepEqual([
-            { yep: [15], arr: [{ a: { b: [1] }, e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0 }
+            { yep: [15], arr: [{ a: { b: [1] }, e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
           done();
-        })
-      })
+        });
+      });
 
-      describe('array.array.index.path', function(){
-        it('with single value', function(done){
-          mpath.set('arr.arr.0.a', 'single', o, function (v) {
+      describe('array.array.index.path', function() {
+        it('with single value', function(done) {
+          mpath.set('arr.arr.0.a', 'single', o, function(v) {
             return 'single' === v ? 'double' : v;
           });
           assert.deepEqual([
-            { yep: [15], arr: [{ a: 'double', e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0 }
+            { yep: [15], arr: [{ a: 'double', e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
           mpath.set('arr.arr.0.a', 'single', o);
           assert.deepEqual([
-            { yep: [15], arr: [{ a: 'single', e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0 }
+            { yep: [15], arr: [{ a: 'single', e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
           done();
-        })
-        it('with array', function(done){
-          mpath.set('arr.arr.0.a', [4,8,15,16,23,42], o, function (v) {
+        });
+        it('with array', function(done) {
+          mpath.set('arr.arr.0.a', [4, 8, 15, 16, 23, 42], o, function(v) {
             return 4 === v ? 3 : v;
           });
           assert.deepEqual([
-            { yep: [15], arr: [{ a: 3, e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: false }
+            { yep: [15], arr: [{ a: 3, e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: false }
           ], o.arr);
 
-          mpath.set('arr.arr.0.a', [4,8,15,16,23,42], o);
+          mpath.set('arr.arr.0.a', [4, 8, 15, 16, 23, 42], o);
           assert.deepEqual([
-            { yep: [15], arr: [{ a: 4, e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: false }
+            { yep: [15], arr: [{ a: 4, e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: false }
           ], o.arr);
 
           done();
-        })
-      })
+        });
+      });
 
-      describe('array.array.$.index.path', function(){
-        it('with single value', function(done){
-          mpath.set('arr.arr.$.0.a', 'singles', o, function (v) {
+      describe('array.array.$.index.path', function() {
+        it('with single value', function(done) {
+          mpath.set('arr.arr.$.0.a', 'singles', o, function(v) {
             return 0;
           });
           assert.deepEqual([
-            { yep: [15], arr: [{ a: 0, e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0 }
+            { yep: [15], arr: [{ a: 0, e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
           mpath.set('arr.arr.$.0.a', 'singles', o);
           assert.deepEqual([
-            { yep: [15], arr: [{ a: 'singles', e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0 }
+            { yep: [15], arr: [{ a: 'singles', e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
           mpath.set('$.arr.arr.0.a', 'single', o);
           assert.deepEqual([
-            { yep: [15], arr: [{ a: 'single', e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0 }
+            { yep: [15], arr: [{ a: 'single', e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
           done();
-        })
-        it('with array', function(done){
-          mpath.set('arr.arr.$.0.a', [4,8,15,16,23,42], o, function (v) {
-            return 'nope'
+        });
+        it('with array', function(done) {
+          mpath.set('arr.arr.$.0.a', [4, 8, 15, 16, 23, 42], o, function(v) {
+            return 'nope';
           });
           assert.deepEqual([
-            { yep: [15], arr: [{ a: 'nope', e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0}
+            { yep: [15], arr: [{ a: 'nope', e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
-          mpath.set('arr.arr.$.0.a', [4,8,15,16,23,42], o);
+          mpath.set('arr.arr.$.0.a', [4, 8, 15, 16, 23, 42], o);
           assert.deepEqual([
-            { yep: [15], arr: [{ a: [4,8,15,16,23,42], e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0}
+            { yep: [15], arr: [{ a: [4, 8, 15, 16, 23, 42], e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
-          mpath.set('arr.$.arr.0.a', [4,8,15,16,23,42,108], o);
+          mpath.set('arr.$.arr.0.a', [4, 8, 15, 16, 23, 42, 108], o);
           assert.deepEqual([
-            { yep: [15], arr: [{ a: [4,8,15,16,23,42,108], e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0}
+            { yep: [15], arr: [{ a: [4, 8, 15, 16, 23, 42, 108], e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
           done();
-        })
-      })
+        });
+      });
 
-      describe('array.array.path.index', function(){
-        it('with single value', function(done){
-          mpath.set('arr.arr.a.7', 47, o, function (v) {
-            return 1
+      describe('array.array.path.index', function() {
+        it('with single value', function(done) {
+          mpath.set('arr.arr.a.7', 47, o, function(v) {
+            return 1;
           });
           assert.deepEqual([
-            { yep: [15], arr: [{ a: [4,8,15,16,23,42,108,1], e: 'a'}, { a: { c: 48, b: [1], '7': 1 }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0}
+            { yep: [15], arr: [{ a: [4, 8, 15, 16, 23, 42, 108, 1], e: 'a' }, { a: { c: 48, b: [1], 7: 1 }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
           mpath.set('arr.arr.a.7', 47, o);
           assert.deepEqual([
-            { yep: [15], arr: [{ a: [4,8,15,16,23,42,108,47], e: 'a'}, { a: { c: 48, b: [1], '7': 47 }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0}
+            { yep: [15], arr: [{ a: [4, 8, 15, 16, 23, 42, 108, 47], e: 'a' }, { a: { c: 48, b: [1], 7: 47 }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0 }
           ], o.arr);
 
           done();
-        })
-        it('with array', function(done){
+        });
+        it('with array', function(done) {
           o.arr[1].arr = [{ a: [] }, { a: [] }, { a: null }];
-          mpath.set('arr.arr.a.7', [[null,46], [undefined, 'woot']], o);
+          mpath.set('arr.arr.a.7', [[null, 46], [undefined, 'woot']], o);
 
-          var a1 = [];
-          var a2 = [];
+          const a1 = [];
+          const a2 = [];
           a1[7] = undefined;
           a2[7] = 'woot';
 
           assert.deepEqual([
-            { yep: [15], arr: [{ a: [4,8,15,16,23,42,108,null], e: 'a'}, { a: { c: 48, b: [1], '7': 46 }, e: 'b'}, { d: 'yep', e: 35 }] }
-          , { yep: 0, arr: [{a:a1},{a:a2},{a:null}] }
+            { yep: [15], arr: [{ a: [4, 8, 15, 16, 23, 42, 108, null], e: 'a' }, { a: { c: 48, b: [1], 7: 46 }, e: 'b' }, { d: 'yep', e: 35 }] },
+            { yep: 0, arr: [{ a: a1 }, { a: a2 }, { a: null }] }
           ], o.arr);
 
           done();
-        })
-      })
+        });
+      });
 
-      describe('handles array.array.path', function(){
-        it('with single', function(done){
-          o.arr[1].arr = [{},{}];
-          assert.deepEqual([{},{}], o.arr[1].arr);
+      describe('handles array.array.path', function() {
+        it('with single', function(done) {
+          o.arr[1].arr = [{}, {}];
+          assert.deepEqual([{}, {}], o.arr[1].arr);
           o.arr.push({ arr: 'something else' });
           o.arr.push({ arr: ['something else'] });
           o.arr.push({ arr: [[]] });
           o.arr.push({ arr: [5] });
 
-          var weird = [];
+          const weird = [];
           weird.e = 'xmas';
 
           // test
-          mpath.set('arr.arr.e', 47, o, function (v) {
-            return 'xmas'
+          mpath.set('arr.arr.e', 47, o, function(v) {
+            return 'xmas';
           });
           assert.deepEqual([
             { yep: [15], arr: [
-                  { a: [4,8,15,16,23,42,108,null], e: 'xmas'}
-                , { a: { c: 48, b: [1], '7': 46 }, e: 'xmas'}
-                , { d: 'yep', e: 'xmas' }
-              ]
-            }
-          , { yep: 0, arr: [{e: 'xmas'}, {e:'xmas'}] }
-          , { arr: 'something else' }
-          , { arr: ['something else'] }
-          , { arr: [weird] }
-          , { arr: [5] }
+              { a: [4, 8, 15, 16, 23, 42, 108, null], e: 'xmas' },
+              { a: { c: 48, b: [1], 7: 46 }, e: 'xmas' },
+              { d: 'yep', e: 'xmas' }
+            ]
+            },
+            { yep: 0, arr: [{ e: 'xmas' }, { e: 'xmas' }] },
+            { arr: 'something else' },
+            { arr: ['something else'] },
+            { arr: [weird] },
+            { arr: [5] }
           ]
           , o.arr);
 
@@ -1051,73 +1051,73 @@ describe('mpath', function(){
           mpath.set('arr.arr.e', 47, o);
           assert.deepEqual([
             { yep: [15], arr: [
-                  { a: [4,8,15,16,23,42,108,null], e: 47}
-                , { a: { c: 48, b: [1], '7': 46 }, e: 47}
-                , { d: 'yep', e: 47 }
-              ]
-            }
-          , { yep: 0, arr: [{e: 47}, {e:47}] }
-          , { arr: 'something else' }
-          , { arr: ['something else'] }
-          , { arr: [weird] }
-          , { arr: [5] }
+              { a: [4, 8, 15, 16, 23, 42, 108, null], e: 47 },
+              { a: { c: 48, b: [1], 7: 46 }, e: 47 },
+              { d: 'yep', e: 47 }
+            ]
+            },
+            { yep: 0, arr: [{ e: 47 }, { e: 47 }] },
+            { arr: 'something else' },
+            { arr: ['something else'] },
+            { arr: [weird] },
+            { arr: [5] }
           ]
           , o.arr);
 
           done();
-        })
-        it('with arrays', function(done){
-          mpath.set('arr.arr.e', [[1,2,3],[4,5],null,[],[6], [7,8,9]], o, function (v) {
+        });
+        it('with arrays', function(done) {
+          mpath.set('arr.arr.e', [[1, 2, 3], [4, 5], null, [], [6], [7, 8, 9]], o, function(v) {
             return 10;
           });
 
-          var weird = [];
+          const weird = [];
           weird.e = 10;
 
           assert.deepEqual([
             { yep: [15], arr: [
-                  { a: [4,8,15,16,23,42,108,null], e: 10}
-                , { a: { c: 48, b: [1], '7': 46 }, e: 10}
-                , { d: 'yep', e: 10 }
-              ]
-            }
-          , { yep: 0, arr: [{e: 10}, {e:10}] }
-          , { arr: 'something else' }
-          , { arr: ['something else'] }
-          , { arr: [weird] }
-          , { arr: [5] }
+              { a: [4, 8, 15, 16, 23, 42, 108, null], e: 10 },
+              { a: { c: 48, b: [1], 7: 46 }, e: 10 },
+              { d: 'yep', e: 10 }
+            ]
+            },
+            { yep: 0, arr: [{ e: 10 }, { e: 10 }] },
+            { arr: 'something else' },
+            { arr: ['something else'] },
+            { arr: [weird] },
+            { arr: [5] }
           ]
           , o.arr);
 
-          mpath.set('arr.arr.e', [[1,2,3],[4,5],null,[],[6], [7,8,9]], o);
+          mpath.set('arr.arr.e', [[1, 2, 3], [4, 5], null, [], [6], [7, 8, 9]], o);
 
           weird.e = 6;
 
           assert.deepEqual([
             { yep: [15], arr: [
-                  { a: [4,8,15,16,23,42,108,null], e: 1}
-                , { a: { c: 48, b: [1], '7': 46 }, e: 2}
-                , { d: 'yep', e: 3 }
-              ]
-            }
-          , { yep: 0, arr: [{e: 4}, {e:5}] }
-          , { arr: 'something else' }
-          , { arr: ['something else'] }
-          , { arr: [weird] }
-          , { arr: [5] }
+              { a: [4, 8, 15, 16, 23, 42, 108, null], e: 1 },
+              { a: { c: 48, b: [1], 7: 46 }, e: 2 },
+              { d: 'yep', e: 3 }
+            ]
+            },
+            { yep: 0, arr: [{ e: 4 }, { e: 5 }] },
+            { arr: 'something else' },
+            { arr: ['something else'] },
+            { arr: [weird] },
+            { arr: [5] }
           ]
           , o.arr);
 
           done();
-        })
-      })
-    })
+        });
+      });
+    });
 
-    describe('with `special`', function(){
-      var o = doc();
+    describe('with `special`', function() {
+      const o = doc();
 
-      it('works', function(done){
-        mpath.set('name', 'chan', o, special, function (v) {
+      it('works', function(done) {
+        mpath.set('name', 'chan', o, special, function(v) {
           return 'hi';
         });
         assert.deepEqual('hi', o.name);
@@ -1125,652 +1125,652 @@ describe('mpath', function(){
         mpath.set('name', 'changer', o, special);
         assert.deepEqual('changer', o.name);
 
-        mpath.set('first.second.third', [1,{name:'y'},9], o, special);
-        assert.deepEqual([1,{name:'y'},9], o.first.second.third);
+        mpath.set('first.second.third', [1, { name: 'y' }, 9], o, special);
+        assert.deepEqual([1, { name: 'y' }, 9], o.first.second.third);
 
-        mpath.set('first.second.third.1.name', 'z', o, special)
-        assert.deepEqual([1,{name:'z'},9], o.first.second.third);
+        mpath.set('first.second.third.1.name', 'z', o, special);
+        assert.deepEqual([1, { name: 'z' }, 9], o.first.second.third);
 
         mpath.set('comments.1.name', 'ttwwoo', o, special);
-        assert.deepEqual({ name: 'two', _doc: { name: 'ttwwoo' }}, o.comments[1]);
+        assert.deepEqual({ name: 'two', _doc: { name: 'ttwwoo' } }, o.comments[1]);
 
-        mpath.set('comments.2.comments.1.comments.0.expander', 'adder', o, special, function (v) {
-          return 'super'
+        mpath.set('comments.2.comments.1.comments.0.expander', 'adder', o, special, function(v) {
+          return 'super';
         });
         assert.deepEqual(
-            { val: 2, expander: 'super'}
+          { val: 2, expander: 'super' }
           , o.comments[2]._doc.comments[1]._doc.comments[0]);
 
         mpath.set('comments.2.comments.1.comments.0.expander', 'adder', o, special);
         assert.deepEqual(
-            { val: 2, expander: 'adder'}
+          { val: 2, expander: 'adder' }
           , o.comments[2]._doc.comments[1]._doc.comments[0]);
 
         mpath.set('comments.2.comments.1.comments.2', 'set', o, special);
         assert.equal(3, o.comments[2]._doc.comments[1]._doc.comments.length);
         assert.deepEqual(
-            { val: 2, expander: 'adder'}
+          { val: 2, expander: 'adder' }
           , o.comments[2]._doc.comments[1]._doc.comments[0]);
         assert.deepEqual(
-            undefined
+          undefined
           , o.comments[2]._doc.comments[1]._doc.comments[1]);
         assert.deepEqual(
-            'set'
+          'set'
           , o.comments[2]._doc.comments[1]._doc.comments[2]);
         done();
-      })
+      });
 
-      describe('array.path', function(){
-        describe('with single non-array value', function(){
-          it('works', function(done){
-            o.arr[1]._doc = { special: true }
+      describe('array.path', function() {
+        describe('with single non-array value', function() {
+          it('works', function(done) {
+            o.arr[1]._doc = { special: true };
 
-            mpath.set('arr.yep', false, o, special, function (v) {
+            mpath.set('arr.yep', false, o, special, function(v) {
               return 'yes';
             });
             assert.deepEqual([
-              { yep: 'yes', arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-            , { yep: true, _doc: { special: true, yep: 'yes'}}
+              { yep: 'yes', arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+              { yep: true, _doc: { special: true, yep: 'yes' } }
             ], o.arr);
 
             mpath.set('arr.yep', false, o, special);
             assert.deepEqual([
-              { yep: false, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-            , { yep: true, _doc: { special: true, yep: false }}
+              { yep: false, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+              { yep: true, _doc: { special: true, yep: false } }
             ], o.arr);
 
             done();
-          })
-        })
-        describe('with array of values', function(){
-          it('that are equal in length', function(done){
-            mpath.set('arr.yep', ['one',2], o, special, function (v) {
+          });
+        });
+        describe('with array of values', function() {
+          it('that are equal in length', function(done) {
+            mpath.set('arr.yep', ['one', 2], o, special, function(v) {
               return 2 === v ? 20 : v;
             });
             assert.deepEqual([
-              { yep: 'one', arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-            , { yep: true, _doc: { special: true, yep: 20}}
+              { yep: 'one', arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+              { yep: true, _doc: { special: true, yep: 20 } }
             ], o.arr);
 
-            mpath.set('arr.yep', ['one',2], o, special);
+            mpath.set('arr.yep', ['one', 2], o, special);
             assert.deepEqual([
-              { yep: 'one', arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-            , { yep: true, _doc: { special: true, yep: 2}}
+              { yep: 'one', arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+              { yep: true, _doc: { special: true, yep: 2 } }
             ], o.arr);
 
             done();
-          })
+          });
 
-          it('that is less than length', function(done){
-            mpath.set('arr.yep', [47], o, special, function (v) {
+          it('that is less than length', function(done) {
+            mpath.set('arr.yep', [47], o, special, function(v) {
               return 80;
             });
             assert.deepEqual([
-              { yep: 80, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-            , { yep: true, _doc: { special: true, yep: 2}}
+              { yep: 80, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+              { yep: true, _doc: { special: true, yep: 2 } }
             ], o.arr);
 
             mpath.set('arr.yep', [47], o, special);
             assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
-            , { yep: true, _doc: { special: true, yep: 2}}
+              { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] },
+              { yep: true, _doc: { special: true, yep: 2 } }
             ], o.arr);
 
             // add _doc to first element
-            o.arr[0]._doc = { yep: 46, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] }
+            o.arr[0]._doc = { yep: 46, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] };
 
             mpath.set('arr.yep', [20], o, special);
             assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }], _doc: { yep: 20, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] } }
-            , { yep: true, _doc: { special: true, yep: 2}}
+              { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }], _doc: { yep: 20, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] } },
+              { yep: true, _doc: { special: true, yep: 2 } }
             ], o.arr);
 
             done();
-          })
+          });
 
-          it('that is greater than length', function(done){
-            mpath.set('arr.yep', [5,6,7], o, special, function () {
+          it('that is greater than length', function(done) {
+            mpath.set('arr.yep', [5, 6, 7], o, special, function() {
               return 'x';
             });
             assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }], _doc: { yep: 'x', arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] } }
-            , { yep: true, _doc: { special: true, yep: 'x'}}
+              { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }], _doc: { yep: 'x', arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] } },
+              { yep: true, _doc: { special: true, yep: 'x' } }
             ], o.arr);
 
-            mpath.set('arr.yep', [5,6,7], o, special);
+            mpath.set('arr.yep', [5, 6, 7], o, special);
             assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }], _doc: { yep: 5, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] } }
-            , { yep: true, _doc: { special: true, yep: 6}}
+              { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }], _doc: { yep: 5, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] } },
+              { yep: true, _doc: { special: true, yep: 6 } }
             ], o.arr);
 
             done();
-          })
-        })
-      })
+          });
+        });
+      });
 
-      describe('array.$.path', function(){
-        describe('with single non-array value', function(){
-          it('copies the value to each item in array', function(done){
-            mpath.set('arr.$.yep', {xtra: 'double good'}, o, special, function (v) {
+      describe('array.$.path', function() {
+        describe('with single non-array value', function() {
+          it('copies the value to each item in array', function(done) {
+            mpath.set('arr.$.yep', { xtra: 'double good' }, o, special, function(v) {
               return 9;
             });
             assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: 9, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] } }
-            , { yep: true, _doc: { special: true, yep: 9}}
+              { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+                _doc: { yep: 9, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] } },
+              { yep: true, _doc: { special: true, yep: 9 } }
             ], o.arr);
 
-            mpath.set('arr.$.yep', {xtra: 'double good'}, o, special);
+            mpath.set('arr.$.yep', { xtra: 'double good' }, o, special);
             assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: {xtra:'double good'}, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] } }
-            , { yep: true, _doc: { special: true, yep: {xtra:'double good'}}}
+              { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+                _doc: { yep: { xtra: 'double good' }, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] } },
+              { yep: true, _doc: { special: true, yep: { xtra: 'double good' } } }
             ], o.arr);
 
             done();
-          })
-        })
-        describe('with array of values', function(){
-          it('copies the value to each item in array', function(done){
-            mpath.set('arr.$.yep', [15], o, special, function (v) {
-              return 'array'
+          });
+        });
+        describe('with array of values', function() {
+          it('copies the value to each item in array', function(done) {
+            mpath.set('arr.$.yep', [15], o, special, function(v) {
+              return 'array';
             });
             assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: 'array', arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] } }
-            , { yep: true, _doc: { special: true, yep: 'array'}}
+              { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+                _doc: { yep: 'array', arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] } },
+              { yep: true, _doc: { special: true, yep: 'array' } }
             ], o.arr);
 
             mpath.set('arr.$.yep', [15], o, special);
             assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] } }
-            , { yep: true, _doc: { special: true, yep: [15]}}
+              { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+                _doc: { yep: [15], arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] } },
+              { yep: true, _doc: { special: true, yep: [15] } }
             ], o.arr);
 
             done();
-          })
-        })
-      })
+          });
+        });
+      });
 
-      describe('array.index.path', function(){
-        it('works', function(done){
-          mpath.set('arr.1.yep', 0, o, special, function (v) {
+      describe('array.index.path', function() {
+        it('works', function(done) {
+          mpath.set('arr.1.yep', 0, o, special, function(v) {
             return 1;
           });
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] } }
-            , { yep: true, _doc: { special: true, yep: 1}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] } },
+            { yep: true, _doc: { special: true, yep: 1 } }
           ], o.arr);
 
           mpath.set('arr.1.yep', 0, o, special);
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           done();
-        })
-      })
+        });
+      });
 
-      describe('array.index.array.path', function(){
-        it('with single value', function(done){
-          mpath.set('arr.0.arr.e', 35, o, special, function (v) {
-            return 30
+      describe('array.index.array.path', function() {
+        it('with single value', function(done) {
+          mpath.set('arr.0.arr.e', 35, o, special, function(v) {
+            return 30;
           });
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: { b: 47 }, e: 30}, { a: { c: 48 }, e: 30}, { d: 'yep', e: 30 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: { b: 47 }, e: 30 }, { a: { c: 48 }, e: 30 }, { d: 'yep', e: 30 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           mpath.set('arr.0.arr.e', 35, o, special);
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: { b: 47 }, e: 35}, { a: { c: 48 }, e: 35}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: { b: 47 }, e: 35 }, { a: { c: 48 }, e: 35 }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           done();
-        })
-        it('with array', function(done){
-          mpath.set('arr.0.arr.e', ['a','b'], o, special, function (v) {
+        });
+        it('with array', function(done) {
+          mpath.set('arr.0.arr.e', ['a', 'b'], o, special, function(v) {
             return 'a' === v ? 'A' : v;
           });
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: { b: 47 }, e: 'A'}, { a: { c: 48 }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: { b: 47 }, e: 'A' }, { a: { c: 48 }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
-          mpath.set('arr.0.arr.e', ['a','b'], o, special);
+          mpath.set('arr.0.arr.e', ['a', 'b'], o, special);
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: { b: 47 }, e: 'a'}, { a: { c: 48 }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: { b: 47 }, e: 'a' }, { a: { c: 48 }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           done();
-        })
-      })
+        });
+      });
 
-      describe('array.index.array.path.path', function(){
-        it('with single value', function(done){
-          mpath.set('arr.0.arr.a.b', 36, o, special, function (v) {
-            return 20
+      describe('array.index.array.path.path', function() {
+        it('with single value', function(done) {
+          mpath.set('arr.0.arr.a.b', 36, o, special, function(v) {
+            return 20;
           });
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: { b: 20 }, e: 'a'}, { a: { c: 48, b: 20 }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: { b: 20 }, e: 'a' }, { a: { c: 48, b: 20 }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           mpath.set('arr.0.arr.a.b', 36, o, special);
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: { b: 36 }, e: 'a'}, { a: { c: 48, b: 36 }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: { b: 36 }, e: 'a' }, { a: { c: 48, b: 36 }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           done();
-        })
-        it('with array', function(done){
-          mpath.set('arr.0.arr.a.b', [1,2,3,4], o, special, function (v) {
-            return v*2;
+        });
+        it('with array', function(done) {
+          mpath.set('arr.0.arr.a.b', [1, 2, 3, 4], o, special, function(v) {
+            return v * 2;
           });
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: { b: 2 }, e: 'a'}, { a: { c: 48, b: 4 }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: { b: 2 }, e: 'a' }, { a: { c: 48, b: 4 }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
-          mpath.set('arr.0.arr.a.b', [1,2,3,4], o, special);
+          mpath.set('arr.0.arr.a.b', [1, 2, 3, 4], o, special);
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: { b: 1 }, e: 'a'}, { a: { c: 48, b: 2 }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: { b: 1 }, e: 'a' }, { a: { c: 48, b: 2 }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           done();
-        })
-      })
+        });
+      });
 
-      describe('array.index.array.$.path.path', function(){
-        it('with single value', function(done){
-          mpath.set('arr.0.arr.$.a.b', '$', o, special, function (v) {
-            return 'dollaz'
+      describe('array.index.array.$.path.path', function() {
+        it('with single value', function(done) {
+          mpath.set('arr.0.arr.$.a.b', '$', o, special, function(v) {
+            return 'dollaz';
           });
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: { b: 'dollaz' }, e: 'a'}, { a: { c: 48, b: 'dollaz' }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: { b: 'dollaz' }, e: 'a' }, { a: { c: 48, b: 'dollaz' }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           mpath.set('arr.0.arr.$.a.b', '$', o, special);
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: { b: '$' }, e: 'a'}, { a: { c: 48, b: '$' }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: { b: '$' }, e: 'a' }, { a: { c: 48, b: '$' }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           done();
-        })
-        it('with array', function(done){
-          mpath.set('arr.0.arr.$.a.b', [1], o, special, function (v) {
+        });
+        it('with array', function(done) {
+          mpath.set('arr.0.arr.$.a.b', [1], o, special, function(v) {
             return {};
           });
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: { b: {} }, e: 'a'}, { a: { c: 48, b: {} }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: { b: {} }, e: 'a' }, { a: { c: 48, b: {} }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           mpath.set('arr.0.arr.$.a.b', [1], o, special);
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: { b: [1] }, e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: { b: [1] }, e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           done();
-        })
-      })
+        });
+      });
 
-      describe('array.array.index.path', function(){
-        it('with single value', function(done){
-          mpath.set('arr.arr.0.a', 'single', o, special, function (v) {
+      describe('array.array.index.path', function() {
+        it('with single value', function(done) {
+          mpath.set('arr.arr.0.a', 'single', o, special, function(v) {
             return 88;
           });
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: 88, e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: 88, e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           mpath.set('arr.arr.0.a', 'single', o, special);
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: 'single', e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: 'single', e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           done();
-        })
-        it('with array', function(done){
-          mpath.set('arr.arr.0.a', [4,8,15,16,23,42], o, special, function (v) {
-            return v*2;
+        });
+        it('with array', function(done) {
+          mpath.set('arr.arr.0.a', [4, 8, 15, 16, 23, 42], o, special, function(v) {
+            return v * 2;
           });
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: 8, e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: 8, e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
-          mpath.set('arr.arr.0.a', [4,8,15,16,23,42], o, special);
+          mpath.set('arr.arr.0.a', [4, 8, 15, 16, 23, 42], o, special);
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: 4, e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: 4, e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           done();
-        })
-      })
+        });
+      });
 
-      describe('array.array.$.index.path', function(){
-        it('with single value', function(done){
-          mpath.set('arr.arr.$.0.a', 'singles', o, special, function (v) {
+      describe('array.array.$.index.path', function() {
+        it('with single value', function(done) {
+          mpath.set('arr.arr.$.0.a', 'singles', o, special, function(v) {
             return v.toUpperCase();
           });
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: 'SINGLES', e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: 'SINGLES', e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           mpath.set('arr.arr.$.0.a', 'singles', o, special);
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: 'singles', e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: 'singles', e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           mpath.set('$.arr.arr.0.a', 'single', o, special);
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: 'single', e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: 'single', e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           done();
-        })
-        it('with array', function(done){
-          mpath.set('arr.arr.$.0.a', [4,8,15,16,23,42], o, special, function (v) {
-            return Array
+        });
+        it('with array', function(done) {
+          mpath.set('arr.arr.$.0.a', [4, 8, 15, 16, 23, 42], o, special, function(v) {
+            return Array;
           });
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: Array, e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: Array, e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
-          mpath.set('arr.arr.$.0.a', [4,8,15,16,23,42], o, special);
+          mpath.set('arr.arr.$.0.a', [4, 8, 15, 16, 23, 42], o, special);
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: [4,8,15,16,23,42], e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: [4, 8, 15, 16, 23, 42], e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
-          mpath.set('arr.$.arr.0.a', [4,8,15,16,23,42,108], o, special);
+          mpath.set('arr.$.arr.0.a', [4, 8, 15, 16, 23, 42, 108], o, special);
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: [4,8,15,16,23,42,108], e: 'a'}, { a: { c: 48, b: [1] }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: [4, 8, 15, 16, 23, 42, 108], e: 'a' }, { a: { c: 48, b: [1] }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           done();
-        })
-      })
+        });
+      });
 
-      describe('array.array.path.index', function(){
-        it('with single value', function(done){
-          mpath.set('arr.arr.a.7', 47, o, special, function (v) {
+      describe('array.array.path.index', function() {
+        it('with single value', function(done) {
+          mpath.set('arr.arr.a.7', 47, o, special, function(v) {
             return Object;
           });
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: [4,8,15,16,23,42,108,Object], e: 'a'}, { a: { c: 48, b: [1], '7': Object }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: [4, 8, 15, 16, 23, 42, 108, Object], e: 'a' }, { a: { c: 48, b: [1], 7: Object }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           mpath.set('arr.arr.a.7', 47, o, special);
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: [4,8,15,16,23,42,108,47], e: 'a'}, { a: { c: 48, b: [1], '7': 47 }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: [4, 8, 15, 16, 23, 42, 108, 47], e: 'a' }, { a: { c: 48, b: [1], 7: 47 }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { special: true, yep: 0 } }
           ], o.arr);
 
           done();
-        })
-        it('with array', function(done){
+        });
+        it('with array', function(done) {
           o.arr[1]._doc.arr = [{ a: [] }, { a: [] }, { a: null }];
-          mpath.set('arr.arr.a.7', [[null,46], [undefined, 'woot']], o, special, function (v) {
+          mpath.set('arr.arr.a.7', [[null, 46], [undefined, 'woot']], o, special, function(v) {
             return undefined === v ? 'nope' : v;
           });
 
-          var a1 = [];
-          var a2 = [];
+          const a1 = [];
+          const a2 = [];
           a1[7] = 'nope';
           a2[7] = 'woot';
 
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: [4,8,15,16,23,42,108,null], e: 'a'}, { a: { c: 48, b: [1], '7': 46 }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { arr: [{a:a1},{a:a2},{a:null}], special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: [4, 8, 15, 16, 23, 42, 108, null], e: 'a' }, { a: { c: 48, b: [1], 7: 46 }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { arr: [{ a: a1 }, { a: a2 }, { a: null }], special: true, yep: 0 } }
           ], o.arr);
 
-          mpath.set('arr.arr.a.7', [[null,46], [undefined, 'woot']], o, special);
+          mpath.set('arr.arr.a.7', [[null, 46], [undefined, 'woot']], o, special);
 
           a1[7] = undefined;
 
           assert.deepEqual([
-              { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-                , _doc: { yep: [15], arr: [{ a: [4,8,15,16,23,42,108,null], e: 'a'}, { a: { c: 48, b: [1], '7': 46 }, e: 'b'}, { d: 'yep', e: 35 }] } }
-            , { yep: true, _doc: { arr: [{a:a1},{a:a2},{a:null}], special: true, yep: 0}}
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: { yep: [15], arr: [{ a: [4, 8, 15, 16, 23, 42, 108, null], e: 'a' }, { a: { c: 48, b: [1], 7: 46 }, e: 'b' }, { d: 'yep', e: 35 }] } },
+            { yep: true, _doc: { arr: [{ a: a1 }, { a: a2 }, { a: null }], special: true, yep: 0 } }
           ], o.arr);
 
           done();
-        })
-      })
-
-      describe('handles array.array.path', function(){
-        it('with single', function(done){
-          o.arr[1]._doc.arr = [{},{}];
-          assert.deepEqual([{},{}], o.arr[1]._doc.arr);
-          o.arr.push({ _doc: { arr: 'something else' }});
-          o.arr.push({ _doc: { arr: ['something else'] }});
-          o.arr.push({ _doc: { arr: [[]] }});
-          o.arr.push({ _doc: { arr: [5] }});
+        });
+      });
+
+      describe('handles array.array.path', function() {
+        it('with single', function(done) {
+          o.arr[1]._doc.arr = [{}, {}];
+          assert.deepEqual([{}, {}], o.arr[1]._doc.arr);
+          o.arr.push({ _doc: { arr: 'something else' } });
+          o.arr.push({ _doc: { arr: ['something else'] } });
+          o.arr.push({ _doc: { arr: [[]] } });
+          o.arr.push({ _doc: { arr: [5] } });
 
           // test
           mpath.set('arr.arr.e', 47, o, special);
 
-          var weird = [];
+          const weird = [];
           weird.e = 47;
 
           assert.deepEqual([
-            { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-              , _doc: {
-                  yep: [15]
-                , arr: [
-                    { a: [4,8,15,16,23,42,108,null], e: 47}
-                  , { a: { c: 48, b: [1], '7': 46 }, e: 47}
-                  , { d: 'yep', e: 47 }
-                  ]
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: {
+                yep: [15],
+                arr: [
+                  { a: [4, 8, 15, 16, 23, 42, 108, null], e: 47 },
+                  { a: { c: 48, b: [1], 7: 46 }, e: 47 },
+                  { d: 'yep', e: 47 }
+                ]
               }
-            }
-          , { yep: true
-              , _doc: {
-                  arr: [
-                     {e:47}
-                   , {e:47}
-                  ]
-                , special: true
-                , yep: 0
+            },
+            { yep: true,
+              _doc: {
+                arr: [
+                  { e: 47 },
+                  { e: 47 }
+                ],
+                special: true,
+                yep: 0
               }
-            }
-          , { _doc: { arr: 'something else' }}
-          , { _doc: { arr: ['something else'] }}
-          , { _doc: { arr: [weird] }}
-          , { _doc: { arr: [5] }}
+            },
+            { _doc: { arr: 'something else' } },
+            { _doc: { arr: ['something else'] } },
+            { _doc: { arr: [weird] } },
+            { _doc: { arr: [5] } }
           ]
           , o.arr);
 
           done();
-        })
-        it('with arrays', function(done){
-          mpath.set('arr.arr.e', [[1,2,3],[4,5],null,[],[6], [7,8,9]], o, special);
+        });
+        it('with arrays', function(done) {
+          mpath.set('arr.arr.e', [[1, 2, 3], [4, 5], null, [], [6], [7, 8, 9]], o, special);
 
-          var weird = [];
+          const weird = [];
           weird.e = 6;
 
           assert.deepEqual([
-            { yep: 47, arr: [{ a: { b: 47 }}, { a: { c: 48 }}, { d: 'yep' }]
-              , _doc: {
-                  yep: [15]
-                , arr: [
-                    { a: [4,8,15,16,23,42,108,null], e: 1}
-                  , { a: { c: 48, b: [1], '7': 46 }, e: 2}
-                  , { d: 'yep', e: 3 }
-                  ]
+            { yep: 47, arr: [{ a: { b: 47 } }, { a: { c: 48 } }, { d: 'yep' }],
+              _doc: {
+                yep: [15],
+                arr: [
+                  { a: [4, 8, 15, 16, 23, 42, 108, null], e: 1 },
+                  { a: { c: 48, b: [1], 7: 46 }, e: 2 },
+                  { d: 'yep', e: 3 }
+                ]
               }
-            }
-          , { yep: true
-              , _doc: {
-                  arr: [
-                     {e:4}
-                   , {e:5}
-                  ]
-                , special: true
-                , yep: 0
+            },
+            { yep: true,
+              _doc: {
+                arr: [
+                  { e: 4 },
+                  { e: 5 }
+                ],
+                special: true,
+                yep: 0
               }
-            }
-          , { _doc: { arr: 'something else' }}
-          , { _doc: { arr: ['something else'] }}
-          , { _doc: { arr: [weird] }}
-          , { _doc: { arr: [5] }}
+            },
+            { _doc: { arr: 'something else' } },
+            { _doc: { arr: ['something else'] } },
+            { _doc: { arr: [weird] } },
+            { _doc: { arr: [5] } }
           ]
           , o.arr);
 
           done();
-        })
-      })
-
-      describe('that is a function', function(){
-        describe('without map', function(){
-          it('works on array value', function(done){
-            var o = { hello: { world: [{ how: 'are' }, { you: '?' }] }};
-            var special = function (obj, key, val) {
+        });
+      });
+
+      describe('that is a function', function() {
+        describe('without map', function() {
+          it('works on array value', function(done) {
+            const o = { hello: { world: [{ how: 'are' }, { you: '?' }] } };
+            const special = function(obj, key, val) {
               if (val) {
                 obj[key] = val;
               } else {
                 return 'thing' == key
                   ? obj.world
-                  : obj[key]
+                  : obj[key];
               }
-            }
+            };
             mpath.set('hello.thing.how', 'arrrr', o, special);
-            assert.deepEqual(o, { hello: { world: [{ how: 'arrrr' }, { you: '?', how: 'arrrr' }] }});
+            assert.deepEqual(o, { hello: { world: [{ how: 'arrrr' }, { you: '?', how: 'arrrr' }] } });
             done();
-          })
-          it('works on non-array value', function(done){
-            var o = { hello: { world: { how: 'are you' }}};
-            var special = function (obj, key, val) {
+          });
+          it('works on non-array value', function(done) {
+            const o = { hello: { world: { how: 'are you' } } };
+            const special = function(obj, key, val) {
               if (val) {
                 obj[key] = val;
               } else {
                 return 'thing' == key
                   ? obj.world
-                  : obj[key]
+                  : obj[key];
               }
-            }
+            };
             mpath.set('hello.thing.how', 'RU', o, special);
-            assert.deepEqual(o, { hello: { world: { how: 'RU' }}});
+            assert.deepEqual(o, { hello: { world: { how: 'RU' } } });
             done();
-          })
-        })
-        it('works with map', function(done){
-          var o = { hello: { world: [{ how: 'are' }, { you: '?' }] }};
-          var special = function (obj, key, val) {
+          });
+        });
+        it('works with map', function(done) {
+          const o = { hello: { world: [{ how: 'are' }, { you: '?' }] } };
+          const special = function(obj, key, val) {
             if (val) {
               obj[key] = val;
             } else {
               return 'thing' == key
                 ? obj.world
-                : obj[key]
+                : obj[key];
             }
-          }
-          var map = function (val) {
+          };
+          const map = function(val) {
             return 'convert' == val
               ? 'ºº'
-              : val
-          }
+              : val;
+          };
           mpath.set('hello.thing.how', 'convert', o, special, map);
-          assert.deepEqual(o, { hello: { world: [{ how: 'ºº' }, { you: '?', how: 'ºº' }] }});
+          assert.deepEqual(o, { hello: { world: [{ how: 'ºº' }, { you: '?', how: 'ºº' }] } });
           done();
-        })
-      })
+        });
+      });
 
-    })
+    });
 
-    describe('get/set integration', function(){
-      var o = doc();
+    describe('get/set integration', function() {
+      const o = doc();
 
-      it('works', function(done){
-        var vals = mpath.get('array.o.array.x.b', o);
+      it('works', function(done) {
+        const vals = mpath.get('array.o.array.x.b', o);
 
         vals[0][0][2] = 10;
         vals[1][0][1] = 0;
         vals[1][1] = 'Rambaldi';
-        vals[1][2] = [12,14];
-        vals[2] = [{changed:true}, [null, ['changed','to','array']]];
+        vals[1][2] = [12, 14];
+        vals[2] = [{ changed: true }, [null, ['changed', 'to', 'array']]];
 
         mpath.set('array.o.array.x.b', vals, o);
 
-        var t = [
-            { o: { array: [{x: {b: [4,6,10]}}, { y: 10} ] }}
-          , { o: { array: [{x: {b: [1,0,3]}}, { x: {b:'Rambaldi',z: 10 }}, { x: {b: [12,14]}}] }}
-          , { o: { array: [{x: {b: {changed:true}}}, { x: { b: [null, ['changed','to','array']]}}]}}
-          , { o: { array: [{x: null }] }}
-          , { o: { array: [{y: 3 }] }}
-          , { o: { array: [3, 0, null] }}
-          , { o: { name: 'ha' }}
+        const t = [
+          { o: { array: [{ x: { b: [4, 6, 10] } }, { y: 10 }] } },
+          { o: { array: [{ x: { b: [1, 0, 3] } }, { x: { b: 'Rambaldi', z: 10 } }, { x: { b: [12, 14] } }] } },
+          { o: { array: [{ x: { b: { changed: true } } }, { x: { b: [null, ['changed', 'to', 'array']] } }] } },
+          { o: { array: [{ x: null }] } },
+          { o: { array: [{ y: 3 }] } },
+          { o: { array: [3, 0, null] } },
+          { o: { name: 'ha' } }
         ];
         assert.deepEqual(t, o.array);
         done();
       });
 
-      it('array.prop', function(done){
+      it('array.prop', function(done) {
         mpath.set('comments.name', ['this', 'was', 'changed'], o);
 
         assert.deepEqual([
-            { name: 'this' }
-          , { name: 'was', _doc: { name: '2' }}
-          , { name: 'changed'
-              , comments: [{},{ comments: [{val: 'twoo'}]}]
-              , _doc: { name: '3', comments: [{},{ _doc: { comments: [{ val: 2 }] }}]  }}
+          { name: 'this' },
+          { name: 'was', _doc: { name: '2' } },
+          { name: 'changed',
+            comments: [{}, { comments: [{ val: 'twoo' }] }],
+            _doc: { name: '3', comments: [{}, { _doc: { comments: [{ val: 2 }] } }] } }
         ], o.comments);
 
         mpath.set('comments.name', ['also', 'changed', 'this'], o, special);
 
         assert.deepEqual([
-            { name: 'also' }
-          , { name: 'was', _doc: { name: 'changed' }}
-          , { name: 'changed'
-              , comments: [{},{ comments: [{val: 'twoo'}]}]
-              , _doc: { name: 'this', comments: [{},{ _doc: { comments: [{ val: 2 }] }}]  }}
+          { name: 'also' },
+          { name: 'was', _doc: { name: 'changed' } },
+          { name: 'changed',
+            comments: [{}, { comments: [{ val: 'twoo' }] }],
+            _doc: { name: 'this', comments: [{}, { _doc: { comments: [{ val: 2 }] } }] } }
         ], o.comments);
 
         done();
@@ -1784,10 +1784,10 @@ describe('mpath', function(){
       });
     });
 
-    describe('multiple $ use', function(){
-      var o = doc();
-      it('is ok', function(done){
-        assert.doesNotThrow(function () {
+    describe('multiple $ use', function() {
+      const o = doc();
+      it('is ok', function(done) {
+        assert.doesNotThrow(function() {
           mpath.set('arr.$.arr.$.a', 35, o);
         });
         done();
@@ -1815,8 +1815,8 @@ describe('mpath', function(){
       }
       assert.equal(mpath.get('a.b', { a: new Map([['b', 1]]) }), 1);
 
-      var m = new Map([['b', 1]]);
-      var obj = { a: m };
+      const m = new Map([['b', 1]]);
+      const obj = { a: m };
       mpath.set('a.c', 2, obj);
       assert.equal(m.get('c'), 2);
 
@@ -1824,7 +1824,7 @@ describe('mpath', function(){
     });
 
     it('unset', function(done) {
-      var o = { a: 1 };
+      let o = { a: 1 };
       mpath.unset('a', o);
       assert.deepEqual(o, {});
 
@@ -1868,11 +1868,11 @@ describe('mpath', function(){
       done();
     });
 
-    it('ignores setting a nested path that doesnt exist', function(done){
-      var o = doc();
-      assert.doesNotThrow(function(){
+    it('ignores setting a nested path that doesnt exist', function(done) {
+      const o = doc();
+      assert.doesNotThrow(function() {
         mpath.set('thing.that.is.new', 10, o);
-      })
+      });
       done();
     });
   });