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

node_modules/es5-ext/array/#/@@iterator/implement.js

@@ -0,0 +1,6 @@
+'use strict';
+
+if (!require('./is-implemented')()) {
+	Object.defineProperty(Array.prototype, require('es6-symbol').iterator, { value: require('./shim'),
+		configurable: true, enumerable: false, writable: true });
+}

node_modules/es5-ext/array/#/@@iterator/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+module.exports = require('./is-implemented')()
+	? Array.prototype[require('es6-symbol').iterator] : require('./shim');

node_modules/es5-ext/array/#/@@iterator/is-implemented.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var iteratorSymbol = require('es6-symbol').iterator;
+
+module.exports = function () {
+	var arr = ['foo', 1], iterator, result;
+	if (typeof arr[iteratorSymbol] !== 'function') return false;
+	iterator = arr[iteratorSymbol]();
+	if (!iterator) return false;
+	if (typeof iterator.next !== 'function') return false;
+	result = iterator.next();
+	if (!result) return false;
+	if (result.value !== 'foo') return false;
+	if (result.done !== false) return false;
+	return true;
+};

node_modules/es5-ext/array/#/@@iterator/shim.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('../values/shim');

node_modules/es5-ext/array/#/_compare-by-length.js

@@ -0,0 +1,9 @@
+// Used internally to sort array of lists by length
+
+'use strict';
+
+var toPosInt = require('../../number/to-pos-integer');
+
+module.exports = function (a, b) {
+	return toPosInt(a.length) - toPosInt(b.length);
+};

node_modules/es5-ext/array/#/binary-search.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var toPosInt = require('../../number/to-pos-integer')
+  , callable = require('../../object/valid-callable')
+  , value    = require('../../object/valid-value')
+
+  , floor    = Math.floor;
+
+module.exports = function (compareFn) {
+	var length, low, high, middle;
+
+	value(this);
+	callable(compareFn);
+
+	length = toPosInt(this.length);
+	low = 0;
+	high = length - 1;
+
+	while (low <= high) {
+		middle = floor((low + high) / 2);
+		if (compareFn(this[middle]) < 0) high = middle - 1;
+		else low = middle + 1;
+	}
+
+	if (high < 0) return 0;
+	if (high >= length) return length - 1;
+	return high;
+};

node_modules/es5-ext/array/#/clear.js

@@ -0,0 +1,12 @@
+// Inspired by Google Closure:
+// http://closure-library.googlecode.com/svn/docs/
+// closure_goog_array_array.js.html#goog.array.clear
+
+'use strict';
+
+var value = require('../../object/valid-value');
+
+module.exports = function () {
+	value(this).length = 0;
+	return this;
+};

node_modules/es5-ext/array/#/compact.js

@@ -0,0 +1,9 @@
+// Inspired by: http://documentcloud.github.com/underscore/#compact
+
+'use strict';
+
+var filter = Array.prototype.filter;
+
+module.exports = function () {
+	return filter.call(this, function (val) { return val != null; });
+};

node_modules/es5-ext/array/#/concat/implement.js

@@ -0,0 +1,6 @@
+'use strict';
+
+if (!require('./is-implemented')()) {
+	Object.defineProperty(Array.prototype, 'concat', { value: require('./shim'),
+		configurable: true, enumerable: false, writable: true });
+}

node_modules/es5-ext/array/#/concat/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+module.exports = require('./is-implemented')() ?
+		Array.prototype.concat : require('./shim');

node_modules/es5-ext/array/#/concat/is-implemented.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var SubArray = require('../../_sub-array-dummy-safe');
+
+module.exports = function () {
+	return (new SubArray()).concat('foo') instanceof SubArray;
+};

