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

node_modules/memoizee/lib/configure-map.js

@@ -0,0 +1,144 @@
+'use strict';
+
+var customError      = require('es5-ext/error/custom')
+  , defineLength     = require('es5-ext/function/_define-length')
+  , d                = require('d')
+  , ee               = require('event-emitter').methods
+  , resolveResolve   = require('./resolve-resolve')
+  , resolveNormalize = require('./resolve-normalize')
+
+  , apply = Function.prototype.apply, call = Function.prototype.call
+  , create = Object.create, hasOwnProperty = Object.prototype.hasOwnProperty
+  , defineProperties = Object.defineProperties
+  , on = ee.on, emit = ee.emit;
+
+module.exports = function (original, length, options) {
+	var cache = create(null), conf, memLength, get, set, del, clear, extDel, normalizer
+	  , getListeners, setListeners, deleteListeners, memoized, resolve;
+	if (length !== false) memLength = length;
+	else if (isNaN(original.length)) memLength = 1;
+	else memLength = original.length;
+
+	if (options.normalizer) {
+		normalizer = resolveNormalize(options.normalizer);
+		get = normalizer.get;
+		set = normalizer.set;
+		del = normalizer.delete;
+		clear = normalizer.clear;
+	}
+	if (options.resolvers != null) resolve = resolveResolve(options.resolvers);
+
+	if (get) {
+		memoized = defineLength(function (arg) {
+			var id, result, args = arguments;
+			if (resolve) args = resolve(args);
+			id = get(args);
+			if (id !== null) {
+				if (hasOwnProperty.call(cache, id)) {
+					if (getListeners) conf.emit('get', id, args, this);
+					return cache[id];
+				}
+			}
+			if (args.length === 1) result = call.call(original, this, arg);
+			else result = apply.call(original, this, args);
+			if (id === null) {
+				id = get(args);
+				if (id !== null) throw customError("Circular invocation", 'CIRCULAR_INVOCATION');
+				id = set(args);
+			} else if (hasOwnProperty.call(cache, id)) {
+				throw customError("Circular invocation", 'CIRCULAR_INVOCATION');
+			}
+			cache[id] = result;
+			if (setListeners) conf.emit('set', id);
+			return result;
+		}, memLength);
+	} else if (length === 0) {
+		memoized = function () {
+			var result;
+			if (hasOwnProperty.call(cache, 'data')) {
+				if (getListeners) conf.emit('get', 'data', arguments, this);
+				return cache.data;
+			}
+			if (!arguments.length) result = call.call(original, this);
+			else result = apply.call(original, this, arguments);
+			if (hasOwnProperty.call(cache, 'data')) {
+				throw customError("Circular invocation", 'CIRCULAR_INVOCATION');
+			}
+			cache.data = result;
+			if (setListeners) conf.emit('set', 'data');
+			return result;
+		};
+	} else {
+		memoized = function (arg) {
+			var result, args = arguments, id;
+			if (resolve) args = resolve(arguments);
+			id = String(args[0]);
+			if (hasOwnProperty.call(cache, id)) {
+				if (getListeners) conf.emit('get', id, args, this);
+				return cache[id];
+			}
+			if (args.length === 1) result = call.call(original, this, args[0]);
+			else result = apply.call(original, this, args);
+			if (hasOwnProperty.call(cache, id)) {
+				throw customError("Circular invocation", 'CIRCULAR_INVOCATION');
+			}
+			cache[id] = result;
+			if (setListeners) conf.emit('set', id);
+			return result;
+		};
+	}
+	conf = {
+		original: original,
+		memoized: memoized,
+		get: function (args) {
+			if (resolve) args = resolve(args);
+			if (get) return get(args);
+			return String(args[0]);
+		},
+		has: function (id) { return hasOwnProperty.call(cache, id); },
+		delete: function (id) {
+			var result;
+			if (!hasOwnProperty.call(cache, id)) return;
+			if (del) del(id);
+			result = cache[id];
+			delete cache[id];
+			if (deleteListeners) conf.emit('delete', id, result);
+		},
+		clear: function () {
+			var oldCache = cache;
+			if (clear) clear();
+			cache = create(null);
+			conf.emit('clear', oldCache);
+		},
+		on: function (type, listener) {
+			if (type === 'get') getListeners = true;
+			else if (type === 'set') setListeners = true;
+			else if (type === 'delete') deleteListeners = true;
+			return on.call(this, type, listener);
+		},
+		emit: emit,
+		updateEnv: function () { original = conf.original; }
+	};
+	if (get) {
+		extDel = defineLength(function (arg) {
+			var id, args = arguments;
+			if (resolve) args = resolve(args);
+			id = get(args);
+			if (id === null) return;
+			conf.delete(id);
+		}, memLength);
+	} else if (length === 0) {
+		extDel = function () { return conf.delete('data'); };
+	} else {
+		extDel = function (arg) {
+			if (resolve) arg = resolve(arguments)[0];
+			return conf.delete(arg);
+		};
+	}
+	defineProperties(memoized, {
+		__memoized__: d(true),
+		delete: d(extDel),
+		clear: d(conf.clear)
+	});
+	return conf;
+};

