Beta 7 with some repo names changed.

Client/node_modules/es6-iterator/#/chain.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var setPrototypeOf = require("es5-ext/object/set-prototype-of")
+  , d              = require("d")
+  , Iterator       = require("../")
+  , validIterable  = require("../valid-iterable")
+
+  , push = Array.prototype.push
+  , defineProperties = Object.defineProperties
+  , IteratorChain;
+
+IteratorChain = function (iterators) {
+	defineProperties(this, {
+		__iterators__: d("", iterators),
+		__current__: d("w", iterators.shift())
+	});
+};
+if (setPrototypeOf) setPrototypeOf(IteratorChain, Iterator);
+
+IteratorChain.prototype = Object.create(Iterator.prototype, {
+	constructor: d(IteratorChain),
+	next: d(function () {
+		var result;
+		if (!this.__current__) return { done: true, value: undefined };
+		result = this.__current__.next();
+		while (result.done) {
+			this.__current__ = this.__iterators__.shift();
+			if (!this.__current__) return { done: true, value: undefined };
+			result = this.__current__.next();
+		}
+		return result;
+	})
+});
+
+module.exports = function () {
+	var iterators = [this];
+	push.apply(iterators, arguments);
+	iterators.forEach(validIterable);
+	return new IteratorChain(iterators);
+};

Client/node_modules/es6-iterator/array.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var setPrototypeOf = require("es5-ext/object/set-prototype-of")
+  , contains       = require("es5-ext/string/#/contains")
+  , d              = require("d")
+  , Symbol         = require("es6-symbol")
+  , Iterator       = require("./");
+
+var defineProperty = Object.defineProperty, ArrayIterator;
+
+ArrayIterator = module.exports = function (arr, kind) {
+	if (!(this instanceof ArrayIterator)) throw new TypeError("Constructor requires 'new'");
+	Iterator.call(this, arr);
+	if (!kind) kind = "value";
+	else if (contains.call(kind, "key+value")) kind = "key+value";
+	else if (contains.call(kind, "key")) kind = "key";
+	else kind = "value";
+	defineProperty(this, "__kind__", d("", kind));
+};
+if (setPrototypeOf) setPrototypeOf(ArrayIterator, Iterator);
+
+// Internal %ArrayIteratorPrototype% doesn't expose its constructor
+delete ArrayIterator.prototype.constructor;
+
+ArrayIterator.prototype = Object.create(Iterator.prototype, {
+	_resolve: d(function (i) {
+		if (this.__kind__ === "value") return this.__list__[i];
+		if (this.__kind__ === "key+value") return [i, this.__list__[i]];
+		return i;
+	})
+});
+defineProperty(ArrayIterator.prototype, Symbol.toStringTag, d("c", "Array Iterator"));

Client/node_modules/es6-iterator/for-of.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var isArguments = require("es5-ext/function/is-arguments")
+  , callable    = require("es5-ext/object/valid-callable")
+  , isString    = require("es5-ext/string/is-string")
+  , get         = require("./get");
+
+var isArray = Array.isArray, call = Function.prototype.call, some = Array.prototype.some;
+
+module.exports = function (iterable, cb /*, thisArg*/) {
+	var mode, thisArg = arguments[2], result, doBreak, broken, i, length, char, code;
+	if (isArray(iterable) || isArguments(iterable)) mode = "array";
+	else if (isString(iterable)) mode = "string";
+	else iterable = get(iterable);
+
+	callable(cb);
+	doBreak = function () {
+		broken = true;
+	};
+	if (mode === "array") {
+		some.call(iterable, function (value) {
+			call.call(cb, thisArg, value, doBreak);
+			return broken;
+		});
+		return;
+	}
+	if (mode === "string") {
+		length = iterable.length;
+		for (i = 0; i < length; ++i) {
+			char = iterable[i];
+			if (i + 1 < length) {
+				code = char.charCodeAt(0);
+				if (code >= 0xd800 && code <= 0xdbff) char += iterable[++i];
+			}
+			call.call(cb, thisArg, char, doBreak);
+			if (broken) break;
+		}
+		return;
+	}
+	result = iterable.next();
+
+	while (!result.done) {
+		call.call(cb, thisArg, result.value, doBreak);
+		if (broken) return;
+		result = iterable.next();
+	}
+};

