dot.dot.dot.exampol

node_modules/traverse/test/circular.js

@@ -0,0 +1,118 @@
+'use strict';
+
+var test = require('tape');
+var traverse = require('../');
+var deepEqual = require('./lib/deep_equal');
+var util = require('util');
+
+test('circular', function (t) {
+	t.plan(1);
+
+	var obj = { x: 3 };
+	obj.y = obj;
+	traverse(obj).forEach(function () {
+		if (this.path.join('') === 'y') {
+			t.equal(
+				util.inspect(this.circular.node),
+				util.inspect(obj)
+			);
+		}
+	});
+});
+
+test('deepCirc', function (t) {
+	t.plan(2);
+	var obj = { x: [1, 2, 3], y: [4, 5] };
+	obj.y[2] = obj;
+
+	traverse(obj).forEach(function () {
+		if (this.circular) {
+			t.deepEqual(this.circular.path, []);
+			t.deepEqual(this.path, ['y', '2']);
+		}
+	});
+});
+
+test('doubleCirc', function (t) {
+	var obj = { x: [1, 2, 3], y: [4, 5] };
+	obj.y[2] = obj;
+	obj.x.push(obj.y);
+
+	var circs = [];
+	traverse(obj).forEach(function (x) {
+		if (this.circular) {
+			circs.push({ circ: this.circular, self: this, node: x });
+		}
+	});
+
+	t.deepEqual(circs[0].self.path, ['x', '3', '2']);
+	t.deepEqual(circs[0].circ.path, []);
+
+	t.deepEqual(circs[1].self.path, ['y', '2']);
+	t.deepEqual(circs[1].circ.path, []);
+
+	t.deepEqual(circs.length, 2);
+	t.end();
+});
+
+test('circDubForEach', function (t) {
+	var obj = { x: [1, 2, 3], y: [4, 5] };
+	obj.y[2] = obj;
+	obj.x.push(obj.y);
+
+	traverse(obj).forEach(function () {
+		if (this.circular) { this.update('...'); }
+	});
+
+	t.same(obj, { x: [1, 2, 3, [4, 5, '...']], y: [4, 5, '...'] });
+	t.end();
+});
+
+test('circDubMap', function (t) {
+	var obj = { x: [1, 2, 3], y: [4, 5] };
+	obj.y[2] = obj;
+	obj.x.push(obj.y);
+
+	var c = traverse(obj).map(function () {
+		if (this.circular) {
+			this.update('...');
+		}
+	});
+
+	t.same(c, { x: [1, 2, 3, [4, 5, '...']], y: [4, 5, '...'] });
+	t.end();
+});
+
+test('circClone', function (t) {
+	var obj = { x: [1, 2, 3], y: [4, 5] };
+	obj.y[2] = obj;
+	obj.x.push(obj.y);
+
+	var clone = traverse.clone(obj);
+	t.ok(obj !== clone);
+
+	t.ok(clone.y[2] === clone);
+	t.ok(clone.y[2] !== obj);
+	t.ok(clone.x[3][2] === clone);
+	t.ok(clone.x[3][2] !== obj);
+	t.same(clone.x.slice(0, 3), [1, 2, 3]);
+	t.same(clone.y.slice(0, 2), [4, 5]);
+	t.end();
+});
+
+test('circMapScrub', function (t) {
+	var obj = { a: 1, b: 2 };
+	obj.c = obj;
+
+	var scrubbed = traverse(obj).map(function () {
+		if (this.circular) { this.remove(); }
+	});
+	t.same(
+		Object.keys(scrubbed).sort(),
+		['a', 'b']
+	);
+	t.ok(deepEqual(scrubbed, { a: 1, b: 2 }));
+
+	t.equal(obj.c, obj);
+	t.end();
+});

node_modules/traverse/test/date.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var test = require('tape');
+var traverse = require('../');
+
+test('dateEach', function (t) {
+	var obj = { x: new Date(), y: 10, z: 5 };
+
+	var counts = {};
+
+	traverse(obj).forEach(function (node) {
+		var type = (node instanceof Date && 'Date') || typeof node;
+		counts[type] = (counts[type] || 0) + 1;
+	});
+
+	t.same(counts, {
+		object: 1,
+		Date: 1,
+		number: 2,
+	});
+	t.end();
+});
+
+test('dateMap', function (t) {
+	var obj = { x: new Date(), y: 10, z: 5 };
+
+	var res = traverse(obj).map(function (node) {
+		if (typeof node === 'number') { this.update(node + 100); }
+	});
+
+	t.ok(obj.x !== res.x);
+	t.same(res, {
+		x: obj.x,
+		y: 110,
+		z: 105,
+	});
+	t.end();
+});
+