node_modules/memoizee/lib/methods.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var forEach       = require('es5-ext/object/for-each')
+  , normalizeOpts = require('es5-ext/object/normalize-options')
+  , callable      = require('es5-ext/object/valid-callable')
+  , lazy          = require('d/lazy')
+  , resolveLength = require('./resolve-length')
+  , extensions    = require('./registered-extensions');
+
+module.exports = function (memoize) {
+	return function (props) {
+		forEach(props, function (desc, name) {
+			var fn = callable(desc.value), length;
+			desc.value = function (options) {
+				if (options.getNormalizer) {
+					options = normalizeOpts(options);
+					if (length === undefined) {
+						length = resolveLength(options.length, fn.length, options.async && extensions.async);
+					}
+					options.normalizer = options.getNormalizer(length);
+					delete options.getNormalizer;
+				}
+				return memoize(fn.bind(this), options);
+			};
+		});
+		return lazy(props);
+	};
+};

node_modules/memoizee/lib/registered-extensions.js

@@ -0,0 +1 @@
+'use strict';

node_modules/memoizee/lib/resolve-length.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var toPosInt = require('es5-ext/number/to-pos-integer');
+
+module.exports = function (optsLength, fnLength, isAsync) {
+	var length;
+	if (isNaN(optsLength)) {
+		length = fnLength;
+		if (!(length >= 0)) return 1;
+		if (isAsync && length) return length - 1;
+		return length;
+	}
+	if (optsLength === false) return false;
+	return toPosInt(optsLength);
+};

node_modules/memoizee/lib/resolve-normalize.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var callable = require('es5-ext/object/valid-callable');
+
+module.exports = function (userNormalizer) {
+	var normalizer;
+	if (typeof userNormalizer === 'function') return { set: userNormalizer, get: userNormalizer };
+	normalizer = { get: callable(userNormalizer.get) };
+	if (userNormalizer.set !== undefined) {
+		normalizer.set = callable(userNormalizer.set);
+		normalizer.delete = callable(userNormalizer.delete);
+		normalizer.clear = callable(userNormalizer.clear);
+		return normalizer;
+	}
+	normalizer.set = normalizer.get;
+	return normalizer;
+};

node_modules/memoizee/lib/resolve-resolve.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var toArray  = require('es5-ext/array/to-array')
+  , callable = require('es5-ext/object/valid-callable')
+
+  , slice = Array.prototype.slice
+  , resolveArgs;
+
+resolveArgs = function (args) {
+	return this.map(function (r, i) {
+		return r ? r(args[i]) : args[i];
+	}).concat(slice.call(args, this.length));
+};
+
+module.exports = function (resolvers) {
+	resolvers = toArray(resolvers);
+	resolvers.forEach(function (r) {
+		if (r != null) callable(r);
+	});
+	return resolveArgs.bind(resolvers);
+};

node_modules/memoizee/lib/weak.js