Client/node_modules/es6-iterator/get.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var isArguments    = require("es5-ext/function/is-arguments")
+  , isString       = require("es5-ext/string/is-string")
+  , ArrayIterator  = require("./array")
+  , StringIterator = require("./string")
+  , iterable       = require("./valid-iterable")
+  , iteratorSymbol = require("es6-symbol").iterator;
+
+module.exports = function (obj) {
+	if (typeof iterable(obj)[iteratorSymbol] === "function") return obj[iteratorSymbol]();
+	if (isArguments(obj)) return new ArrayIterator(obj);
+	if (isString(obj)) return new StringIterator(obj);
+	return new ArrayIterator(obj);
+};

Client/node_modules/es6-iterator/index.js

@@ -0,0 +1,106 @@
+"use strict";
+
+var clear    = require("es5-ext/array/#/clear")
+  , assign   = require("es5-ext/object/assign")
+  , callable = require("es5-ext/object/valid-callable")
+  , value    = require("es5-ext/object/valid-value")
+  , d        = require("d")
+  , autoBind = require("d/auto-bind")
+  , Symbol   = require("es6-symbol");
+
+var defineProperty = Object.defineProperty, defineProperties = Object.defineProperties, Iterator;
+
+module.exports = Iterator = function (list, context) {
+	if (!(this instanceof Iterator)) throw new TypeError("Constructor requires 'new'");
+	defineProperties(this, {
+		__list__: d("w", value(list)),
+		__context__: d("w", context),
+		__nextIndex__: d("w", 0)
+	});
+	if (!context) return;
+	callable(context.on);
+	context.on("_add", this._onAdd);
+	context.on("_delete", this._onDelete);
+	context.on("_clear", this._onClear);
+};
+
+// Internal %IteratorPrototype% doesn't expose its constructor
+delete Iterator.prototype.constructor;
+
+defineProperties(
+	Iterator.prototype,
+	assign(
+		{
+			_next: d(function () {
+				var i;
+				if (!this.__list__) return undefined;
+				if (this.__redo__) {
+					i = this.__redo__.shift();
+					if (i !== undefined) return i;
+				}
+				if (this.__nextIndex__ < this.__list__.length) return this.__nextIndex__++;
+				this._unBind();
+				return undefined;
+			}),
+			next: d(function () {
+				return this._createResult(this._next());
+			}),
+			_createResult: d(function (i) {
+				if (i === undefined) return { done: true, value: undefined };
+				return { done: false, value: this._resolve(i) };
+			}),
+			_resolve: d(function (i) {
+				return this.__list__[i];
+			}),
+			_unBind: d(function () {
+				this.__list__ = null;
+				delete this.__redo__;
+				if (!this.__context__) return;
+				this.__context__.off("_add", this._onAdd);
+				this.__context__.off("_delete", this._onDelete);
+				this.__context__.off("_clear", this._onClear);
+				this.__context__ = null;
+			}),
+			toString: d(function () {
+				return "[object " + (this[Symbol.toStringTag] || "Object") + "]";
+			})
+		},
+		autoBind({
+			_onAdd: d(function (index) {
+				if (index >= this.__nextIndex__) return;
+				++this.__nextIndex__;
+				if (!this.__redo__) {
+					defineProperty(this, "__redo__", d("c", [index]));
+					return;
+				}
+				this.__redo__.forEach(function (redo, i) {
+					if (redo >= index) this.__redo__[i] = ++redo;
+				}, this);
+				this.__redo__.push(index);
+			}),
+			_onDelete: d(function (index) {
+				var i;
+				if (index >= this.__nextIndex__) return;
+				--this.__nextIndex__;
+				if (!this.__redo__) return;
+				i = this.__redo__.indexOf(index);
+				if (i !== -1) this.__redo__.splice(i, 1);
+				this.__redo__.forEach(function (redo, j) {
+					if (redo > index) this.__redo__[j] = --redo;
+				}, this);
+			}),
+			_onClear: d(function () {
+				if (this.__redo__) clear.call(this.__redo__);
+				this.__nextIndex__ = 0;
+			})
+		})
+	)
+);
+
+defineProperty(
+	Iterator.prototype,
+	Symbol.iterator,
+	d(function () {
+		return this;
+	})
+);

