updated bunch of file paths and changed the way posts are loaded

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

node_modules/es6-iterator/.lint

@@ -0,0 +1,11 @@
+@root
+
+module
+
+tabs
+indent 2
+maxlen 100
+
+ass
+nomen
+plusplus

node_modules/es6-iterator/.npmignore

@@ -0,0 +1,4 @@
+.DS_Store
+/node_modules
+/npm-debug.log
+/.lintcache

node_modules/es6-iterator/.travis.yml

@@ -0,0 +1,11 @@
+sudo: false # http://docs.travis-ci.com/user/workers/container-based-infrastructure/
+language: node_js
+node_js:
+  - 0.12
+  - 4
+
+notifications:
+  email:
+    - medikoo+es6-iterator@medikoo.com
+
+script: "npm test && npm run lint"

node_modules/es6-iterator/CHANGES

@@ -0,0 +1,35 @@
+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)

node_modules/es6-iterator/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2013-2015 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.

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

node_modules/es6-iterator/array.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var setPrototypeOf = require('es5-ext/object/set-prototype-of')
+  , contains       = require('es5-ext/string/#/contains')
+  , d              = require('d')
+  , Iterator       = require('./')
+
+  , defineProperty = Object.defineProperty
+  , ArrayIterator;
+
+ArrayIterator = module.exports = function (arr, kind) {
+	if (!(this instanceof ArrayIterator)) return new ArrayIterator(arr, kind);
+	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);
+
+ArrayIterator.prototype = Object.create(Iterator.prototype, {
+	constructor: d(ArrayIterator),
+	_resolve: d(function (i) {
+		if (this.__kind__ === 'value') return this.__list__[i];
+		if (this.__kind__ === 'key+value') return [i, this.__list__[i]];
+		return i;
+	}),
+	toString: d(function () { return '[object Array Iterator]'; })
+});

node_modules/es6-iterator/for-of.js

@@ -0,0 +1,46 @@
+'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')
+
+  , 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, l, 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);
+			if (broken) return true;
+		});
+		return;
+	}
+	if (mode === 'string') {
+		l = iterable.length;
+		for (i = 0; i < l; ++i) {
+			char = iterable[i];
+			if ((i + 1) < l) {
+				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();
+	}
+};

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

node_modules/es6-iterator/index.js

@@ -0,0 +1,90 @@
+'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')
+
+  , defineProperty = Object.defineProperty
+  , defineProperties = Object.defineProperties
+  , Iterator;
+
+module.exports = Iterator = function (list, context) {
+	if (!(this instanceof Iterator)) return new Iterator(list, context);
+	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);
+};
+
+defineProperties(Iterator.prototype, assign({
+	constructor: d(Iterator),
+	_next: d(function () {
+		var i;
+		if (!this.__list__) return;
+		if (this.__redo__) {
+			i = this.__redo__.shift();
+			if (i !== undefined) return i;
+		}
+		if (this.__nextIndex__ < this.__list__.length) return this.__nextIndex__++;
+		this._unBind();
+	}),
+	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 Iterator]'; })
+}, 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, i) {
+			if (redo > index) this.__redo__[i] = --redo;
+		}, this);
+	}),
+	_onClear: d(function () {
+		if (this.__redo__) clear.call(this.__redo__);
+		this.__nextIndex__ = 0;
+	})
+})));
+
+defineProperty(Iterator.prototype, Symbol.iterator, d(function () {
+	return this;
+}));
+defineProperty(Iterator.prototype, Symbol.toStringTag, d('', 'Iterator'));

node_modules/es6-iterator/is-iterable.js

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

node_modules/es6-iterator/package.json