node_modules/traverse/test/equal.js

@@ -0,0 +1,238 @@
+'use strict';
+
+var test = require('tape');
+var deepEqual = require('./lib/deep_equal');
+
+test('deepDates', function (t) {
+	t.plan(2);
+
+	t.ok(
+		deepEqual(
+			{ d: new Date(), x: [1, 2, 3] },
+			{ d: new Date(), x: [1, 2, 3] }
+		),
+		'dates should be equal'
+	);
+
+	var d0 = new Date();
+	setTimeout(function () {
+		t.ok(
+			!deepEqual(
+				{ d: d0, x: [1, 2, 3] },
+				{ d: new Date(), x: [1, 2, 3] }
+			),
+			'microseconds should count in date equality'
+		);
+	}, 5);
+});
+
+test('deepCircular', function (t) {
+	var a = [1];
+	a.push(a); // a = [ 1, *a ]
+
+	var b = [1];
+	b.push(a); // b = [ 1, [ 1, *a ] ]
+
+	t.ok(
+		!deepEqual(a, b),
+		'circular ref mount points count towards equality'
+	);
+
+	var c = [1];
+	c.push(c); // c = [ 1, *c ]
+	t.ok(
+		deepEqual(a, c),
+		'circular refs are structurally the same here'
+	);
+
+	var d = [1];
+	d.push(a); // c = [ 1, [ 1, *d ] ]
+	t.ok(
+		deepEqual(b, d),
+		'non-root circular ref structural comparison'
+	);
+
+	t.end();
+});
+
+test('deepInstances', function (t) {
+	t.ok(
+		!deepEqual([Object(false)], [false]),
+		'boolean instances are not real booleans'
+	);
+
+	t.ok(
+		!deepEqual([Object('x')], ['x']),
+		'string instances are not real strings'
+	);
+
+	t.ok(
+		!deepEqual([Object(4)], [4]),
+		'number instances are not real numbers'
+	);
+
+	t.ok(
+		deepEqual([new RegExp('x')], [/x/]),
+		'regexp instances are real regexps'
+	);
+
+	t.ok(
+		!deepEqual([new RegExp(/./)], [/../]),
+		'these regexps aren\'t the same'
+	);
+
+	t.ok(
+		!deepEqual(
+			[function (x) { return x * 2; }],
+			[function (x) { return x * 2; }]
+		),
+		'functions with the same .toString() aren\'t necessarily the same'
+	);
+
+	function f(x) { return x * 2; }
+	t.ok(
+		deepEqual([f], [f]),
+		'these functions are actually equal'
+	);
+
+	t.end();
+});
+
+test('deepEqual', function (t) {
+	t.ok(
+		!deepEqual([1, 2, 3], { 0: 1, 1: 2, 2: 3 }),
+		'arrays are not objects'
+	);
+	t.end();
+});
+
+test('falsy', function (t) {
+	t.ok(
+		!deepEqual([undefined], [null]),
+		'null is not undefined!'
+	);
+
+	t.ok(
+		!deepEqual([null], [undefined]),
+		'undefined is not null!'
+	);
+
+	t.ok(
+		!deepEqual(
+			{ a: 1, b: 2, c: [3, undefined, 5] },
+			{ a: 1, b: 2, c: [3, null, 5] }
+		),
+		'undefined is not null, however deeply!'
+	);
+
+	t.ok(
+		!deepEqual(
+			{ a: 1, b: 2, c: [3, undefined, 5] },
+			{ a: 1, b: 2, c: [3, null, 5] }
+		),
+		'null is not undefined, however deeply!'
+	);
+
+	t.ok(
+		!deepEqual(
+			{ a: 1, b: 2, c: [3, undefined, 5] },
+			{ a: 1, b: 2, c: [3, null, 5] }
+		),
+		'null is not undefined, however deeply!'
+	);
+
+	t.end();
+});
+
+test('deletedArrayEqual', function (t) {
+	var xs = [1, 2, 3, 4];
+	delete xs[2];
+
+	var ys = Object.create(Array.prototype);
+	ys[0] = 1;
+	ys[1] = 2;
+	ys[3] = 4;
+
+	t.ok(
+		deepEqual(xs, ys),
+		'arrays with deleted elements are only equal to arrays with similarly deleted elements'
+	);
+
+	t.ok(
+		!deepEqual(xs, [1, 2, undefined, 4]),
+		'deleted array elements cannot be undefined'
+	);
+
+	t.ok(
+		!deepEqual(xs, [1, 2, null, 4]),
+		'deleted array elements cannot be null'
+	);
+
+	t.end();
+});
+
+test('deletedObjectEqual', function (t) {
+	var obj = { a: 1, b: 2, c: 3 };
+	delete obj.c;
+
+	t.ok(
+		deepEqual(obj, { a: 1, b: 2 }),
+		'deleted object elements should not show up'
+	);
+
+	t.ok(
+		!deepEqual(obj, { a: 1, b: 2, c: undefined }),
+		'deleted object elements are not undefined'
+	);
+
+	t.ok(
+		!deepEqual(obj, { a: 1, b: 2, c: null }),
+		'deleted object elements are not null'
+	);
+
+	t.end();
+});
+
+test('emptyKeyEqual', function (t) {
+	t.ok(!deepEqual({ a: 1 }, { a: 1, '': 55 }));
+
+	t.end();
+});
+
+test('deepArguments', function (t) {
+	t.ok(
+		!deepEqual(
+			[4, 5, 6],
+			(function () { return arguments; }(4, 5, 6))
+		),
+		'arguments are not arrays'
+	);
+
+	t.ok(
+		deepEqual(
+			(function () { return arguments; }(4, 5, 6)),
+			(function () { return arguments; }(4, 5, 6))
+		),
+		'arguments should equal'
+	);
+
+	t.end();
+});
+
+test('deepUn', function (t) {
+	t.ok(!deepEqual({ a: 1, b: 2 }, undefined));
+	t.ok(!deepEqual({ a: 1, b: 2 }, {}));
+	t.ok(!deepEqual(undefined, { a: 1, b: 2 }));
+	t.ok(!deepEqual({}, { a: 1, b: 2 }));
+	t.ok(deepEqual(undefined, undefined));
+	t.ok(deepEqual(null, null));
+	t.ok(!deepEqual(undefined, null));
+
+	t.end();
+});
+
+test('deepLevels', function (t) {
+	var xs = [1, 2, [3, 4, [5, 6]]];
+	t.ok(!deepEqual(xs, []));
+	t.end();
+});