Client/node_modules/es6-iterator/is-iterable.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var isArguments = require("es5-ext/function/is-arguments")
+  , isValue     = require("es5-ext/object/is-value")
+  , isString    = require("es5-ext/string/is-string");
+
+var iteratorSymbol = require("es6-symbol").iterator
+  , isArray        = Array.isArray;
+
+module.exports = function (value) {
+	if (!isValue(value)) return false;
+	if (isArray(value)) return true;
+	if (isString(value)) return true;
+	if (isArguments(value)) return true;
+	return typeof value[iteratorSymbol] === "function";
+};

Client/node_modules/es6-iterator/package.json

@@ -0,0 +1,74 @@
+{
+  "_from": "es6-iterator@~2.0.3",
+  "_id": "es6-iterator@2.0.3",
+  "_inBundle": false,
+  "_integrity": "sha1-p96IkUGgWpSwhUQDstCg+/qY87c=",
+  "_location": "/es6-iterator",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "es6-iterator@~2.0.3",
+    "name": "es6-iterator",
+    "escapedName": "es6-iterator",
+    "rawSpec": "~2.0.3",
+    "saveSpec": null,
+    "fetchSpec": "~2.0.3"
+  },
+  "_requiredBy": [
+    "/es5-ext"
+  ],
+  "_resolved": "https://registry.npmjs.org/es6-iterator/-/es6-iterator-2.0.3.tgz",
+  "_shasum": "a7de889141a05a94b0854403b2d0a0fbfa98f3b7",
+  "_spec": "es6-iterator@~2.0.3",
+  "_where": "C:\\Users\\Luis\\source\\repos\\AAMasters\\BackendServers\\node_modules\\es5-ext",
+  "author": {
+    "name": "Mariusz Nowak",
+    "email": "medyk@medikoo.com",
+    "url": "http://www.medikoo.com/"
+  },
+  "bugs": {
+    "url": "https://github.com/medikoo/es6-iterator/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "d": "1",
+    "es5-ext": "^0.10.35",
+    "es6-symbol": "^3.1.1"
+  },
+  "deprecated": false,
+  "description": "Iterator abstraction based on ES6 specification",
+  "devDependencies": {
+    "eslint": "^4.9",
+    "eslint-config-medikoo-es5": "^1.4.4",
+    "event-emitter": "^0.3.5",
+    "tad": "^0.2.7"
+  },
+  "eslintConfig": {
+    "extends": "medikoo-es5",
+    "root": true,
+    "rules": {
+      "no-extend-native": "off"
+    }
+  },
+  "homepage": "https://github.com/medikoo/es6-iterator#readme",
+  "keywords": [
+    "iterator",
+    "array",
+    "list",
+    "set",
+    "map",
+    "generator"
+  ],
+  "license": "MIT",
+  "name": "es6-iterator",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/medikoo/es6-iterator.git"
+  },
+  "scripts": {
+    "lint": "eslint --ignore-path=.gitignore .",
+    "test": "node ./node_modules/tad/bin/tad"
+  },
+  "version": "2.0.3"
+}

Client/node_modules/es6-iterator/string.js