node_modules/es5-ext/array/#/concat/shim.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var isPlainArray = require('../../is-plain-array')
+  , toPosInt     = require('../../../number/to-pos-integer')
+  , isObject     = require('../../../object/is-object')
+
+  , isArray = Array.isArray, concat = Array.prototype.concat
+  , forEach = Array.prototype.forEach
+
+  , isSpreadable;
+
+isSpreadable = function (value) {
+	if (!value) return false;
+	if (!isObject(value)) return false;
+	if (value['@@isConcatSpreadable'] !== undefined) {
+		return Boolean(value['@@isConcatSpreadable']);
+	}
+	return isArray(value);
+};
+
+module.exports = function (item/*, …items*/) {
+	var result;
+	if (!this || !isArray(this) || isPlainArray(this)) {
+		return concat.apply(this, arguments);
+	}
+	result = new this.constructor(this.length);
+	forEach.call(this, function (val, i) { result[i] = val; });
+	forEach.call(arguments, function (arg) {
+		var base;
+		if (isSpreadable(arg)) {
+			base = result.length;
+			result.length += toPosInt(arg.length);
+			forEach.call(arg, function (val, i) { result[base + i] = val; });
+			return;
+		}
+		result.push(arg);
+	});
+	return result;
+};

node_modules/es5-ext/array/#/contains.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var indexOf = require('./e-index-of');
+
+module.exports = function (searchElement/*, position*/) {
+	return indexOf.call(this, searchElement, arguments[1]) > -1;
+};

node_modules/es5-ext/array/#/copy-within/implement.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (!require('./is-implemented')()) {
+	Object.defineProperty(Array.prototype, 'copyWithin',
+		{ value: require('./shim'), configurable: true, enumerable: false,
+			writable: true });
+}

node_modules/es5-ext/array/#/copy-within/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+module.exports = require('./is-implemented')() ?
+		Array.prototype.copyWithin : require('./shim');

node_modules/es5-ext/array/#/copy-within/is-implemented.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = function () {
+	var arr = [1, 2, 3, 4, 5];
+	if (typeof arr.copyWithin !== 'function') return false;
+	return String(arr.copyWithin(1, 3)) === '1,4,5,4,5';
+};

node_modules/es5-ext/array/#/copy-within/shim.js

@@ -0,0 +1,39 @@
+// Taken from: https://github.com/paulmillr/es6-shim/
+
+'use strict';
+
+var toInteger  = require('../../../number/to-integer')
+  , toPosInt   = require('../../../number/to-pos-integer')
+  , validValue = require('../../../object/valid-value')
+
+  , hasOwnProperty = Object.prototype.hasOwnProperty
+  , max = Math.max, min = Math.min;
+
+module.exports = function (target, start/*, end*/) {
+	var o = validValue(this), end = arguments[2], l = toPosInt(o.length)
+	  , to, from, fin, count, direction;
+
+	target = toInteger(target);
+	start = toInteger(start);
+	end = (end === undefined) ? l : toInteger(end);
+
+	to = target < 0 ? max(l + target, 0) : min(target, l);
+	from = start < 0 ? max(l + start, 0) : min(start, l);
+	fin = end < 0 ? max(l + end, 0) : min(end, l);
+	count = min(fin - from, l - to);
+	direction = 1;
+
+	if ((from < to) && (to < (from + count))) {
+		direction = -1;
+		from += count - 1;
+		to += count - 1;
+	}
+	while (count > 0) {
+		if (hasOwnProperty.call(o, from)) o[to] = o[from];
+		else delete o[from];
+		from += direction;
+		to += direction;
+		count -= 1;
+	}
+	return o;
+};

node_modules/es5-ext/array/#/diff.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var value    = require('../../object/valid-value')
+  , contains = require('./contains')
+
+  , filter = Array.prototype.filter;
+
+module.exports = function (other) {
+	(value(this) && value(other));
+	return filter.call(this, function (item) {
+		return !contains.call(other, item);
+	});
+};

node_modules/es5-ext/array/#/e-index-of.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var toPosInt = require('../../number/to-pos-integer')
+  , value    = require('../../object/valid-value')
+
+  , indexOf = Array.prototype.indexOf
+  , hasOwnProperty = Object.prototype.hasOwnProperty
+  , abs = Math.abs, floor = Math.floor;
+
+module.exports = function (searchElement/*, fromIndex*/) {
+	var i, l, fromIndex, val;
+	if (searchElement === searchElement) { //jslint: ignore
+		return indexOf.apply(this, arguments);
+	}
+
+	l = toPosInt(value(this).length);
+	fromIndex = arguments[1];
+	if (isNaN(fromIndex)) fromIndex = 0;
+	else if (fromIndex >= 0) fromIndex = floor(fromIndex);
+	else fromIndex = toPosInt(this.length) - floor(abs(fromIndex));
+
+	for (i = fromIndex; i < l; ++i) {
+		if (hasOwnProperty.call(this, i)) {
+			val = this[i];
+			if (val !== val) return i; //jslint: ignore
+		}
+	}
+	return -1;
+};