node_modules/traverse/test/error.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var test = require('tape');
+var traverse = require('../');
+
+test('traverse an Error', function (t) {
+	var obj = new Error('test');
+	var results = traverse(obj).map(function () {});
+	t.same(results, { message: 'test' });
+
+	t.end();
+});
+

node_modules/traverse/test/has.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var test = require('tape');
+var traverse = require('../');
+
+test('has', function (t) {
+	var obj = { a: 2, b: [4, 5, { c: 6 }] };
+
+	t.equal(traverse(obj).has(['b', 2, 'c']), true);
+	t.equal(traverse(obj).has(['b', 2, 'c', 0]), false);
+	t.equal(traverse(obj).has(['b', 2, 'd']), false);
+	t.equal(traverse(obj).has([]), true);
+	t.equal(traverse(obj).has(['a']), true);
+	t.equal(traverse(obj).has(['a', 2]), false);
+
+	t.end();
+});

node_modules/traverse/test/instance.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var test = require('tape');
+var traverse = require('../');
+var EventEmitter = require('events').EventEmitter;
+
+test('check instanceof on node elems', function (t) {
+	var counts = { emitter: 0 };
+
+	traverse([new EventEmitter(), 3, 4, { ev: new EventEmitter() }])
+		.forEach(function (node) {
+			if (node instanceof EventEmitter) { counts.emitter += 1; }
+		});
+	t.equal(counts.emitter, 2);
+
+	t.end();
+});

node_modules/traverse/test/interface.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var test = require('tape');
+var traverse = require('../');
+
+test('interface map', function (t) {
+	var obj = { a: [5, 6, 7], b: { c: [8] } };
+
+	t.same(
+		traverse.paths(obj)
+			.sort()
+			.map(function (path) { return path.join('/'); })
+			.slice(1)
+			.join(' ')
+		,
+		'a a/0 a/1 a/2 b b/c b/c/0'
+	);
+
+	t.same(
+		traverse.nodes(obj),
+		[
+			{ a: [5, 6, 7], b: { c: [8] } },
+			[5, 6, 7], 5, 6, 7,
+			{ c: [8] }, [8], 8,
+		]
+	);
+
+	t.same(
+		traverse.map(obj, function (node) {
+			if (typeof node === 'number') {
+				return node + 1000;
+			}
+			if (Array.isArray(node)) {
+				return node.join(' ');
+			}
+			return void undefined;
+		}),
+		{ a: '5 6 7', b: { c: '8' } }
+	);
+
+	var nodes = 0;
+	traverse.forEach(obj, function () { nodes += 1; });
+	t.equal(nodes, 8);
+
+	t.end();
+});

