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

node_modules/memoizee/ext/async.js

@@ -0,0 +1,146 @@
+// Support for asynchronous functions
+
+'use strict';
+
+var aFrom        = require('es5-ext/array/from')
+  , mixin        = require('es5-ext/object/mixin')
+  , defineLength = require('es5-ext/function/_define-length')
+  , nextTick     = require('next-tick')
+
+  , slice = Array.prototype.slice
+  , apply = Function.prototype.apply, create = Object.create
+  , hasOwnProperty = Object.prototype.hasOwnProperty;
+
+require('../lib/registered-extensions').async = function (tbi, conf) {
+	var waiting = create(null), cache = create(null)
+	  , base = conf.memoized, original = conf.original
+	  , currentCallback, currentContext, currentArgs;
+
+	// Initial
+	conf.memoized = defineLength(function (arg) {
+		var args = arguments, last = args[args.length - 1];
+		if (typeof last === 'function') {
+			currentCallback = last;
+			args = slice.call(args, 0, -1);
+		}
+		return base.apply(currentContext = this, currentArgs = args);
+	}, base);
+	try { mixin(conf.memoized, base); } catch (ignore) {}
+
+	// From cache (sync)
+	conf.on('get', function (id) {
+		var cb, context, args;
+		if (!currentCallback) return;
+
+		// Unresolved
+		if (waiting[id]) {
+			if (typeof waiting[id] === 'function') waiting[id] = [waiting[id], currentCallback];
+			else waiting[id].push(currentCallback);
+			currentCallback = null;
+			return;
+		}
+
+		// Resolved, assure next tick invocation
+		cb = currentCallback;
+		context = currentContext;
+		args = currentArgs;
+		currentCallback = currentContext = currentArgs = null;
+		nextTick(function () {
+			var data;
+			if (hasOwnProperty.call(cache, id)) {
+				data = cache[id];
+				conf.emit('getasync', id, args, context);
+				apply.call(cb, data.context, data.args);
+			} else {
+				// Purged in a meantime, we shouldn't rely on cached value, recall
+				currentCallback = cb;
+				currentContext = context;
+				currentArgs = args;
+				base.apply(context, args);
+			}
+		});
+	});
+
+	// Not from cache
+	conf.original = function () {
+		var args, cb, origCb, result;
+		if (!currentCallback) return apply.call(original, this, arguments);
+		args = aFrom(arguments);
+		cb = function self(err) {
+			var cb, args, id = self.id;
+			if (id == null) {
+				// Shouldn't happen, means async callback was called sync way
+				nextTick(apply.bind(self, this, arguments));
+				return;
+			}
+			delete self.id;
+			cb = waiting[id];
+			delete waiting[id];
+			if (!cb) {
+				// Already processed,
+				// outcome of race condition: asyncFn(1, cb), asyncFn.clear(), asyncFn(1, cb)
+				return;
+			}
+			args = aFrom(arguments);
+			if (conf.has(id)) {
+				if (err) {
+					conf.delete(id);
+				} else {
+					cache[id] = { context: this, args: args };
+					conf.emit('setasync', id, (typeof cb === 'function') ? 1 : cb.length);
+				}
+			}
+			if (typeof cb === 'function') {
+				result = apply.call(cb, this, args);
+			} else {
+				cb.forEach(function (cb) { result = apply.call(cb, this, args); }, this);
+			}
+			return result;
+		};
+		origCb = currentCallback;
+		currentCallback = currentContext = currentArgs = null;
+		args.push(cb);
+		result = apply.call(original, this, args);
+		cb.cb = origCb;
+		currentCallback = cb;
+		return result;
+	};
+
+	// After not from cache call
+	conf.on('set', function (id) {
+		if (!currentCallback) {
+			conf.delete(id);
+			return;
+		}
+		if (waiting[id]) {
+			// Race condition: asyncFn(1, cb), asyncFn.clear(), asyncFn(1, cb)
+			if (typeof waiting[id] === 'function') waiting[id] = [waiting[id], currentCallback.cb];
+			else waiting[id].push(currentCallback.cb);
+		} else {
+			waiting[id] = currentCallback.cb;
+		}
+		delete currentCallback.cb;
+		currentCallback.id = id;
+		currentCallback = null;
+	});
+
+	// On delete
+	conf.on('delete', function (id) {
+		var result;
+		// If false, we don't have value yet, so we assume that intention is not
+		// to memoize this call. After value is obtained we don't cache it but
+		// gracefully pass to callback
+		if (hasOwnProperty.call(waiting, id)) return;
+		if (!cache[id]) return;
+		result = cache[id];
+		delete cache[id];
+		conf.emit('deleteasync', id, result);
+	});
+
+	// On clear
+	conf.on('clear', function () {
+		var oldCache = cache;
+		cache = create(null);
+		conf.emit('clearasync', oldCache);
+	});
+};

node_modules/memoizee/ext/dispose.js

@@ -0,0 +1,27 @@
+// Call dispose callback on each cache purge
+
+'use strict';
+
+var callable   = require('es5-ext/object/valid-callable')
+  , forEach    = require('es5-ext/object/for-each')
+  , extensions = require('../lib/registered-extensions')
+
+  , slice = Array.prototype.slice, apply = Function.prototype.apply;
+
+extensions.dispose = function (dispose, conf, options) {
+	var del;
+	callable(dispose);
+	if (options.async && extensions.async) {
+		conf.on('deleteasync', del = function (id, result) {
+			apply.call(dispose, null, slice.call(result.args, 1));
+		});
+		conf.on('clearasync', function (cache) {
+			forEach(cache, function (result, id) { del(id, result); });
+		});
+		return;
+	}
+	conf.on('delete', del = function (id, result) { dispose(result); });
+	conf.on('clear', function (cache) {
+		forEach(cache, function (result, id) { del(id, result); });
+	});
+};