node_modules/es5-ext/array/#/e-last-index-of.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var toPosInt = require('../../number/to-pos-integer')
+  , value    = require('../../object/valid-value')
+
+  , lastIndexOf = Array.prototype.lastIndexOf
+  , hasOwnProperty = Object.prototype.hasOwnProperty
+  , abs = Math.abs, floor = Math.floor;
+
+module.exports = function (searchElement/*, fromIndex*/) {
+	var i, fromIndex, val;
+	if (searchElement === searchElement) { //jslint: ignore
+		return lastIndexOf.apply(this, arguments);
+	}
+
+	value(this);
+	fromIndex = arguments[1];
+	if (isNaN(fromIndex)) fromIndex = (toPosInt(this.length) - 1);
+	else if (fromIndex >= 0) fromIndex = floor(fromIndex);
+	else fromIndex = toPosInt(this.length) - floor(abs(fromIndex));
+
+	for (i = fromIndex; i >= 0; --i) {
+		if (hasOwnProperty.call(this, i)) {
+			val = this[i];
+			if (val !== val) return i; //jslint: ignore
+		}
+	}
+	return -1;
+};

node_modules/es5-ext/array/#/entries/implement.js

@@ -0,0 +1,6 @@
+'use strict';
+
+if (!require('./is-implemented')()) {
+	Object.defineProperty(Array.prototype, 'entries', { value: require('./shim'),
+		configurable: true, enumerable: false, writable: true });
+}

node_modules/es5-ext/array/#/entries/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+module.exports = require('./is-implemented')() ?
+		Array.prototype.entries : require('./shim');

node_modules/es5-ext/array/#/entries/is-implemented.js

@@ -0,0 +1,15 @@
+'use strict';
+
+module.exports = function () {
+	var arr = [1, 'foo'], iterator, result;
+	if (typeof arr.entries !== 'function') return false;
+	iterator = arr.entries();
+	if (!iterator) return false;
+	if (typeof iterator.next !== 'function') return false;
+	result = iterator.next();
+	if (!result || !result.value) return false;
+	if (result.value[0] !== 0) return false;
+	if (result.value[1] !== 1) return false;
+	if (result.done !== false) return false;
+	return true;
+};

node_modules/es5-ext/array/#/entries/shim.js

@@ -0,0 +1,4 @@
+'use strict';
+
+var ArrayIterator = require('es6-iterator/array');
+module.exports = function () { return new ArrayIterator(this, 'key+value'); };

node_modules/es5-ext/array/#/exclusion.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var value    = require('../../object/valid-value')
+  , aFrom    = require('../from')
+  , toArray  = require('../to-array')
+  , contains = require('./contains')
+  , byLength = require('./_compare-by-length')
+
+  , filter = Array.prototype.filter, push = Array.prototype.push;
+
+module.exports = function (/*…lists*/) {
+	var lists, seen, result;
+	if (!arguments.length) return aFrom(this);
+	push.apply(lists = [this], arguments);
+	lists.forEach(value);
+	seen = [];
+	result = [];
+	lists.sort(byLength).forEach(function (list) {
+		result = result.filter(function (item) {
+			return !contains.call(list, item);
+		}).concat(filter.call(list, function (x) {
+			return !contains.call(seen, x);
+		}));
+		push.apply(seen, toArray(list));
+	});
+	return result;
+};

node_modules/es5-ext/array/#/fill/implement.js

@@ -0,0 +1,6 @@
+'use strict';
+
+if (!require('./is-implemented')()) {
+	Object.defineProperty(Array.prototype, 'fill', { value: require('./shim'),
+		configurable: true, enumerable: false, writable: true });
+}

node_modules/es5-ext/array/#/fill/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+module.exports = require('./is-implemented')() ?
+		Array.prototype.fill : require('./shim');

