chore: include benchmark suite;

- results from `fast-deep-equal/benchmark` are unreliable

bench/index.js

@@ -0,0 +1,136 @@
+const { Suite } = require('benchmark');
+
+console.log('Load times:');
+
+console.time('assert');
+const { deepStrictEqual } = require('assert');
+console.timeEnd('assert');
+
+console.time('util');
+const { isDeepStrictEqual } = require('util');
+console.timeEnd('util');
+
+console.time('fast-deep-equal');
+const fastdeep = require('fast-deep-equal');
+console.timeEnd('fast-deep-equal');
+
+console.time('lodash/isequal');
+const lodash = require('lodash/isequal');
+console.timeEnd('lodash/isequal');
+
+console.time('nano-equal');
+const nanoequal = require('nano-equal');
+console.timeEnd('nano-equal');
+
+console.time('dequal');
+const dequal = require('dequal');
+console.timeEnd('dequal');
+
+
+function naiive(a, b) {
+	try {
+		deepStrictEqual(a, b);
+		return true;
+	} catch (err) {
+		return false;
+	}
+}
+
+const contenders = {
+	'assert.deepStrictEqual': naiive,
+	'util.isDeepStrictEqual': isDeepStrictEqual,
+	'fast-deep-equal': fastdeep,
+	'lodash.isEqual': lodash,
+	'nano-equal': nanoequal,
+	'dequal': dequal,
+};
+
+console.log('\nValidation: ');
+Object.keys(contenders).forEach(name => {
+	const func = contenders[name];
+
+	try {
+		deepStrictEqual(func(1, 1), true, 'equal numbers');
+		deepStrictEqual(func(1, 2), false, 'not equal numbers');
+		deepStrictEqual(func(1, [1]), false, 'number vs array');
+		deepStrictEqual(func(0, null), false, 'number vs null');
+		deepStrictEqual(func(0, undefined), false, 'number vs undefined');
+
+		deepStrictEqual(
+			func({
+				prop1: 'value1',
+				prop2: 'value2',
+				prop3: 'value3',
+				prop4: {
+					subProp1: 'sub value1',
+					subProp2: {
+						subSubProp1: 'sub sub value1',
+						subSubProp2: [1, 2, {prop2: 1, prop: 2}, 4, 5]
+					}
+				},
+				prop5: 1000,
+				prop6: new Date(2016, 2, 10)
+			}, {
+				prop5: 1000,
+				prop3: 'value3',
+				prop1: 'value1',
+				prop2: 'value2',
+				prop6: new Date('2016/03/10'),
+				prop4: {
+					subProp2: {
+						subSubProp1: 'sub sub value1',
+						subSubProp2: [1, 2, {prop2: 1, prop: 2}, 4, 5]
+					},
+					subProp1: 'sub value1'
+				}
+			}),
+			true,
+			'kitchen sink'
+		)
+
+		console.log('  ✔', name);
+	} catch (err) {
+		console.log('  ✘', name, `(FAILED @ "${err.message}")`);
+	}
+});
+
+
+console.log('\nBenchmark:');
+const bench = new Suite().on('cycle', e => {
+	console.log('  ' + e.target);
+});
+
+Object.keys(contenders).forEach(name => {
+	bench.add(name + ' '.repeat(22 - name.length), () => {
+		// contenders[name]({ a: 1, b: 2, c: 3 }, { a: 1, b: 4, c: 3 });
+		contenders[name]({
+			prop1: 'value1',
+			prop2: 'value2',
+			prop3: 'value3',
+			prop4: {
+				subProp1: 'sub value1',
+				subProp2: {
+					subSubProp1: 'sub sub value1',
+					subSubProp2: [1, 2, {prop2: 1, prop: 2}, 4, 5]
+				}
+			},
+			prop5: 1000,
+			prop6: new Date(2016, 2, 10)
+		}, {
+			prop5: 1000,
+			prop3: 'value3',
+			prop1: 'value1',
+			prop2: 'value2',
+			prop6: new Date('2016/03/10'),
+			prop4: {
+				subProp2: {
+					subSubProp1: 'sub sub value1',
+					subSubProp2: [1, 2, {prop2: 1, prop: 2}, 4, 5]
+				},
+				subProp1: 'sub value1'
+			}
+		});
+	})
+});
+
+bench.run();

bench/package.json

@@ -0,0 +1,10 @@
+{
+  "private": true,
+  "devDependencies": {
+    "benchmark": "2.1.4",
+    "dequal": "file:../",
+    "fast-deep-equal": "3.1.3",
+    "lodash": "4.17.15",
+    "nano-equal": "2.0.2"
+  }
+}

readme.md

@@ -24,7 +24,7 @@ $ npm install --save dequal
 ## Usage
 
 ```js
-const dequal = require('dequal');
+import dequal from 'dequal';
 
 dequal(1, 1); //=> true
 dequal({}, {}); //=> true
@@ -60,11 +60,30 @@ A `Boolean` is returned indicating if the two were deeply equal.
 > Running Node v10.13.0
 
 ```
-fast-deep-equal   x 214,365 ops/sec ±0.30% (93 runs sampled)
-dequal            x 160,116 ops/sec ±0.29% (93 runs sampled)
-lodash.isEqual    x  45,257 ops/sec ±0.26% (95 runs sampled)
+Load times:
+  assert:            0.111ms
+  util:              0.007ms
+  fast-deep-equal:   0.550ms
+  lodash/isequal:   22.396ms
+  nano-equal:        0.628ms
+  dequal:            0.517ms
+
+Validation:
+  ✔ assert.deepStrictEqual
+  ✔ util.isDeepStrictEqual
+  ✔ fast-deep-equal
+  ✔ lodash.isEqual
+  ✔ nano-equal
+  ✔ dequal
+
+Benchmark:
+  assert.deepStrictEqual x 208,260 ops/sec ±0.89% (94 runs sampled)
+  util.isDeepStrictEqual x 209,764 ops/sec ±0.95% (95 runs sampled)
+  fast-deep-equal        x 443,862 ops/sec ±0.86% (95 runs sampled)
+  lodash.isEqual         x 194,133 ops/sec ±0.43% (95 runs sampled)
+  nano-equal             x 414,957 ops/sec ±0.41% (98 runs sampled)
+  dequal                 x 507,470 ops/sec ±0.60% (95 runs sampled)
 ```
-<sup>_Candidates operate identically to one another_</sup>
 
 ## License