@@ -0,0 +1,39 @@
+// Thanks @mathiasbynens
+// http://mathiasbynens.be/notes/javascript-unicode#iterating-over-symbols
+
+"use strict";
+
+var setPrototypeOf = require("es5-ext/object/set-prototype-of")
+  , d              = require("d")
+  , Symbol         = require("es6-symbol")
+  , Iterator       = require("./");
+
+var defineProperty = Object.defineProperty, StringIterator;
+
+StringIterator = module.exports = function (str) {
+	if (!(this instanceof StringIterator)) throw new TypeError("Constructor requires 'new'");
+	str = String(str);
+	Iterator.call(this, str);
+	defineProperty(this, "__length__", d("", str.length));
+};
+if (setPrototypeOf) setPrototypeOf(StringIterator, Iterator);
+
+// Internal %ArrayIteratorPrototype% doesn't expose its constructor
+delete StringIterator.prototype.constructor;
+
+StringIterator.prototype = Object.create(Iterator.prototype, {
+	_next: d(function () {
+		if (!this.__list__) return undefined;
+		if (this.__nextIndex__ < this.__length__) return this.__nextIndex__++;
+		this._unBind();
+		return undefined;
+	}),
+	_resolve: d(function (i) {
+		var char = this.__list__[i], code;
+		if (this.__nextIndex__ === this.__length__) return char;
+		code = char.charCodeAt(0);
+		if (code >= 0xd800 && code <= 0xdbff) return char + this.__list__[this.__nextIndex__++];
+		return char;
+	})
+});
+defineProperty(StringIterator.prototype, Symbol.toStringTag, d("c", "String Iterator"));

Client/node_modules/es6-iterator/test/#/chain.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var Iterator = require("../../");
+
+module.exports = function (t, a) {
+	var i1 = new Iterator(["raz", "dwa", "trzy"])
+	  , i2 = new Iterator(["cztery", "pięć", "sześć"])
+	  , i3 = new Iterator(["siedem", "osiem", "dziewięć"])
+
+	  , iterator = t.call(i1, i2, i3);
+
+	a.deep(iterator.next(), { done: false, value: "raz" }, "#1");
+	a.deep(iterator.next(), { done: false, value: "dwa" }, "#2");
+	a.deep(iterator.next(), { done: false, value: "trzy" }, "#3");
+	a.deep(iterator.next(), { done: false, value: "cztery" }, "#4");
+	a.deep(iterator.next(), { done: false, value: "pięć" }, "#5");
+	a.deep(iterator.next(), { done: false, value: "sześć" }, "#6");
+	a.deep(iterator.next(), { done: false, value: "siedem" }, "#7");
+	a.deep(iterator.next(), { done: false, value: "osiem" }, "#8");
+	a.deep(iterator.next(), { done: false, value: "dziewięć" }, "#9");
+	a.deep(iterator.next(), { done: true, value: undefined }, "Done #1");
+	a.deep(iterator.next(), { done: true, value: undefined }, "Done #2");
+};

Client/node_modules/es6-iterator/test/.eslintrc.json

@@ -0,0 +1,5 @@
+{
+  "rules": {
+    "id-length": "off"
+  }
+}

Client/node_modules/es6-iterator/test/array.js