node_modules/es5-ext/array/#/fill/is-implemented.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = function () {
+	var arr = [1, 2, 3, 4, 5, 6];
+	if (typeof arr.fill !== 'function') return false;
+	return String(arr.fill(-1, -3)) === '1,2,3,-1,-1,-1';
+};

node_modules/es5-ext/array/#/fill/shim.js

@@ -0,0 +1,21 @@
+// Taken from: https://github.com/paulmillr/es6-shim/
+
+'use strict';
+
+var toInteger  = require('../../../number/to-integer')
+  , toPosInt   = require('../../../number/to-pos-integer')
+  , validValue = require('../../../object/valid-value')
+
+  , max = Math.max, min = Math.min;
+
+module.exports = function (value/*, start, end*/) {
+	var o = validValue(this), start = arguments[1], end = arguments[2]
+	  , l = toPosInt(o.length), relativeStart, i;
+
+	start = (start === undefined) ? 0 : toInteger(start);
+	end = (end === undefined) ? l : toInteger(end);
+
+	relativeStart = start < 0 ? max(l + start, 0) : min(start, l);
+	for (i = relativeStart; i < l && i < end; ++i) o[i] = value;
+	return o;
+};

node_modules/es5-ext/array/#/filter/implement.js

@@ -0,0 +1,6 @@
+'use strict';
+
+if (!require('./is-implemented')()) {
+	Object.defineProperty(Array.prototype, 'filter', { value: require('./shim'),
+		configurable: true, enumerable: false, writable: true });
+}

node_modules/es5-ext/array/#/filter/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+module.exports = require('./is-implemented')() ?
+		Array.prototype.filter : require('./shim');

node_modules/es5-ext/array/#/filter/is-implemented.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var SubArray = require('../../_sub-array-dummy-safe')
+
+  , pass = function () { return true; };
+
+module.exports = function () {
+	return (new SubArray()).filter(pass) instanceof SubArray;
+};

node_modules/es5-ext/array/#/filter/shim.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var isPlainArray = require('../../is-plain-array')
+  , callable     = require('../../../object/valid-callable')
+
+  , isArray = Array.isArray, filter = Array.prototype.filter
+  , forEach = Array.prototype.forEach, call = Function.prototype.call;
+
+module.exports = function (callbackFn/*, thisArg*/) {
+	var result, thisArg, i;
+	if (!this || !isArray(this) || isPlainArray(this)) {
+		return filter.apply(this, arguments);
+	}
+	callable(callbackFn);
+	thisArg = arguments[1];
+	result = new this.constructor();
+	i = 0;
+	forEach.call(this, function (val, j, self) {
+		if (call.call(callbackFn, thisArg, val, j, self)) result[i++] = val;
+	});
+	return result;
+};

node_modules/es5-ext/array/#/find-index/implement.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (!require('./is-implemented')()) {
+	Object.defineProperty(Array.prototype, 'findIndex',
+		{ value: require('./shim'),
+			configurable: true, enumerable: false, writable: true });
+}

node_modules/es5-ext/array/#/find-index/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+module.exports = require('./is-implemented')() ?
+		Array.prototype.findIndex : require('./shim');

node_modules/es5-ext/array/#/find-index/is-implemented.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var fn = function (x) { return x > 3; };
+
+module.exports = function () {
+	var arr = [1, 2, 3, 4, 5, 6];
+	if (typeof arr.findIndex !== 'function') return false;
+	return arr.findIndex(fn) === 3;
+};

node_modules/es5-ext/array/#/find-index/shim.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var callable = require('../../../object/valid-callable')
+  , value    = require('../../../object/valid-value')
+
+  , some = Array.prototype.some, apply = Function.prototype.apply;
+
+module.exports = function (predicate/*, thisArg*/) {
+	var k, self;
+	self = Object(value(this));
+	callable(predicate);
+
+	return some.call(self, function (value, index) {
+		if (apply.call(predicate, this, arguments)) {
+			k = index;
+			return true;
+		}
+		return false;
+	}, arguments[1]) ? k : -1;
+};

node_modules/es5-ext/array/#/find/implement.js

