0.2.0 - Mid migration

web/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);
+};

web/node_modules/es6-iterator/.editorconfig

@@ -0,0 +1,14 @@
+# EditorConfig is awesome: http://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_style = tab
+
+[{*.json,*.yml}]
+indent_style = space
+indent_size = 2

web/node_modules/es6-iterator/.npmignore

@@ -0,0 +1,12 @@
+.DS_Store
+Thumbs.db
+/.idea
+/.vscode
+npm-debug.log
+/wallaby.js
+/node_modules
+/.travis.yml
+/.gitignore
+/.circle.yml
+/.circleci
+/.appveyor.yml

web/node_modules/es6-iterator/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Change Log
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+<a name="2.0.3"></a>
+## [2.0.3](https://github.com/medikoo/es6-iterator/compare/v2.0.2...v2.0.3) (2017-10-17)
+
+
+### Bug Fixes
+
+* configurability of toStringTag ([b99f692](https://github.com/medikoo/es6-iterator/commit/b99f692))
+
+
+
+<a name="2.0.2"></a>
+## [2.0.2](https://github.com/medikoo/es6-iterator/compare/v2.0.1...v2.0.2) (2017-10-17)
+
+
+### Bug Fixes
+
+* constructor exposure ([dbc0c51](https://github.com/medikoo/es6-iterator/commit/dbc0c51))
+* do not allow non constructor calls ([1f2f800](https://github.com/medikoo/es6-iterator/commit/1f2f800))
+* toString and toStringTag symbol definitions. ([2d17786](https://github.com/medikoo/es6-iterator/commit/2d17786)), closes [#6](https://github.com/medikoo/es6-iterator/issues/6)
+
+## Changelog for previous versions
+
+See `CHANGES` file

web/node_modules/es6-iterator/CHANGES

@@ -0,0 +1,42 @@
+For recent changelog see CHANGELOG.md
+
+-----
+
+v2.0.1  --  2017.03.15
+* Update dependencies
+
+v2.0.0  --  2015.10.02
+* Use es6-symbol at v3
+
+v1.0.0  --  2015.06.23
+* Implement support for arguments object
+* Drop support for v0.8 node ('^' in package.json dependencies)
+
+v0.1.3  --  2015.02.02
+* Update dependencies
+* Fix spelling of LICENSE
+
+v0.1.2  --  2014.11.19
+* Optimise internal `_next` to not verify internal's list length at all times
+  (#2 thanks @RReverser)
+* Fix documentation examples
+* Configure lint scripts
+
+v0.1.1  --  2014.04.29
+* Fix es6-symbol dependency version
+
+v0.1.0  --  2014.04.29
+* Assure strictly npm hosted dependencies
+* Remove sparse arrays dedicated handling (as per spec)
+* Add: isIterable, validIterable and chain (method)
+* Remove toArray, it's addressed by Array.from (polyfil can be found in es5-ext/array/from)
+* Add break possiblity to 'forOf' via 'doBreak' function argument
+* Provide dedicated iterator for array-likes (ArrayIterator) and for strings (StringIterator)
+* Provide @@toStringTag symbol
+* When available rely on @@iterator symbol
+* Remove 32bit integer maximum list length restriction
+* Improve Iterator internals
+* Update to use latest version of dependencies
+
+v0.0.0  --  2013.10.12
+Initial (dev version)

web/node_modules/es6-iterator/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (C) 2013-2017 Mariusz Nowak (www.medikoo.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

web/node_modules/es6-iterator/README.md

@@ -0,0 +1,148 @@
+# es6-iterator
+## ECMAScript 6 Iterator interface
+
+### Installation
+
+	$ npm install es6-iterator
+	
+To port it to Browser or any other (non CJS) environment, use your favorite CJS bundler. No favorite yet? Try: [Browserify](http://browserify.org/), [Webmake](https://github.com/medikoo/modules-webmake) or [Webpack](http://webpack.github.io/)
+
+## API
+
+### Constructors
+
+#### Iterator(list) _(es6-iterator)_
+
+Abstract Iterator interface. Meant for extensions and not to be used on its own.
+
+Accepts any _list_ object (technically object with numeric _length_ property).
+
+_Mind it doesn't iterate strings properly, for that use dedicated [StringIterator](#string-iterator)_
+
+```javascript
+var Iterator = require('es6-iterator')
+var iterator = new Iterator([1, 2, 3]);
+
+iterator.next(); // { value: 1, done: false }
+iterator.next(); // { value: 2, done: false }
+iterator.next(); // { value: 3, done: false }
+iterator.next(); // { value: undefined, done: true }
+```
+
+
+#### ArrayIterator(arrayLike[, kind]) _(es6-iterator/array)_
+
+Dedicated for arrays and array-likes. Supports three iteration kinds:
+* __value__ _(default)_ - Iterates values
+* __key__ - Iterates indexes
+* __key+value__ - Iterates keys and indexes, each iteration value is in _[key, value]_ form.
+
+
+```javascript
+var ArrayIterator = require('es6-iterator/array')
+var iterator = new ArrayIterator([1, 2, 3], 'key+value');
+
+iterator.next(); // { value: [0, 1], done: false }
+iterator.next(); // { value: [1, 2], done: false }
+iterator.next(); // { value: [2, 3], done: false }
+iterator.next(); // { value: undefined, done: true }
+```
+
+May also be used for _arguments_ objects:
+
+```javascript
+(function () {
+  var iterator = new ArrayIterator(arguments);
+
+  iterator.next(); // { value: 1, done: false }
+  iterator.next(); // { value: 2, done: false }
+  iterator.next(); // { value: 3, done: false }
+  iterator.next(); // { value: undefined, done: true }
+}(1, 2, 3));
+```
+
+#### StringIterator(str) _(es6-iterator/string)_
+
+Assures proper iteration over unicode symbols.  
+See: http://mathiasbynens.be/notes/javascript-unicode
+
+```javascript
+var StringIterator = require('es6-iterator/string');
+var iterator = new StringIterator('f🙈o🙉o🙊');
+
+iterator.next(); // { value: 'f', done: false }
+iterator.next(); // { value: '🙈', done: false }
+iterator.next(); // { value: 'o', done: false }
+iterator.next(); // { value: '🙉', done: false }
+iterator.next(); // { value: 'o', done: false }
+iterator.next(); // { value: '🙊', done: false }
+iterator.next(); // { value: undefined, done: true }
+```
+
+### Function utilities
+
+#### forOf(iterable, callback[, thisArg]) _(es6-iterator/for-of)_
+
+Polyfill for ECMAScript 6 [`for...of`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of) statement.
+
+```
+var forOf = require('es6-iterator/for-of');
+var result = [];
+
+forOf('🙈🙉🙊', function (monkey) { result.push(monkey); });
+console.log(result); // ['🙈', '🙉', '🙊'];
+```
+
+Optionally you can break iteration at any point:
+
+```javascript
+var result = [];
+
+forOf([1,2,3,4]', function (val, doBreak) {
+  result.push(monkey);
+  if (val >= 3) doBreak();
+});
+console.log(result); // [1, 2, 3];
+```
+
+#### get(obj) _(es6-iterator/get)_
+
+Return iterator for any iterable object.
+
+```javascript
+var getIterator = require('es6-iterator/get');
+var iterator = get([1,2,3]);
+
+iterator.next(); // { value: 1, done: false }
+iterator.next(); // { value: 2, done: false }
+iterator.next(); // { value: 3, done: false }
+iterator.next(); // { value: undefined, done: true }
+```
+
+#### isIterable(obj) _(es6-iterator/is-iterable)_
+
+Whether _obj_ is iterable
+
+```javascript
+var isIterable = require('es6-iterator/is-iterable');
+
+isIterable(null); // false
+isIterable(true); // false
+isIterable('str'); // true
+isIterable(['a', 'r', 'r']); // true
+isIterable(new ArrayIterator([])); // true
+```
+
+#### validIterable(obj) _(es6-iterator/valid-iterable)_
+
+If _obj_ is an iterable it is returned. Otherwise _TypeError_ is thrown.
+
+### Method extensions
+
+#### iterator.chain(iterator1[, …iteratorn]) _(es6-iterator/#/chain)_
+
+Chain multiple iterators into one.
+
+### Tests [![Build Status](https://travis-ci.org/medikoo/es6-iterator.png)](https://travis-ci.org/medikoo/es6-iterator)
+
+	$ npm test

web/node_modules/es6-iterator/appveyor.yml

@@ -0,0 +1,26 @@
+# Test against the latest version of this Node.js version
+environment:
+  matrix:
+    # node.js
+    - nodejs_version: "0.12"
+    - nodejs_version: "4"
+    - nodejs_version: "6"
+    - nodejs_version: "8"
+
+# Install scripts. (runs after repo cloning)
+install:
+  # Get the latest stable version of Node.js or io.js
+  - ps: Install-Product node $env:nodejs_version
+  # install modules
+  - npm install
+
+# Post-install test scripts.
+test_script:
+  # Output useful info for debugging.
+  - node --version
+  - npm --version
+  # run tests
+  - npm test
+
+# Don't actually build.
+build: off

web/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"));

web/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();
+	}
+};

web/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);
+};

web/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;
+	})
+);

web/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";
+};

web/node_modules/es6-iterator/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "es6-iterator",
+  "version": "2.0.3",
+  "description": "Iterator abstraction based on ES6 specification",
+  "author": "Mariusz Nowak <medyk@medikoo.com> (http://www.medikoo.com/)",
+  "keywords": [
+    "iterator",
+    "array",
+    "list",
+    "set",
+    "map",
+    "generator"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/medikoo/es6-iterator.git"
+  },
+  "dependencies": {
+    "d": "1",
+    "es5-ext": "^0.10.35",
+    "es6-symbol": "^3.1.1"
+  },
+  "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"
+    }
+  },
+  "scripts": {
+    "lint": "eslint --ignore-path=.gitignore .",
+    "test": "node ./node_modules/tad/bin/tad"
+  },
+  "license": "MIT"
+}

web/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"));

web/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");
+};

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

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

web/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");
+		}
+	};
+};

web/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");
+};

web/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");
+};

web/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");
+		}
+	};
+};

web/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");
+};

web/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");
+};

web/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");
+};

web/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;
+};