node_modules/traverse/test/json.js

@@ -0,0 +1,55 @@
+'use strict';
+
+var test = require('tape');
+var traverse = require('../');
+
+test('json test', function (t) {
+	var id = 54;
+	var callbacks = {};
+	var obj = { moo: function () {}, foo: [2, 3, 4, function () {}] };
+
+	var scrubbed = traverse(obj).map(function (x) {
+		if (typeof x === 'function') {
+			callbacks[id] = { id: id, f: x, path: this.path };
+			this.update('[Function]');
+			id += 1;
+		}
+	});
+
+	t.equal(
+		scrubbed.moo,
+		'[Function]',
+		'obj.moo replaced with "[Function]"'
+	);
+
+	t.equal(
+		scrubbed.foo[3],
+		'[Function]',
+		'obj.foo[3] replaced with "[Function]"'
+	);
+
+	t.same(scrubbed, {
+		moo: '[Function]',
+		foo: [2, 3, 4, '[Function]'],
+	}, 'Full JSON string matches');
+
+	t.same(
+		typeof obj.moo,
+		'function',
+		'Original obj.moo still a function'
+	);
+
+	t.same(
+		typeof obj.foo[3],
+		'function',
+		'Original obj.foo[3] still a function'
+	);
+
+	t.same(callbacks, {
+		54: { id: 54, f: obj.moo, path: ['moo'] },
+		55: { id: 55, f: obj.foo[3], path: ['foo', '3'] },
+	}, 'Check the generated callbacks list');
+
+	t.end();
+});
+

node_modules/traverse/test/keys.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var test = require('tape');
+var traverse = require('../');
+
+test('sort test', function (t) {
+	var acc = [];
+	traverse({
+		a: 30,
+		b: 22,
+		id: 9,
+	}).forEach(function (node) {
+		if (!Array.isArray(node) && typeof node === 'object') {
+			this.before(function (beforeNode) {
+				this.keys = Object.keys(beforeNode);
+				this.keys.sort(function (a, b) {
+					var aA = [a === 'id' ? 0 : 1, a];
+					var bA = [b === 'id' ? 0 : 1, b];
+					return aA < bA ? -1 : aA > bA ? 1 : 0;
+				});
+			});
+		}
+		if (this.isLeaf) { acc.push(node); }
+	});
+
+	t.equal(
+		acc.join(' '),
+		'9 30 22',
+		'Traversal in a custom order'
+	);
+
+	t.end();
+});

node_modules/traverse/test/leaves.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var test = require('tape');
+var traverse = require('../');
+
+test('leaves test', function (t) {
+	var acc = [];
+	traverse({
+		a: [1, 2, 3],
+		b: 4,
+		c: [5, 6],
+		d: { e: [7, 8], f: 9 },
+	}).forEach(function (x) {
+		if (this.isLeaf) { acc.push(x); }
+	});
+
+	t.equal(
+		acc.join(' '),
+		'1 2 3 4 5 6 7 8 9',
+		'Traversal in the right(?) order'
+	);
+
+	t.end();
+});

node_modules/traverse/test/lib/deep_equal.js