@@ -0,0 +1,6 @@
+'use strict';
+
+if (!require('./is-implemented')()) {
+	Object.defineProperty(Array.prototype, 'find', { value: require('./shim'),
+		configurable: true, enumerable: false, writable: true });
+}

node_modules/es5-ext/array/#/find/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+module.exports = require('./is-implemented')() ?
+		Array.prototype.find : require('./shim');

node_modules/es5-ext/array/#/find/is-implemented.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var fn = function (x) { return x > 3; };
+
+module.exports = function () {
+	var arr = [1, 2, 3, 4, 5, 6];
+	if (typeof arr.find !== 'function') return false;
+	return arr.find(fn) === 4;
+};

node_modules/es5-ext/array/#/find/shim.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var findIndex = require('../find-index/shim');
+
+module.exports = function (predicate/*, thisArg*/) {
+	var index = findIndex.apply(this, arguments);
+	return (index === -1) ? undefined : this[index];
+};

node_modules/es5-ext/array/#/first-index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var toPosInt = require('../../number/to-pos-integer')
+  , value    = require('../../object/valid-value')
+
+  , hasOwnProperty = Object.prototype.hasOwnProperty;
+
+module.exports = function () {
+	var i, l;
+	if (!(l = toPosInt(value(this).length))) return null;
+	i = 0;
+	while (!hasOwnProperty.call(this, i)) {
+		if (++i === l) return null;
+	}
+	return i;
+};

node_modules/es5-ext/array/#/first.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var firstIndex = require('./first-index');
+
+module.exports = function () {
+	var i;
+	if ((i = firstIndex.call(this)) !== null) return this[i];
+	return undefined;
+};

node_modules/es5-ext/array/#/flatten.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var isArray = Array.isArray, forEach = Array.prototype.forEach
+  , push = Array.prototype.push;
+
+module.exports = function flatten() {
+	var r = [];
+	forEach.call(this, function (x) {
+		push.apply(r, isArray(x) ? flatten.call(x) : [x]);
+	});
+	return r;
+};

node_modules/es5-ext/array/#/for-each-right.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var toPosInt = require('../../number/to-pos-integer')
+  , callable = require('../../object/valid-callable')
+  , value    = require('../../object/valid-value')
+
+  , hasOwnProperty = Object.prototype.hasOwnProperty
+  , call = Function.prototype.call;
+
+module.exports = function (cb/*, thisArg*/) {
+	var i, self, thisArg;
+
+	self = Object(value(this));
+	callable(cb);
+	thisArg = arguments[1];
+
+	for (i = (toPosInt(self.length) - 1); i >= 0; --i) {
+		if (hasOwnProperty.call(self, i)) call.call(cb, thisArg, self[i], i, self);
+	}
+};

node_modules/es5-ext/array/#/group.js

@@ -0,0 +1,23 @@
+// Inspired by Underscore's groupBy:
+// http://documentcloud.github.com/underscore/#groupBy
+
+'use strict';
+
+var callable = require('../../object/valid-callable')
+  , value    = require('../../object/valid-value')
+
+  , forEach = Array.prototype.forEach, apply = Function.prototype.apply;
+
+module.exports = function (cb/*, thisArg*/) {
+	var r;
+
+	(value(this) && callable(cb));
+
+	r = {};
+	forEach.call(this, function (v) {
+		var key = apply.call(cb, this, arguments);
+		if (!r.hasOwnProperty(key)) r[key] = [];
+		r[key].push(v);
+	}, arguments[1]);
+	return r;
+};

node_modules/es5-ext/array/#/index.js