@@ -0,0 +1,92 @@
+{
+  "_args": [
+    [
+      "es6-iterator@2",
+      "/home/mitchell/Desktop/test-mywebsite/mywebsite/node_modules/cli-color"
+    ]
+  ],
+  "_from": "es6-iterator@>=2.0.0 <3.0.0",
+  "_id": "es6-iterator@2.0.0",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/es6-iterator",
+  "_nodeVersion": "0.12.7",
+  "_npmUser": {
+    "email": "medikoo+npm@medikoo.com",
+    "name": "medikoo"
+  },
+  "_npmVersion": "2.11.3",
+  "_phantomChildren": {},
+  "_requested": {
+    "name": "es6-iterator",
+    "raw": "es6-iterator@2",
+    "rawSpec": "2",
+    "scope": null,
+    "spec": ">=2.0.0 <3.0.0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/cli-color",
+    "/es5-ext"
+  ],
+  "_resolved": "https://registry.npmjs.org/es6-iterator/-/es6-iterator-2.0.0.tgz",
+  "_shasum": "bd968567d61635e33c0b80727613c9cb4b096bac",
+  "_shrinkwrap": null,
+  "_spec": "es6-iterator@2",
+  "_where": "/home/mitchell/Desktop/test-mywebsite/mywebsite/node_modules/cli-color",
+  "author": {
+    "email": "medyk@medikoo.com",
+    "name": "Mariusz Nowak",
+    "url": "http://www.medikoo.com/"
+  },
+  "bugs": {
+    "url": "https://github.com/medikoo/es6-iterator/issues"
+  },
+  "dependencies": {
+    "d": "^0.1.1",
+    "es5-ext": "^0.10.7",
+    "es6-symbol": "3"
+  },
+  "description": "Iterator abstraction based on ES6 specification",
+  "devDependencies": {
+    "event-emitter": "^0.3.4",
+    "tad": "^0.2.3",
+    "xlint": "^0.2.2",
+    "xlint-jslint-medikoo": "^0.1.3"
+  },
+  "directories": {},
+  "dist": {
+    "shasum": "bd968567d61635e33c0b80727613c9cb4b096bac",
+    "tarball": "http://registry.npmjs.org/es6-iterator/-/es6-iterator-2.0.0.tgz"
+  },
+  "gitHead": "4d9445834e87780ab373b14d6791e860899e2d31",
+  "homepage": "https://github.com/medikoo/es6-iterator#readme",
+  "keywords": [
+    "array",
+    "generator",
+    "iterator",
+    "list",
+    "map",
+    "set"
+  ],
+  "license": "MIT",
+  "maintainers": [
+    {
+      "name": "medikoo",
+      "email": "medikoo+npm@medikoo.com"
+    }
+  ],
+  "name": "es6-iterator",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/medikoo/es6-iterator.git"
+  },
+  "scripts": {
+    "lint": "node node_modules/xlint/bin/xlint --linter=node_modules/xlint-jslint-medikoo/index.js --no-cache --no-stream",
+    "lint-console": "node node_modules/xlint/bin/xlint --linter=node_modules/xlint-jslint-medikoo/index.js --watch",
+    "test": "node ./node_modules/tad/bin/tad"
+  },
+  "version": "2.0.0"
+}

node_modules/es6-iterator/string.js

@@ -0,0 +1,37 @@
+// 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')
+  , Iterator       = require('./')
+
+  , defineProperty = Object.defineProperty
+  , StringIterator;
+
+StringIterator = module.exports = function (str) {
+	if (!(this instanceof StringIterator)) return new StringIterator(str);
+	str = String(str);
+	Iterator.call(this, str);
+	defineProperty(this, '__length__', d('', str.length));
+
+};
+if (setPrototypeOf) setPrototypeOf(StringIterator, Iterator);
+
+StringIterator.prototype = Object.create(Iterator.prototype, {
+	constructor: d(StringIterator),
+	_next: d(function () {
+		if (!this.__list__) return;
+		if (this.__nextIndex__ < this.__length__) return this.__nextIndex__++;
+		this._unBind();
+	}),
+	_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;
+	}),
+	toString: d(function () { return '[object String Iterator]'; })
+});

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

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

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

@@ -0,0 +1,40 @@
+'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");
+};

node_modules/es6-iterator/test/get.js

@@ -0,0 +1,17 @@
+'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");
+};

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

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

@@ -0,0 +1,19 @@
+'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");
+};

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

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

@@ -0,0 +1,18 @@
+'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");
+};

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