@@ -0,0 +1,87 @@
+'use strict';
+
+var traverse = require('../../');
+
+function toS(o) {
+	return Object.prototype.toString.call(o);
+}
+
+module.exports = function (a, b) {
+	if (arguments.length !== 2) {
+		throw new Error('deepEqual requires exactly two objects to compare against');
+	}
+
+	var equal = true;
+	function notEqual() {
+		equal = false;
+		// this.stop();
+		return undefined;
+	}
+
+	var node = b;
+
+	traverse(a).forEach(function (y) { // eslint-disable-line consistent-return
+
+		// if (node === undefined || node === null) return notEqual();
+
+		if (!this.isRoot) {
+			/*
+            if (!Object.hasOwnProperty.call(node, this.key)) {
+                return notEqual();
+            }
+        */
+			if (typeof node !== 'object') { return notEqual(); }
+			node = node[this.key];
+		}
+
+		var x = node;
+
+		this.post(function () {
+			node = x;
+		});
+
+		if (this.circular) {
+			if (traverse(b).get(this.circular.path) !== x) { notEqual(); }
+		} else if (typeof x !== typeof y) {
+			notEqual();
+		} else if (x === null || y === null || x === undefined || y === undefined) {
+			if (x !== y) { notEqual(); }
+		} else if (x.__proto__ !== y.__proto__) {
+			notEqual();
+		} else if (x === y) {
+			// nop
+		} else if (typeof x === 'function') {
+			if (x instanceof RegExp) {
+				// both regexps on account of the __proto__ check
+				if (String(x) !== String(y)) { notEqual(); }
+			} else if (x !== y) { notEqual(); }
+		} else if (typeof x === 'object') {
+			if (toS(y) === '[object Arguments]'
+            || toS(x) === '[object Arguments]') {
+				if (toS(x) !== toS(y)) {
+					notEqual();
+				}
+			} else if (toS(y) === '[object RegExp]'
+            || toS(x) === '[object RegExp]') {
+				if (!x || !y || x.toString() !== y.toString()) { notEqual(); }
+			} else if (x instanceof Date || y instanceof Date) {
+				if (!(x instanceof Date) || !(y instanceof Date)
+                || x.getTime() !== y.getTime()) {
+					notEqual();
+				}
+			} else {
+				var kx = Object.keys(x);
+				var ky = Object.keys(y);
+				if (kx.length !== ky.length) { return notEqual(); }
+				for (var i = 0; i < kx.length; i++) {
+					var k = kx[i];
+					if (!Object.hasOwnProperty.call(y, k)) {
+						notEqual();
+					}
+				}
+			}
+		}
+	});
+
+	return equal;
+};

node_modules/traverse/test/mutability.js