node_modules/memoizee/ext/max-age.js

@@ -0,0 +1,70 @@
+// Timeout cached values
+
+'use strict';
+
+var aFrom      = require('es5-ext/array/from')
+  , noop       = require('es5-ext/function/noop')
+  , forEach    = require('es5-ext/object/for-each')
+  , timeout    = require('timers-ext/valid-timeout')
+  , extensions = require('../lib/registered-extensions')
+
+  , max = Math.max, min = Math.min, create = Object.create;
+
+extensions.maxAge = function (maxAge, conf, options) {
+	var timeouts, postfix, preFetchAge, preFetchTimeouts;
+
+	maxAge = timeout(maxAge);
+	if (!maxAge) return;
+
+	timeouts = create(null);
+	postfix = (options.async && extensions.async) ? 'async' : '';
+	conf.on('set' + postfix, function (id) {
+		timeouts[id] = setTimeout(function () { conf.delete(id); }, maxAge);
+		if (!preFetchTimeouts) return;
+		if (preFetchTimeouts[id]) clearTimeout(preFetchTimeouts[id]);
+		preFetchTimeouts[id] = setTimeout(function () {
+			delete preFetchTimeouts[id];
+		}, preFetchAge);
+	});
+	conf.on('delete' + postfix, function (id) {
+		clearTimeout(timeouts[id]);
+		delete timeouts[id];
+		if (!preFetchTimeouts) return;
+		clearTimeout(preFetchTimeouts[id]);
+		delete preFetchTimeouts[id];
+	});
+
+	if (options.preFetch) {
+		if ((options.preFetch === true) || isNaN(options.preFetch)) {
+			preFetchAge = 0.333;
+		} else {
+			preFetchAge = max(min(Number(options.preFetch), 1), 0);
+		}
+		if (preFetchAge) {
+			preFetchTimeouts = {};
+			preFetchAge = (1 - preFetchAge) * maxAge;
+			conf.on('get' + postfix, function (id, args, context) {
+				if (!preFetchTimeouts[id]) {
+					preFetchTimeouts[id] =  setTimeout(function () {
+						delete preFetchTimeouts[id];
+						conf.delete(id);
+						if (options.async) {
+							args = aFrom(args);
+							args.push(noop);
+						}
+						conf.memoized.apply(context, args);
+					}, 0);
+				}
+			});
+		}
+	}
+
+	conf.on('clear' + postfix, function () {
+		forEach(timeouts, function (id) { clearTimeout(id); });
+		timeouts = {};
+		if (preFetchTimeouts) {
+			forEach(preFetchTimeouts, function (id) { clearTimeout(id); });
+			preFetchTimeouts = {};
+		}
+	});
+};

node_modules/memoizee/ext/max.js

@@ -0,0 +1,26 @@
+// Limit cache size, LRU (least recently used) algorithm.
+
+'use strict';
+
+var toPosInteger = require('es5-ext/number/to-pos-integer')
+  , lruQueue     = require('lru-queue')
+  , extensions   = require('../lib/registered-extensions');
+
+extensions.max = function (max, conf, options) {
+	var postfix, queue, hit;
+
+	max = toPosInteger(max);
+	if (!max) return;
+
+	queue = lruQueue(max);
+	postfix = (options.async && extensions.async) ? 'async' : '';
+
+	conf.on('set' + postfix, hit = function (id) {
+		id = queue.hit(id);
+		if (id === undefined) return;
+		conf.delete(id);
+	});
+	conf.on('get' + postfix, hit);
+	conf.on('delete' + postfix, queue.delete);
+	conf.on('clear' + postfix, queue.clear);
+};

node_modules/memoizee/ext/ref-counter.js

@@ -0,0 +1,39 @@
+// Reference counter, useful for garbage collector like functionality
+
+'use strict';
+
+var d          = require('d')
+  , extensions = require('../lib/registered-extensions')
+
+  , create = Object.create, defineProperties = Object.defineProperties;
+
+extensions.refCounter = function (ignore, conf, options) {
+	var cache, postfix;
+
+	cache = create(null);
+	postfix = (options.async && extensions.async) ? 'async' : '';
+
+	conf.on('set' + postfix, function (id, length) { cache[id] = length || 1; });
+	conf.on('get' + postfix, function (id) { ++cache[id]; });
+	conf.on('delete' + postfix, function (id) { delete cache[id]; });
+	conf.on('clear' + postfix, function () { cache = {}; });
+
+	defineProperties(conf.memoized, {
+		deleteRef: d(function () {
+			var id = conf.get(arguments);
+			if (id === null) return null;
+			if (!cache[id]) return null;
+			if (!--cache[id]) {
+				conf.delete(id);
+				return true;
+			}
+			return false;
+		}),
+		getRefCount: d(function () {
+			var id = conf.get(arguments);
+			if (id === null) return 0;
+			if (!cache[id]) return 0;
+			return cache[id];
+		})
+	});
+};