hexo-adsense 1.0.21 → 1.0.25

package/packages/memoize/lib/configure-map.js

@@ -0,0 +1,182 @@
+/* eslint no-eq-null: 0, eqeqeq: 0, no-unused-vars: 0 */
+
+"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");
+
+var apply = Function.prototype.apply
+  , call = Function.prototype.call
+  , create = Object.create
+  , 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
+	  , extGet
+	  , extHas
+	  , 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, args[0]);
+			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, null, result);
+			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 = apply.call(original, this, arguments);
+			else result = call.call(original, this);
+			if (hasOwnProperty.call(cache, "data")) {
+				throw customError("Circular invocation", "CIRCULAR_INVOCATION");
+			}
+			cache.data = result;
+			if (setListeners) conf.emit("set", "data", null, result);
+			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, null, result);
+			return result;
+		};
+	}
+	conf = {
+		original: original,
+		memoized: memoized,
+		profileName: options.profileName,
+		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);
+		};
+	}
+	extGet = defineLength(function () {
+		var id, args = arguments;
+		if (length === 0) return cache.data;
+		if (resolve) args = resolve(args);
+		if (get) id = get(args);
+		else id = String(args[0]);
+		return cache[id];
+	});
+	extHas = defineLength(function () {
+		var id, args = arguments;
+		if (length === 0) return conf.has("data");
+		if (resolve) args = resolve(args);
+		if (get) id = get(args);
+		else id = String(args[0]);
+		if (id === null) return false;
+		return conf.has(id);
+	});
+	defineProperties(memoized, {
+		__memoized__: d(true),
+		delete: d(extDel),
+		clear: d(conf.clear),
+		_get: d(extGet),
+		_has: d(extHas)
+	});
+	return conf;
+};

package/packages/memoize/lib/methods.js

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

package/packages/memoize/lib/registered-extensions.js

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

package/packages/memoize/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);
+};

package/packages/memoize/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);
+		if (userNormalizer.delete) normalizer.delete = callable(userNormalizer.delete);
+		if (userNormalizer.clear) normalizer.clear = callable(userNormalizer.clear);
+		return normalizer;
+	}
+	normalizer.set = normalizer.get;
+	return normalizer;
+};

package/packages/memoize/lib/resolve-resolve.js

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

package/packages/memoize/lib/weak.js

@@ -0,0 +1,134 @@
+"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");
+
+var slice = Array.prototype.slice, defineProperties = Object.defineProperties;
+
+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 &&
+			!options.dispose &&
+			!options.maxAge &&
+			!options.max &&
+			!options.refCounter
+		) {
+			return defineProperties(
+				function (obj) {
+					var result, args = arguments;
+					if (resolve) args = resolve(args);
+					obj = args[0];
+					if (map.has(obj)) return map.get(obj);
+					result = fn.apply(this, args);
+					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) 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;
+	};
+};

package/packages/memoize/methods-plain.js

@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = require("./lib/methods")(require("./plain"));

package/packages/memoize/methods.js

@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = require("./lib/methods")(require("./"));

package/packages/memoize/normalizers/get-1.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var indexOf = require("es5-ext/array/#/e-index-of");
+
+module.exports = function () {
+	var lastId = 0, argsMap = [], cache = [];
+	return {
+		get: function (args) {
+			var index = indexOf.call(argsMap, args[0]);
+			return index === -1 ? null : cache[index];
+		},
+		set: function (args) {
+			argsMap.push(args[0]);
+			cache.push(++lastId);
+			return lastId;
+		},
+		delete: function (id) {
+			var index = indexOf.call(cache, id);
+			if (index !== -1) {
+				argsMap.splice(index, 1);
+				cache.splice(index, 1);
+			}
+		},
+		clear: function () {
+			argsMap = [];
+			cache = [];
+		}
+	};
+};

package/packages/memoize/normalizers/get-fixed.js

@@ -0,0 +1,71 @@
+"use strict";
+
+var indexOf = require("es5-ext/array/#/e-index-of")
+  , create  = Object.create;
+
+module.exports = function (length) {
+	var lastId = 0, map = [[], []], cache = create(null);
+	return {
+		get: function (args) {
+			var index = 0, set = map, i;
+			while (index < length - 1) {
+				i = indexOf.call(set[0], args[index]);
+				if (i === -1) return null;
+				set = set[1][i];
+				++index;
+			}
+			i = indexOf.call(set[0], args[index]);
+			if (i === -1) return null;
+			return set[1][i] || null;
+		},
+		set: function (args) {
+			var index = 0, set = map, i;
+			while (index < length - 1) {
+				i = indexOf.call(set[0], args[index]);
+				if (i === -1) {
+					i = set[0].push(args[index]) - 1;
+					set[1].push([[], []]);
+				}
+				set = set[1][i];
+				++index;
+			}
+			i = indexOf.call(set[0], args[index]);
+			if (i === -1) {
+				i = set[0].push(args[index]) - 1;
+			}
+			set[1][i] = ++lastId;
+			cache[lastId] = args;
+			return lastId;
+		},
+		delete: function (id) {
+			var index = 0, set = map, i, path = [], args = cache[id];
+			while (index < length - 1) {
+				i = indexOf.call(set[0], args[index]);
+				if (i === -1) {
+					return;
+				}
+				path.push(set, i);
+				set = set[1][i];
+				++index;
+			}
+			i = indexOf.call(set[0], args[index]);
+			if (i === -1) {
+				return;
+			}
+			id = set[1][i];
+			set[0].splice(i, 1);
+			set[1].splice(i, 1);
+			while (!set[0].length && path.length) {
+				i = path.pop();
+				set = path.pop();
+				set[0].splice(i, 1);
+				set[1].splice(i, 1);
+			}
+			delete cache[id];
+		},
+		clear: function () {
+			map = [[], []];
+			cache = create(null);
+		}
+	};
+};