@@ -0,0 +1,276 @@
+'use strict';
+
+var test = require('tape');
+var assert = require('assert');
+var traverse = require('../');
+var deepEqual = require('./lib/deep_equal');
+
+test('mutate', function (t) {
+	var obj = { a: 1, b: 2, c: [3, 4] };
+	var res = traverse(obj).forEach(function (x) {
+		if (typeof x === 'number' && x % 2 === 0) {
+			this.update(x * 10);
+		}
+	});
+	t.same(obj, res);
+	t.same(obj, { a: 1, b: 20, c: [3, 40] });
+	t.end();
+});
+
+test('mutateT', function (t) {
+	var obj = { a: 1, b: 2, c: [3, 4] };
+	var res = traverse.forEach(obj, function (x) {
+		if (typeof x === 'number' && x % 2 === 0) {
+			this.update(x * 10);
+		}
+	});
+	t.same(obj, res);
+	t.same(obj, { a: 1, b: 20, c: [3, 40] });
+	t.end();
+});
+
+test('map', function (t) {
+	var obj = { a: 1, b: 2, c: [3, 4] };
+	var res = traverse(obj).map(function (x) {
+		if (typeof x === 'number' && x % 2 === 0) {
+			this.update(x * 10);
+		}
+	});
+	t.same(obj, { a: 1, b: 2, c: [3, 4] });
+	t.same(res, { a: 1, b: 20, c: [3, 40] });
+	t.end();
+});
+
+test('mapT', function (t) {
+	var obj = { a: 1, b: 2, c: [3, 4] };
+	var res = traverse.map(obj, function (x) {
+		if (typeof x === 'number' && x % 2 === 0) {
+			this.update(x * 10);
+		}
+	});
+	t.same(obj, { a: 1, b: 2, c: [3, 4] });
+	t.same(res, { a: 1, b: 20, c: [3, 40] });
+	t.end();
+});
+
+test('clone', function (t) {
+	var obj = { a: 1, b: 2, c: [3, 4] };
+	var res = traverse(obj).clone();
+	t.same(obj, res);
+	t.ok(obj !== res);
+	obj.a += 1;
+	t.same(res.a, 1);
+	obj.c.push(5);
+	t.same(res.c, [3, 4]);
+	t.end();
+});
+
+test('cloneT', function (t) {
+	var obj = { a: 1, b: 2, c: [3, 4] };
+	var res = traverse.clone(obj);
+	t.same(obj, res);
+	t.ok(obj !== res);
+	obj.a += 1;
+	t.same(res.a, 1);
+	obj.c.push(5);
+	t.same(res.c, [3, 4]);
+	t.end();
+});
+
+test('reduce', function (t) {
+	var obj = { a: 1, b: 2, c: [3, 4] };
+	var res = traverse(obj).reduce(function (acc, x) {
+		if (this.isLeaf) { acc.push(x); }
+		return acc;
+	}, []);
+	t.same(obj, { a: 1, b: 2, c: [3, 4] });
+	t.same(res, [1, 2, 3, 4]);
+	t.end();
+});
+
+test('reduceInit', function (t) {
+	var obj = { a: 1, b: 2, c: [3, 4] };
+	var res = traverse(obj).reduce(function (acc) {
+		if (this.isRoot) { assert.fail('got root'); }
+		return acc;
+	});
+	t.same(obj, { a: 1, b: 2, c: [3, 4] });
+	t.same(res, obj);
+	t.end();
+});
+
+test('remove', function (t) {
+	var obj = { a: 1, b: 2, c: [3, 4] };
+	traverse(obj).forEach(function (x) {
+		if (this.isLeaf && x % 2 === 0) { this.remove(); }
+	});
+
+	t.same(obj, { a: 1, c: [3] });
+	t.end();
+});
+
+test('removeNoStop', function (t) {
+	var obj = { a: 1, b: 2, c: { d: 3, e: 4 }, f: 5 };
+
+	var keys = [];
+	traverse(obj).forEach(function () {
+		keys.push(this.key);
+		if (this.key === 'c') { this.remove(); }
+	});
+
+	t.same(keys, [undefined, 'a', 'b', 'c', 'd', 'e', 'f']);
+	t.end();
+});
+
+test('removeStop', function (t) {
+	var obj = { a: 1, b: 2, c: { d: 3, e: 4 }, f: 5 };
+
+	var keys = [];
+	traverse(obj).forEach(function () {
+		keys.push(this.key);
+		if (this.key === 'c') { this.remove(true); }
+	});
+
+	t.same(keys, [undefined, 'a', 'b', 'c', 'f']);
+	t.end();
+});
+
+test('removeMap', function (t) {
+	var obj = { a: 1, b: 2, c: [3, 4] };
+	var res = traverse(obj).map(function (x) {
+		if (this.isLeaf && x % 2 === 0) { this.remove(); }
+	});
+
+	t.same(obj, { a: 1, b: 2, c: [3, 4] });
+	t.same(res, { a: 1, c: [3] });
+	t.end();
+});
+
+test('delete', function (t) {
+	var obj = { a: 1, b: 2, c: [3, 4] };
+	traverse(obj).forEach(function (x) {
+		if (this.isLeaf && x % 2 === 0) { this.delete(); }
+	});
+
+	t.ok(!deepEqual(obj, { a: 1, c: [3, undefined] }));
+
+	t.ok(deepEqual(obj, { a: 1, c: [3] }));
+
+	t.ok(!deepEqual(obj, { a: 1, c: [3, null] }));
+	t.end();
+});
+
+test('deleteNoStop', function (t) {
+	var obj = { a: 1, b: 2, c: { d: 3, e: 4 } };
+
+	var keys = [];
+	traverse(obj).forEach(function () {
+		keys.push(this.key);
+		if (this.key === 'c') { this.delete(); }
+	});
+
+	t.same(keys, [undefined, 'a', 'b', 'c', 'd', 'e']);
+	t.end();
+});
+
+test('deleteStop', function (t) {
+	var obj = { a: 1, b: 2, c: { d: 3, e: 4 } };
+
+	var keys = [];
+	traverse(obj).forEach(function () {
+		keys.push(this.key);
+		if (this.key === 'c') { this.delete(true); }
+	});
+
+	t.same(keys, [undefined, 'a', 'b', 'c']);
+	t.end();
+});
+
+test('deleteRedux', function (t) {
+	var obj = { a: 1, b: 2, c: [3, 4, 5] };
+	traverse(obj).forEach(function (x) {
+		if (this.isLeaf && x % 2 === 0) { this.delete(); }
+	});
+
+	t.ok(!deepEqual(obj, { a: 1, c: [3, undefined, 5] }));
+
+	t.ok(deepEqual(obj, { a: 1, c: [3,, 5] }));
+
+	t.ok(!deepEqual(obj, { a: 1, c: [3, null, 5] }));
+
+	t.ok(!deepEqual(obj, { a: 1, c: [3, 5] }));
+
+	t.end();
+});
+
+test('deleteMap', function (t) {
+	var obj = { a: 1, b: 2, c: [3, 4] };
+	var res = traverse(obj).map(function (x) {
+		if (this.isLeaf && x % 2 === 0) { this.delete(); }
+	});
+
+	t.ok(deepEqual(
+		obj,
+		{ a: 1, b: 2, c: [3, 4] }
+	));
+
+	var xs = [3, 4];
+	delete xs[1];
+
+	t.ok(deepEqual(res, { a: 1, c: xs }));
+
+	t.ok(deepEqual(res, { a: 1, c: [3,,] })); // eslint-disable-line comma-spacing
+
+	t.ok(deepEqual(res, { a: 1, c: [3] }));
+
+	t.end();
+});
+
+test('deleteMapRedux', function (t) {
+	var obj = { a: 1, b: 2, c: [3, 4, 5] };
+	var res = traverse(obj).map(function (x) {
+		if (this.isLeaf && x % 2 === 0) { this.delete(); }
+	});
+
+	t.ok(deepEqual(
+		obj,
+		{ a: 1, b: 2, c: [3, 4, 5] }
+	));
+
+	var xs = [3, 4, 5];
+	delete xs[1];
+
+	t.ok(deepEqual(res, { a: 1, c: xs }));
+
+	t.ok(!deepEqual(res, { a: 1, c: [3, 5] }));
+
+	t.ok(deepEqual(res, { a: 1, c: [3,, 5] }));
+
+	t.end();
+});
+
+test('objectToString', function (t) {
+	var obj = { a: 1, b: 2, c: [3, 4] };
+	var res = traverse(obj).forEach(function (x) {
+		if (typeof x === 'object' && !this.isRoot) {
+			this.update(JSON.stringify(x));
+		}
+	});
+	t.same(obj, res);
+	t.same(obj, { a: 1, b: 2, c: '[3,4]' });
+	t.end();
+});
+
+test('stringToObject', function (t) {
+	var obj = { a: 1, b: 2, c: '[3,4]' };
+	var res = traverse(obj).forEach(function (x) {
+		if (typeof x === 'string') {
+			this.update(JSON.parse(x));
+		} else if (typeof x === 'number' && x % 2 === 0) {
+			this.update(x * 10);
+		}
+	});
+	t.deepEqual(obj, res);
+	t.deepEqual(obj, { a: 1, b: 20, c: [3, 40] });
+	t.end();
+});