@@ -0,0 +1,40 @@
+'use strict';
+
+module.exports = {
+	'@@iterator':   require('./@@iterator'),
+	binarySearch:   require('./binary-search'),
+	clear:          require('./clear'),
+	compact:        require('./compact'),
+	concat:         require('./concat'),
+	contains:       require('./contains'),
+	copyWithin:     require('./copy-within'),
+	diff:           require('./diff'),
+	eIndexOf:       require('./e-index-of'),
+	eLastIndexOf:   require('./e-last-index-of'),
+	entries:        require('./entries'),
+	exclusion:      require('./exclusion'),
+	fill:           require('./fill'),
+	filter:         require('./filter'),
+	find:           require('./find'),
+	findIndex:      require('./find-index'),
+	first:          require('./first'),
+	firstIndex:     require('./first-index'),
+	flatten:        require('./flatten'),
+	forEachRight:   require('./for-each-right'),
+	keys:           require('./keys'),
+	group:          require('./group'),
+	indexesOf:      require('./indexes-of'),
+	intersection:   require('./intersection'),
+	isCopy:         require('./is-copy'),
+	isUniq:         require('./is-uniq'),
+	last:           require('./last'),
+	lastIndex:      require('./last-index'),
+	map:            require('./map'),
+	remove:         require('./remove'),
+	separate:       require('./separate'),
+	slice:          require('./slice'),
+	someRight:      require('./some-right'),
+	splice:         require('./splice'),
+	uniq:           require('./uniq'),
+	values:         require('./values')
+};

node_modules/es5-ext/array/#/indexes-of.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var indexOf = require('./e-index-of');
+
+module.exports = function (value/*, fromIndex*/) {
+	var r = [], i, fromIndex = arguments[1];
+	while ((i = indexOf.call(this, value, fromIndex)) !== -1) {
+		r.push(i);
+		fromIndex = i + 1;
+	}
+	return r;
+};

node_modules/es5-ext/array/#/intersection.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var value    = require('../../object/valid-value')
+  , contains = require('./contains')
+  , byLength = require('./_compare-by-length')
+
+  , filter = Array.prototype.filter, push = Array.prototype.push
+  , slice = Array.prototype.slice;
+
+module.exports = function (/*…list*/) {
+	var lists;
+	if (!arguments.length) slice.call(this);
+	push.apply(lists = [this], arguments);
+	lists.forEach(value);
+	lists.sort(byLength);
+	return lists.reduce(function (a, b) {
+		return filter.call(a, function (x) { return contains.call(b, x); });
+	});
+};

node_modules/es5-ext/array/#/is-copy.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var toPosInt = require('../../number/to-pos-integer')
+  , eq    = require('../../object/eq')
+  , value = require('../../object/valid-value')
+
+  , hasOwnProperty = Object.prototype.hasOwnProperty;
+
+module.exports = function (other) {
+	var i, l;
+	(value(this) && value(other));
+	l = toPosInt(this.length);
+	if (l !== toPosInt(other.length)) return false;
+	for (i = 0; i < l; ++i) {
+		if (hasOwnProperty.call(this, i) !== hasOwnProperty.call(other, i)) {
+			return false;
+		}
+		if (!eq(this[i], other[i])) return false;
+	}
+	return true;
+};

node_modules/es5-ext/array/#/is-uniq.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var indexOf = require('./e-index-of')
+
+  , every = Array.prototype.every
+  , isFirst;
+
+isFirst = function (value, index) {
+	return indexOf.call(this, value) === index;
+};
+
+module.exports = function () { return every.call(this, isFirst, this); };

node_modules/es5-ext/array/#/keys/implement.js

@@ -0,0 +1,6 @@
+'use strict';
+
+if (!require('./is-implemented')()) {
+	Object.defineProperty(Array.prototype, 'keys', { value: require('./shim'),
+		configurable: true, enumerable: false, writable: true });
+}

node_modules/es5-ext/array/#/keys/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+module.exports = require('./is-implemented')() ?
+		Array.prototype.keys : require('./shim');

node_modules/es5-ext/array/#/keys/is-implemented.js

@@ -0,0 +1,14 @@
+'use strict';
+
+module.exports = function () {
+	var arr = [1, 'foo'], iterator, result;
+	if (typeof arr.keys !== 'function') return false;
+	iterator = arr.keys();
+	if (!iterator) return false;
+	if (typeof iterator.next !== 'function') return false;
+	result = iterator.next();
+	if (!result) return false;
+	if (result.value !== 0) return false;
+	if (result.done !== false) return false;
+	return true;
+};

node_modules/es5-ext/array/#/keys/shim.js

@@ -0,0 +1,4 @@
+'use strict';
+
+var ArrayIterator = require('es6-iterator/array');
+module.exports = function () { return new ArrayIterator(this, 'key'); };