@@ -0,0 +1,67 @@
+"use strict";
+
+var iteratorSymbol = require("es6-symbol").iterator;
+
+module.exports = function (T) {
+	return {
+		"Values": function (a) {
+			var x = ["raz", "dwa", "trzy", "cztery", "pięć", "sześć"], it;
+
+			it = new T(x);
+			a(it[iteratorSymbol](), it, "@@iterator");
+			a.deep(it.next(), { done: false, value: "raz" }, "#1");
+			a.deep(it.next(), { done: false, value: "dwa" }, "#2");
+			x.splice(1, 0, "elo");
+			a.deep(it.next(), { done: false, value: "dwa" }, "Insert");
+			a.deep(it.next(), { done: false, value: "trzy" }, "#3");
+			a.deep(it.next(), { done: false, value: "cztery" }, "#4");
+			x.pop();
+			a.deep(it.next(), { done: false, value: "pięć" }, "#5");
+			a.deep(it.next(), { done: true, value: undefined }, "End");
+		},
+		"Keys & Values": function (a) {
+			var x = ["raz", "dwa", "trzy", "cztery", "pięć", "sześć"], it;
+
+			it = new T(x, "key+value");
+			a(it[iteratorSymbol](), it, "@@iterator");
+			a.deep(it.next(), { done: false, value: [0, "raz"] }, "#1");
+			a.deep(it.next(), { done: false, value: [1, "dwa"] }, "#2");
+			x.splice(1, 0, "elo");
+			a.deep(it.next(), { done: false, value: [2, "dwa"] }, "Insert");
+			a.deep(it.next(), { done: false, value: [3, "trzy"] }, "#3");
+			a.deep(it.next(), { done: false, value: [4, "cztery"] }, "#4");
+			x.pop();
+			a.deep(it.next(), { done: false, value: [5, "pięć"] }, "#5");
+			a.deep(it.next(), { done: true, value: undefined }, "End");
+		},
+		"Keys": function (a) {
+			var x = ["raz", "dwa", "trzy", "cztery", "pięć", "sześć"], it;
+
+			it = new T(x, "key");
+			a(it[iteratorSymbol](), it, "@@iterator");
+			a.deep(it.next(), { done: false, value: 0 }, "#1");
+			a.deep(it.next(), { done: false, value: 1 }, "#2");
+			x.splice(1, 0, "elo");
+			a.deep(it.next(), { done: false, value: 2 }, "Insert");
+			a.deep(it.next(), { done: false, value: 3 }, "#3");
+			a.deep(it.next(), { done: false, value: 4 }, "#4");
+			x.pop();
+			a.deep(it.next(), { done: false, value: 5 }, "#5");
+			a.deep(it.next(), { done: true, value: undefined }, "End");
+		},
+		"Sparse": function (a) {
+			var x = new Array(6), it;
+
+			x[2] = "raz";
+			x[4] = "dwa";
+			it = new T(x);
+			a.deep(it.next(), { done: false, value: undefined }, "#1");
+			a.deep(it.next(), { done: false, value: undefined }, "#2");
+			a.deep(it.next(), { done: false, value: "raz" }, "#3");
+			a.deep(it.next(), { done: false, value: undefined }, "#4");
+			a.deep(it.next(), { done: false, value: "dwa" }, "#5");
+			a.deep(it.next(), { done: false, value: undefined }, "#6");
+			a.deep(it.next(), { done: true, value: undefined }, "End");
+		}
+	};
+};

Client/node_modules/es6-iterator/test/for-of.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var ArrayIterator = require("../array")
+
+  , slice = Array.prototype.slice;
+
+module.exports = function (t, a) {
+	var i = 0, x = ["raz", "dwa", "trzy"], y = {}, called = 0;
+	t(x, function () {
+		a.deep(slice.call(arguments, 0, 1), [x[i]], "Array " + i + "#");
+		a(this, y, "Array: context:  " + i++ + "#");
+	}, y);
+	i = 0;
+	t((function () {
+ return arguments;
+}("raz", "dwa", "trzy")), function () {
+		a.deep(slice.call(arguments, 0, 1), [x[i]], "Arguments" + i + "#");
+		a(this, y, "Arguments: context:  " + i++ + "#");
+	}, y);
+	i = 0;
+	t(x = "foo", function () {
+		a.deep(slice.call(arguments, 0, 1), [x[i]], "String " + i + "#");
+		a(this, y, "Regular String: context:  " + i++ + "#");
+	}, y);
+	i = 0;
+	x = ["r", "💩", "z"];
+	t("r💩z", function () {
+		a.deep(slice.call(arguments, 0, 1), [x[i]], "String " + i + "#");
+		a(this, y, "Unicode String: context:  " + i++ + "#");
+	}, y);
+	i = 0;
+	t(new ArrayIterator(x), function () {
+		a.deep(slice.call(arguments, 0, 1), [x[i]], "Iterator " + i + "#");
+		a(this, y, "Iterator: context:  " + i++ + "#");
+	}, y);
+
+	t(x = ["raz", "dwa", "trzy"], function (value, doBreak) {
+		++called;
+		return doBreak();
+	});
+	a(called, 1, "Break");
+};

Client/node_modules/es6-iterator/test/get.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var iteratorSymbol = require("es6-symbol").iterator
+  , Iterator       = require("../");
+
+module.exports = function (t, a) {
+	var iterator;
+	a.throws(function () {
+ t();
+}, TypeError, "Null");
+	a.throws(function () {
+ t({});
+}, TypeError, "Plain object");
+	a.throws(function () {
+ t({ length: 0 });
+}, TypeError, "Array-like");
+	iterator = {};
+	iterator[iteratorSymbol] = function () {
+ return new Iterator([]);
+};
+	a(t(iterator) instanceof Iterator, true, "Iterator");
+	a(String(t([])), "[object Array Iterator]", " Array");
+	a(String(t(function () {
+ return arguments;
+}())), "[object Array Iterator]", " Arguments");
+	a(String(t("foo")), "[object String Iterator]", "String");
+};