@@ -0,0 +1,112 @@
+'use strict';
+
+var customError      = require('es5-ext/error/custom')
+  , defineLength     = require('es5-ext/function/_define-length')
+  , partial          = require('es5-ext/function/#/partial')
+  , copy             = require('es5-ext/object/copy')
+  , normalizeOpts    = require('es5-ext/object/normalize-options')
+  , callable         = require('es5-ext/object/valid-callable')
+  , d                = require('d')
+  , WeakMap          = require('es6-weak-map')
+  , resolveLength    = require('./resolve-length')
+  , extensions       = require('./registered-extensions')
+  , resolveResolve   = require('./resolve-resolve')
+  , resolveNormalize = require('./resolve-normalize')
+
+  , slice = Array.prototype.slice, defineProperties = Object.defineProperties
+  , hasOwnProperty = Object.prototype.hasOwnProperty;
+
+module.exports = function (memoize) {
+	return function (fn/*, options*/) {
+		var map, length, options = normalizeOpts(arguments[1]), memoized, resolve, normalizer;
+
+		callable(fn);
+
+		// Do not memoize already memoized function
+		if (hasOwnProperty.call(fn, '__memoized__') && !options.force) return fn;
+
+		length = resolveLength(options.length, fn.length, options.async && extensions.async);
+		options.length = length ? length - 1 : 0;
+		map = new WeakMap();
+
+		if (options.resolvers) resolve = resolveResolve(options.resolvers);
+		if (options.normalizer) normalizer = resolveNormalize(options.normalizer);
+
+		if ((length === 1) && !normalizer && !(options.async && extensions.async) &&
+				!(options.dispose && extensions.dispose) && !(options.maxAge && extensions.maxAge) &&
+				!(options.max && extensions.max) && !(options.refCounter && extensions.refCounter)) {
+			return defineProperties(function (obj) {
+				var result;
+				if (resolve) obj = resolve(arguments)[0];
+				if (map.has(obj)) return map.get(obj);
+				result = fn.call(this, obj);
+				if (map.has(obj)) throw customError("Circular invocation", 'CIRCULAR_INVOCATION');
+				map.set(obj, result);
+				return result;
+			}, {
+				__memoized__: d(true),
+				delete: d(function (obj) {
+					if (resolve) obj = resolve(arguments)[0];
+					return map.delete(obj);
+				})
+			});
+		}
+		memoized = defineProperties(defineLength(function (obj) {
+			var memoizer, args = arguments;
+			if (resolve) {
+				args = resolve(args);
+				obj = args[0];
+			}
+			memoizer = map.get(obj);
+			if (!memoizer) {
+				if (normalizer) {
+					options = copy(options);
+					options.normalizer = copy(normalizer);
+					options.normalizer.get = partial.call(options.normalizer.get, obj);
+					options.normalizer.set = partial.call(options.normalizer.set, obj);
+					if (options.normalizer.delete) {
+						options.normalizer.delete = partial.call(options.normalizer.delete, obj);
+					}
+				}
+				map.set(obj, memoizer = memoize(partial.call(fn, obj), options));
+			}
+			return memoizer.apply(this, slice.call(args, 1));
+		}, length), {
+			__memoized__: d(true),
+			delete: d(defineLength(function (obj) {
+				var memoizer, args = arguments;
+				if (resolve) {
+					args = resolve(args);
+					obj = args[0];
+				}
+				memoizer = map.get(obj);
+				if (!memoizer) return;
+				memoizer.delete.apply(this, slice.call(args, 1));
+			}, length))
+		});
+		if (!options.refCounter || !extensions.refCounter) return memoized;
+		defineProperties(memoized, {
+			deleteRef: d(defineLength(function (obj) {
+				var memoizer, args = arguments;
+				if (resolve) {
+					args = resolve(args);
+					obj = args[0];
+				}
+				memoizer = map.get(obj);
+				if (!memoizer) return null;
+				return memoizer.deleteRef.apply(this, slice.call(args, 1));
+			}, length)),
+			getRefCount: d(defineLength(function (obj) {
+				var memoizer, args = arguments;
+				if (resolve) {
+					args = resolve(args);
+					obj = args[0];
+				}
+				memoizer = map.get(obj);
+				if (!memoizer) return 0;
+				return memoizer.getRefCount.apply(this, slice.call(args, 1));
+			}, length))
+		});
+		return memoized;
+	};
+};