node_modules/es5-ext/array/#/last-index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var toPosInt = require('../../number/to-pos-integer')
+  , value    = require('../../object/valid-value')
+
+  , hasOwnProperty = Object.prototype.hasOwnProperty;
+
+module.exports = function () {
+	var i, l;
+	if (!(l = toPosInt(value(this).length))) return null;
+	i = l - 1;
+	while (!hasOwnProperty.call(this, i)) {
+		if (--i === -1) return null;
+	}
+	return i;
+};

node_modules/es5-ext/array/#/last.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var lastIndex = require('./last-index');
+
+module.exports = function () {
+	var i;
+	if ((i = lastIndex.call(this)) !== null) return this[i];
+	return undefined;
+};

node_modules/es5-ext/array/#/map/implement.js

@@ -0,0 +1,6 @@
+'use strict';
+
+if (!require('./is-implemented')()) {
+	Object.defineProperty(Array.prototype, 'map', { value: require('./shim'),
+		configurable: true, enumerable: false, writable: true });
+}

node_modules/es5-ext/array/#/map/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+module.exports = require('./is-implemented')() ?
+		Array.prototype.map : require('./shim');

node_modules/es5-ext/array/#/map/is-implemented.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var identity = require('../../../function/identity')
+  , SubArray = require('../../_sub-array-dummy-safe');
+
+module.exports = function () {
+	return (new SubArray()).map(identity) instanceof SubArray;
+};

node_modules/es5-ext/array/#/map/shim.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var isPlainArray = require('../../is-plain-array')
+  , callable     = require('../../../object/valid-callable')
+
+  , isArray = Array.isArray, map = Array.prototype.map
+  , forEach = Array.prototype.forEach, call = Function.prototype.call;
+
+module.exports = function (callbackFn/*, thisArg*/) {
+	var result, thisArg;
+	if (!this || !isArray(this) || isPlainArray(this)) {
+		return map.apply(this, arguments);
+	}
+	callable(callbackFn);
+	thisArg = arguments[1];
+	result = new this.constructor(this.length);
+	forEach.call(this, function (val, i, self) {
+		result[i] = call.call(callbackFn, thisArg, val, i, self);
+	});
+	return result;
+};

node_modules/es5-ext/array/#/remove.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var indexOf = require('./e-index-of')
+
+  , forEach = Array.prototype.forEach, splice = Array.prototype.splice;
+
+module.exports = function (item/*, …item*/) {
+	forEach.call(arguments, function (item) {
+		var index = indexOf.call(this, item);
+		if (index !== -1) splice.call(this, index, 1);
+	}, this);
+};

node_modules/es5-ext/array/#/separate.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var forEach = Array.prototype.forEach;
+
+module.exports = function (sep) {
+	var result = [];
+	forEach.call(this, function (val, i) { result.push(val, sep); });
+	result.pop();
+	return result;
+};

node_modules/es5-ext/array/#/slice/implement.js

@@ -0,0 +1,6 @@
+'use strict';
+
+if (!require('./is-implemented')()) {
+	Object.defineProperty(Array.prototype, 'slice', { value: require('./shim'),
+		configurable: true, enumerable: false, writable: true });
+}

node_modules/es5-ext/array/#/slice/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+module.exports = require('./is-implemented')()
+	? Array.prototype.slice : require('./shim');

node_modules/es5-ext/array/#/slice/is-implemented.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var SubArray = require('../../_sub-array-dummy-safe');
+
+module.exports = function () {
+	return (new SubArray()).slice() instanceof SubArray;
+};