node_modules/traverse/test/negative.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var traverse = require('../');
+var test = require('tape');
+
+test('negative update test', function (t) {
+	var obj = [5, 6, -3, [7, 8, -2, 1], { f: 10, g: -13 }];
+	var fixed = traverse.map(obj, function (x) {
+		if (x < 0) { this.update(x + 128); }
+	});
+
+	t.same(
+		fixed,
+		[5, 6, 125, [7, 8, 126, 1], { f: 10, g: 115 }],
+		'Negative values += 128'
+	);
+
+	t.same(
+		obj,
+		[5, 6, -3, [7, 8, -2, 1], { f: 10, g: -13 }],
+		'Original references not modified'
+	);
+
+	t.end();
+});

node_modules/traverse/test/obj.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var test = require('tape');
+var traverse = require('../');
+
+test('traverse an object with nested functions', function (t) {
+	t.plan(1);
+
+	function Cons(x) {
+		t.equal(x, 10);
+	}
+	traverse(new Cons(10));
+});

node_modules/traverse/test/siblings.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var test = require('tape');
+var traverse = require('../');
+
+test('siblings', function (t) {
+	var obj = { a: 1, b: 2, c: [4, 5, 6] };
+
+	var res = traverse(obj).reduce(function (acc) {
+		/* eslint no-param-reassign: 0 */
+		var p = '/' + this.path.join('/');
+		if (this.parent) {
+			acc[p] = {
+				siblings: this.parent.keys,
+				key: this.key,
+				index: this.parent.keys.indexOf(this.key),
+			};
+		} else {
+			acc[p] = {
+				siblings: [],
+				key: this.key,
+				index: -1,
+			};
+		}
+		return acc;
+	}, {});
+
+	t.same(res, {
+		'/': { siblings: [], key: undefined, index: -1 },
+		'/a': { siblings: ['a', 'b', 'c'], key: 'a', index: 0 },
+		'/b': { siblings: ['a', 'b', 'c'], key: 'b', index: 1 },
+		'/c': { siblings: ['a', 'b', 'c'], key: 'c', index: 2 },
+		'/c/0': { siblings: ['0', '1', '2'], key: '0', index: 0 },
+		'/c/1': { siblings: ['0', '1', '2'], key: '1', index: 1 },
+		'/c/2': { siblings: ['0', '1', '2'], key: '2', index: 2 },
+	});
+
+	t.end();
+});