Client/node_modules/es6-iterator/test/index.js

@@ -0,0 +1,99 @@
+"use strict";
+
+var ee             = require("event-emitter")
+  , iteratorSymbol = require("es6-symbol").iterator;
+
+module.exports = function (T) {
+	return {
+		"": function (a) {
+			var x = ["raz", "dwa", "trzy", "cztery", "pięć"], it, y, z;
+
+			it = new T(x);
+			a(it[iteratorSymbol](), it, "@@iterator");
+			y = it.next();
+			a.deep(y, { done: false, value: "raz" }, "#1");
+			z = it.next();
+			a.not(y, z, "Recreate result");
+			a.deep(z, { done: false, value: "dwa" }, "#2");
+			a.deep(it.next(), { done: false, value: "trzy" }, "#3");
+			a.deep(it.next(), { done: false, value: "cztery" }, "#4");
+			a.deep(it.next(), { done: false, value: "pięć" }, "#5");
+			a.deep(y = it.next(), { done: true, value: undefined }, "End");
+			a.not(y, it.next(), "Recreate result on dead");
+		},
+		"Emited": function (a) {
+			var x = ["raz", "dwa", "trzy", "cztery", "pięć"], y, it;
+
+			y = ee();
+			it = new T(x, y);
+			a.deep(it.next(), { done: false, value: "raz" }, "#1");
+			a.deep(it.next(), { done: false, value: "dwa" }, "#2");
+			y.emit("_add", x.push("sześć") - 1);
+			a.deep(it.next(), { done: false, value: "trzy" }, "#3");
+			x.splice(1, 0, "półtora");
+			y.emit("_add", 1);
+			a.deep(it.next(), { done: false, value: "półtora" }, "Insert");
+			x.splice(5, 1);
+			y.emit("_delete", 5);
+			a.deep(it.next(), { done: false, value: "cztery" }, "#4");
+			a.deep(it.next(), { done: false, value: "sześć" }, "#5");
+			a.deep(it.next(), { done: true, value: undefined }, "End");
+		},
+		"Emited #2": function (a) {
+			var x = ["raz", "dwa", "trzy", "cztery", "pięć", "sześć"], y, it;
+
+			y = ee();
+			it = new T(x, y);
+			a.deep(it.next(), { done: false, value: "raz" }, "#1");
+			a.deep(it.next(), { done: false, value: "dwa" }, "#2");
+			x.splice(1, 0, "półtora");
+			y.emit("_add", 1);
+			x.splice(1, 0, "1.25");
+			y.emit("_add", 1);
+			x.splice(0, 1);
+			y.emit("_delete", 0);
+			a.deep(it.next(), { done: false, value: "półtora" }, "Insert");
+			a.deep(it.next(), { done: false, value: "1.25" }, "Insert #2");
+			a.deep(it.next(), { done: false, value: "trzy" }, "#3");
+			a.deep(it.next(), { done: false, value: "cztery" }, "#4");
+			x.splice(5, 1);
+			y.emit("_delete", 5);
+			a.deep(it.next(), { done: false, value: "sześć" }, "#5");
+			a.deep(it.next(), { done: true, value: undefined }, "End");
+		},
+		"Emited: Clear #1": function (a) {
+			var x = ["raz", "dwa", "trzy", "cztery", "pięć", "sześć"], y, it;
+
+			y = ee();
+			it = new T(x, y);
+			a.deep(it.next(), { done: false, value: "raz" }, "#1");
+			a.deep(it.next(), { done: false, value: "dwa" }, "#2");
+			x.length = 0;
+			y.emit("_clear");
+			a.deep(it.next(), { done: true, value: undefined }, "End");
+		},
+		"Emited: Clear #2": function (a) {
+			var x = ["raz", "dwa", "trzy", "cztery", "pięć", "sześć"], y, it;
+
+			y = ee();
+			it = new T(x, y);
+			a.deep(it.next(), { done: false, value: "raz" }, "#1");
+			a.deep(it.next(), { done: false, value: "dwa" }, "#2");
+			x.length = 0;
+			y.emit("_clear");
+			x.push("foo");
+			x.push("bar");
+			a.deep(it.next(), { done: false, value: "foo" }, "#3");
+			a.deep(it.next(), { done: false, value: "bar" }, "#4");
+			x.splice(1, 0, "półtora");
+			y.emit("_add", 1);
+			x.splice(1, 0, "1.25");
+			y.emit("_add", 1);
+			x.splice(0, 1);
+			y.emit("_delete", 0);
+			a.deep(it.next(), { done: false, value: "półtora" }, "Insert");
+			a.deep(it.next(), { done: false, value: "1.25" }, "Insert #2");
+			a.deep(it.next(), { done: true, value: undefined }, "End");
+		}
+	};
+};