node_modules/es5-ext/array/#/slice/shim.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var toInteger    = require('../../../number/to-integer')
+  , toPosInt     = require('../../../number/to-pos-integer')
+  , isPlainArray = require('../../is-plain-array')
+
+  , isArray = Array.isArray, slice = Array.prototype.slice
+  , hasOwnProperty = Object.prototype.hasOwnProperty, max = Math.max;
+
+module.exports = function (start, end) {
+	var length, result, i;
+	if (!this || !isArray(this) || isPlainArray(this)) {
+		return slice.apply(this, arguments);
+	}
+	length = toPosInt(this.length);
+	start = toInteger(start);
+	if (start < 0) start = max(length + start, 0);
+	else if (start > length) start = length;
+	if (end === undefined) {
+		end = length;
+	} else {
+		end = toInteger(end);
+		if (end < 0) end = max(length + end, 0);
+		else if (end > length) end = length;
+	}
+	if (start > end) start = end;
+	result = new this.constructor(end - start);
+	i = 0;
+	while (start !== end) {
+		if (hasOwnProperty.call(this, start)) result[i] = this[start];
+		++i;
+		++start;
+	}
+	return result;
+};

node_modules/es5-ext/array/#/some-right.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var toPosInt = require('../../number/to-pos-integer')
+  , callable = require('../../object/valid-callable')
+  , value    = require('../../object/valid-value')
+
+  , hasOwnProperty = Object.prototype.hasOwnProperty
+  , call = Function.prototype.call;
+
+module.exports = function (cb/*, thisArg*/) {
+	var i, self, thisArg;
+	self = Object(value(this));
+	callable(cb);
+	thisArg = arguments[1];
+
+	for (i = (toPosInt(self.length) - 1); i >= 0; --i) {
+		if (hasOwnProperty.call(self, i) &&
+				call.call(cb, thisArg, self[i], i, self)) {
+			return true;
+		}
+	}
+	return false;
+};

node_modules/es5-ext/array/#/splice/implement.js

@@ -0,0 +1,6 @@
+'use strict';
+
+if (!require('./is-implemented')()) {
+	Object.defineProperty(Array.prototype, 'splice', { value: require('./shim'),
+		configurable: true, enumerable: false, writable: true });
+}

node_modules/es5-ext/array/#/splice/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+module.exports = require('./is-implemented')()
+	? Array.prototype.splice : require('./shim');

node_modules/es5-ext/array/#/splice/is-implemented.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var SubArray = require('../../_sub-array-dummy-safe');
+
+module.exports = function () {
+	return (new SubArray()).splice(0) instanceof SubArray;
+};

node_modules/es5-ext/array/#/splice/shim.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var isPlainArray = require('../../is-plain-array')
+
+  , isArray = Array.isArray, splice = Array.prototype.splice
+  , forEach = Array.prototype.forEach;
+
+module.exports = function (start, deleteCount/*, …items*/) {
+	var arr = splice.apply(this, arguments), result;
+	if (!this || !isArray(this) || isPlainArray(this)) return arr;
+	result = new this.constructor(arr.length);
+	forEach.call(arr, function (val, i) { result[i] = val; });
+	return result;
+};

node_modules/es5-ext/array/#/uniq.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var indexOf = require('./e-index-of')
+
+  , filter = Array.prototype.filter
+
+  , isFirst;
+
+isFirst = function (value, index) {
+	return indexOf.call(this, value) === index;
+};
+
+module.exports = function () { return filter.call(this, isFirst, this); };

node_modules/es5-ext/array/#/values/implement.js

@@ -0,0 +1,6 @@
+'use strict';
+
+if (!require('./is-implemented')()) {
+	Object.defineProperty(Array.prototype, 'values', { value: require('./shim'),
+		configurable: true, enumerable: false, writable: true });
+}

node_modules/es5-ext/array/#/values/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./is-implemented')() ? Array.prototype.values : require('./shim');

node_modules/es5-ext/array/#/values/is-implemented.js

@@ -0,0 +1,14 @@
+'use strict';
+
+module.exports = function () {
+	var arr = ['foo', 1], iterator, result;
+	if (typeof arr.values !== 'function') return false;
+	iterator = arr.values();
+	if (!iterator) return false;
+	if (typeof iterator.next !== 'function') return false;
+	result = iterator.next();
+	if (!result) return false;
+	if (result.value !== 'foo') return false;
+	if (result.done !== false) return false;
+	return true;
+};

node_modules/es5-ext/array/#/values/shim.js

@@ -0,0 +1,4 @@
+'use strict';
+
+var ArrayIterator = require('es6-iterator/array');
+module.exports = function () { return new ArrayIterator(this, 'value'); };