package/packages/memoize/normalizers/get-primitive-fixed.js

@@ -0,0 +1,16 @@
+"use strict";
+
+module.exports = function (length) {
+	if (!length) {
+		return function () {
+			return "";
+		};
+	}
+	return function (args) {
+		var id = String(args[0]), i = 0, currentLength = length;
+		while (--currentLength) {
+			id += "\u0001" + args[++i];
+		}
+		return id;
+	};
+};

package/packages/memoize/normalizers/get.js

@@ -0,0 +1,90 @@
+/* eslint max-statements: 0 */
+
+"use strict";
+
+var indexOf = require("es5-ext/array/#/e-index-of");
+
+var create = Object.create;
+
+module.exports = function () {
+	var lastId = 0, map = [], cache = create(null);
+	return {
+		get: function (args) {
+			var index = 0, set = map, i, length = args.length;
+			if (length === 0) return set[length] || null;
+			if ((set = set[length])) {
+				while (index < length - 1) {
+					i = indexOf.call(set[0], args[index]);
+					if (i === -1) return null;
+					set = set[1][i];
+					++index;
+				}
+				i = indexOf.call(set[0], args[index]);
+				if (i === -1) return null;
+				return set[1][i] || null;
+			}
+			return null;
+		},
+		set: function (args) {
+			var index = 0, set = map, i, length = args.length;
+			if (length === 0) {
+				set[length] = ++lastId;
+			} else {
+				if (!set[length]) {
+					set[length] = [[], []];
+				}
+				set = set[length];
+				while (index < length - 1) {
+					i = indexOf.call(set[0], args[index]);
+					if (i === -1) {
+						i = set[0].push(args[index]) - 1;
+						set[1].push([[], []]);
+					}
+					set = set[1][i];
+					++index;
+				}
+				i = indexOf.call(set[0], args[index]);
+				if (i === -1) {
+					i = set[0].push(args[index]) - 1;
+				}
+				set[1][i] = ++lastId;
+			}
+			cache[lastId] = args;
+			return lastId;
+		},
+		delete: function (id) {
+			var index = 0, set = map, i, args = cache[id], length = args.length, path = [];
+			if (length === 0) {
+				delete set[length];
+			} else if ((set = set[length])) {
+				while (index < length - 1) {
+					i = indexOf.call(set[0], args[index]);
+					if (i === -1) {
+						return;
+					}
+					path.push(set, i);
+					set = set[1][i];
+					++index;
+				}
+				i = indexOf.call(set[0], args[index]);
+				if (i === -1) {
+					return;
+				}
+				id = set[1][i];
+				set[0].splice(i, 1);
+				set[1].splice(i, 1);
+				while (!set[0].length && path.length) {
+					i = path.pop();
+					set = path.pop();
+					set[0].splice(i, 1);
+					set[1].splice(i, 1);
+				}
+			}
+			delete cache[id];
+		},
+		clear: function () {
+			map = [];
+			cache = create(null);
+		}
+	};
+};

package/packages/memoize/normalizers/primitive.js

@@ -0,0 +1,9 @@
+"use strict";
+
+module.exports = function (args) {
+	var id, i, length = args.length;
+	if (!length) return "\u0002";
+	id = String(args[i = 0]);
+	while (--length) id += "\u0001" + args[++i];
+	return id;
+};

package/packages/memoize/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "memoizee",
+  "version": "0.4.15",
+  "description": "Memoize/cache function results",
+  "author": "Mariusz Nowak <medikoo@medikoo.com> (http://www.medikoo.com/)",
+  "keywords": [
+    "memoize",
+    "memoizer",
+    "cache",
+    "memoization",
+    "memo",
+    "memcached",
+    "hashing.",
+    "storage",
+    "caching",
+    "memory",
+    "gc",
+    "weak",
+    "garbage",
+    "collector",
+    "async"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/medikoo/memoizee.git"
+  },
+  "dependencies": {
+    "d": "^1.0.1",
+    "es5-ext": "^0.10.53",
+    "es6-weak-map": "^2.0.3",
+    "event-emitter": "^0.3.5",
+    "is-promise": "^2.2.2",
+    "lru-queue": "^0.1.0",
+    "next-tick": "^1.1.0",
+    "timers-ext": "^0.1.7"
+  },
+  "devDependencies": {
+    "bluebird": "^3.7.2",
+    "eslint": "^5.16.0",
+    "eslint-config-medikoo-es5": "^1.7.3",
+    "plain-promise": "^0.1.1",
+    "tad": "^2.0.1"
+  },
+  "eslintConfig": {
+    "extends": "medikoo-es5",
+    "root": true,
+    "globals": {
+      "setTimeout": true,
+      "clearTimeout": true
+    },
+    "rules": {
+      "max-lines-per-function": "off"
+    }
+  },
+  "scripts": {
+    "lint": "eslint --ignore-path=.gitignore .",
+    "test": "tad"
+  },
+  "license": "ISC"
+}