Client/node_modules/es6-iterator/test/is-iterable.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var iteratorSymbol = require("es6-symbol").iterator
+  , Iterator       = require("../");
+
+module.exports = function (t, a) {
+	var iterator;
+	a(t(), false, "Undefined");
+	a(t(123), false, "Number");
+	a(t({}), false, "Plain object");
+	a(t({ length: 0 }), false, "Array-like");
+	iterator = {};
+	iterator[iteratorSymbol] = function () {
+ return new Iterator([]);
+};
+	a(t(iterator), true, "Iterator");
+	a(t([]), true, "Array");
+	a(t("foo"), true, "String");
+	a(t(""), true, "Empty string");
+	a(t(function () {
+ return arguments;
+}()), true, "Arguments");
+};

Client/node_modules/es6-iterator/test/string.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var iteratorSymbol = require("es6-symbol").iterator;
+
+module.exports = function (T, a) {
+	var it = new T("foobar");
+
+	a(it[iteratorSymbol](), it, "@@iterator");
+	a.deep(it.next(), { done: false, value: "f" }, "#1");
+	a.deep(it.next(), { done: false, value: "o" }, "#2");
+	a.deep(it.next(), { done: false, value: "o" }, "#3");
+	a.deep(it.next(), { done: false, value: "b" }, "#4");
+	a.deep(it.next(), { done: false, value: "a" }, "#5");
+	a.deep(it.next(), { done: false, value: "r" }, "#6");
+	a.deep(it.next(), { done: true, value: undefined }, "End");
+
+	a.h1("Outside of BMP");
+	it = new T("r💩z");
+	a.deep(it.next(), { done: false, value: "r" }, "#1");
+	a.deep(it.next(), { done: false, value: "💩" }, "#2");
+	a.deep(it.next(), { done: false, value: "z" }, "#3");
+	a.deep(it.next(), { done: true, value: undefined }, "End");
+};

Client/node_modules/es6-iterator/test/valid-iterable.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var iteratorSymbol = require("es6-symbol").iterator
+  , Iterator       = require("../");
+
+module.exports = function (t, a) {
+	var obj;
+	a.throws(function () {
+ t();
+}, TypeError, "Undefined");
+	a.throws(function () {
+ t({});
+}, TypeError, "Plain object");
+	a.throws(function () {
+ t({ length: 0 });
+}, TypeError, "Array-like");
+	obj = {};
+	obj[iteratorSymbol] = function () {
+ return new Iterator([]);
+};
+	a(t(obj), obj, "Iterator");
+	obj = [];
+	a(t(obj), obj, "Array");
+	obj = (function () {
+ return arguments;
+}());
+	a(t(obj), obj, "Arguments");
+};

Client/node_modules/es6-iterator/valid-iterable.js

@@ -0,0 +1,8 @@
+"use strict";
+
+var isIterable = require("./is-iterable");
+
+module.exports = function (value) {
+	if (!isIterable(value)) throw new TypeError(value + " is not iterable");
+	return value;
+};