node_modules/traverse/test/stop.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var test = require('tape');
+var traverse = require('../');
+
+test('stop', function (t) {
+	var visits = 0;
+	traverse('abcdefghij'.split('')).forEach(function (node) {
+		if (typeof node === 'string') {
+			visits += 1;
+			if (node === 'e') { this.stop(); }
+		}
+	});
+
+	t.equal(visits, 5);
+	t.end();
+});
+
+test('stopMap', function (t) {
+	var s = traverse('abcdefghij'.split('')).map(function (node) {
+		if (typeof node === 'string') {
+			if (node === 'e') { this.stop(); }
+			return node.toUpperCase();
+		}
+		return void undefined;
+	}).join('');
+
+	t.equal(s, 'ABCDEfghij');
+	t.end();
+});
+
+test('stopReduce', function (t) {
+	var obj = {
+		a: [4, 5],
+		b: [6, [7, 8, 9]],
+	};
+	var xs = traverse(obj).reduce(function (acc, node) {
+		if (this.isLeaf) {
+			if (node === 7) { this.stop(); } else { acc.push(node); }
+		}
+		return acc;
+	}, []);
+
+	t.same(xs, [4, 5, 6]);
+	t.end();
+});

node_modules/traverse/test/stringify.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var test = require('tape');
+var traverse = require('../');
+
+test('stringify', function (t) {
+	var obj = [5, 6, -3, [7, 8, -2, 1], { f: 10, g: -13 }];
+
+	var s = '';
+	traverse(obj).forEach(function (node) {
+		if (Array.isArray(node)) {
+			this.before(function () { s += '['; });
+			this.post(function (child) {
+				if (!child.isLast) { s += ','; }
+			});
+			this.after(function () { s += ']'; });
+		} else if (typeof node === 'object') {
+			this.before(function () { s += '{'; });
+			this.pre(function (x, key) {
+				s += '"' + key + '":';
+			});
+			this.post(function (child) {
+				if (!child.isLast) { s += ','; }
+			});
+			this.after(function () { s += '}'; });
+		} else if (typeof node === 'function') {
+			s += 'null';
+		} else {
+			s += node.toString();
+		}
+	});
+
+	t.equal(s, JSON.stringify(obj));
+	t.end();
+});

node_modules/traverse/test/subexpr.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var traverse = require('../');
+var test = require('tape');
+
+test('subexpr', function (t) {
+	var obj = ['a', 4, 'b', 5, 'c', 6];
+	var r = traverse(obj).map(function (x) {
+		if (typeof x === 'number') {
+			this.update([x - 0.1, x, x + 0.1], true);
+		}
+	});
+
+	t.same(obj, ['a', 4, 'b', 5, 'c', 6]);
+	t.same(r, [
+		'a', [3.9, 4, 4.1],
+		'b', [4.9, 5, 5.1],
+		'c', [5.9, 6, 6.1],
+	]);
+	t.end();
+});
+
+test('block', function (t) {
+	var obj = [[1], [2], [3]];
+	var r = traverse(obj).map(function (x) {
+		if (Array.isArray(x) && !this.isRoot) {
+			if (x[0] === 5) {
+				this.block();
+			} else {
+				this.update([[x[0] + 1]]);
+			}
+		}
+	});
+
+	t.same(r, [
+		[[[[[5]]]]],
+		[[[[5]]]],
+		[[[5]]],
+	]);
+	t.end();
+});

node_modules/traverse/test/super_deep.js

@@ -0,0 +1,56 @@
+'use strict';
+
+var test = require('tape');
+var deepEqual = require('./lib/deep_equal');
+
+function make() {
+	var a = { self: 'a' };
+	var b = { self: 'b' };
+	var c = { self: 'c' };
+	var d = { self: 'd' };
+	var e = { self: 'e' };
+
+	a.a = a;
+	a.b = b;
+	a.c = c;
+
+	b.a = a;
+	b.b = b;
+	b.c = c;
+
+	c.a = a;
+	c.b = b;
+	c.c = c;
+	c.d = d;
+
+	d.a = a;
+	d.b = b;
+	d.c = c;
+	d.d = d;
+	d.e = e;
+
+	e.a = a;
+	e.b = b;
+	e.c = c;
+	e.d = d;
+	e.e = e;
+
+	return a;
+}
+
+test('super_deep', function (t) {
+	var a0 = make();
+	var a1 = make();
+	t.ok(deepEqual(a0, a1));
+
+	a0.c.d.moo = true;
+	t.ok(!deepEqual(a0, a1));
+
+	a1.c.d.moo = true;
+	t.ok(deepEqual(a0, a1));
+
+	// TODO: this one
+	// a0.c.a = a1;
+	// t.ok(!deepEqual(a0, a1));
+	t.end();
+});