From 1f8ef629e6e8c0c8be6c9fc119c6a2e826fbad46 Mon Sep 17 00:00:00 2001
From: Peter Jaszkowiak <p.jaszkow@gmail.com>
Date: Wed, 17 May 2017 15:59:55 -0600
Subject: [PATCH 01/42] Extract in-place translation from bootbox wrapper for
 use anywhere

---
 public/src/modules/translator.js | 66 +++++++++++++++++++++++++++++++-
 public/vendor/bootbox/wrapper.js | 61 ++++-------------------------
 2 files changed, 72 insertions(+), 55 deletions(-)

diff --git a/public/src/modules/translator.js b/public/src/modules/translator.js
index afd64317ef..5296e1eef4 100644
--- a/public/src/modules/translator.js
+++ b/public/src/modules/translator.js
@@ -304,7 +304,7 @@
 		 * Load translation file (or use a cached version), and optionally return the translation of a certain key
 		 * @param {string} namespace - The file name of the translation namespace
 		 * @param {string} [key] - The key of the specific translation to getJSON
-		 * @returns {Promise<Object>|Promise<string>}
+		 * @returns {Promise<{ [key: string]: string }>|Promise<string>}
 		 */
 		Translator.prototype.getTranslation = function getTranslation(namespace, key) {
 			var translation;
@@ -324,6 +324,70 @@
 			return translation;
 		};
 
+		/**
+		 * @param {Node} node
+		 * @returns {Node[]}
+		 */
+		function descendantTextNodes(node) {
+			var textNodes = [];
+
+			function helper(node) {
+				if (node.nodeType === 3) {
+					textNodes.push(node);
+				} else {
+					for (var i = 0, c = node.childNodes, l = c.length; i < l; i += 1) {
+						helper(c[i]);
+					}
+				}
+			}
+
+			helper(node);
+			return textNodes;
+		}
+
+		/**
+		 * Recursively translate a DOM element in place
+		 * @param {Element} element - Root element to translate
+		 * @param {string[]} [attributes] - Array of node attributes to translate
+		 * @returns {Promise<void>}
+		 */
+		Translator.prototype.translateInPlace = function translateInPlace(element, attributes) {
+			attributes = attributes || ['placeholder', 'title'];
+
+			var nodes = descendantTextNodes(element);
+			var text = nodes.map(function (node) {
+				return node.nodeValue;
+			}).join('  ||  ');
+
+			var attrNodes = attributes.reduce(function (prev, attr) {
+				var tuples = Array.prototype.map.call(element.querySelectorAll('[' + attr + '*="[["]'), function (el) {
+					return [attr, el];
+				});
+				return prev.concat(tuples);
+			}, []);
+			var attrText = attrNodes.map(function (node) {
+				return node[1].getAttribute(node[0]);
+			}).join('  ||  ');
+
+			return Promise.all([
+				this.translate(text),
+				this.translate(attrText),
+			]).then(function (ref) {
+				var translated = ref[0];
+				var translatedAttrs = ref[1];
+				if (translated) {
+					translated.split('  ||  ').forEach(function (html, i) {
+						$(nodes[i]).replaceWith(html);
+					});
+				}
+				if (translatedAttrs) {
+					translatedAttrs.split('  ||  ').forEach(function (text, i) {
+						attrNodes[i][1].setAttribute(attrNodes[i][0], text);
+					});
+				}
+			});
+		};
+
 		/**
 		 * Get the language of the current environment, falling back to defaults
 		 * @returns {string}
diff --git a/public/vendor/bootbox/wrapper.js b/public/vendor/bootbox/wrapper.js
index 505b42788f..35efdd8305 100644
--- a/public/vendor/bootbox/wrapper.js
+++ b/public/vendor/bootbox/wrapper.js
@@ -1,67 +1,20 @@
 /* global bootbox */
 
 require(['translator'], function (shim) {
-	"use strict";
-
-	function descendantTextNodes(node) {
-		var textNodes = [];
-
-		function helper(node) {
-			if (node.nodeType === 3) {
-				textNodes.push(node);
-			} else {
-				for (var i = 0, c = node.childNodes, l = c.length; i < l; i += 1) {
-					helper(c[i]);
-				}
-			}
-		}
-
-		helper(node);
-		return textNodes;
-	}
+	'use strict';
 
 	var translator = shim.Translator.create();
 	var dialog = bootbox.dialog;
 	var attrsToTranslate = ['placeholder', 'title', 'value'];
 	bootbox.dialog = function (options) {
-		var show, $elem, nodes, text, attrNodes, attrText;
-
-		show = options.show !== false;
+		var show = options.show !== false;
 		options.show = false;
 
-		$elem = dialog.call(bootbox, options);
+		var $elem = dialog.call(bootbox, options);
+		var element = $elem[0];
 
-		if (/\[\[.+\]\]/.test($elem[0].outerHTML)) {
-			nodes = descendantTextNodes($elem[0]);
-			text = nodes.map(function (node) {
-				return node.nodeValue;
-			}).join('  ||  ');
-
-			attrNodes = attrsToTranslate.reduce(function (prev, attr) {
-				return prev.concat(nodes.map.call($elem.find('[' + attr + '*="[["]'), function (el) {
-					return [attr, el];
-				}));
-			}, []);
-			attrText = attrNodes.map(function (node) {
-				return node[1].getAttribute(node[0]);
-			}).join('  ||  ');
-
-			Promise.all([
-				translator.translate(text),
-				translator.translate(attrText),
-			]).then(function (ref) {
-				var translated = ref[0];
-				var translatedAttrs = ref[1];
-				if (translated) {
-					translated.split('  ||  ').forEach(function (html, i) {
-						$(nodes[i]).replaceWith(html);
-					});
-				}
-				if (translatedAttrs) {
-					translatedAttrs.split('  ||  ').forEach(function (text, i) {
-						attrNodes[i][1].setAttribute(attrNodes[i][0], text);
-					});
-				}
+		if (/\[\[.+\]\]/.test(element.outerHTML)) {
+			translator.translateInPlace(element, attrsToTranslate).then(function () {
 				if (show) {
 					$elem.modal('show');
 				}
@@ -84,7 +37,7 @@ require(['translator'], function (shim) {
 			CANCEL: translations[1],
 			CONFIRM: translations[2],
 		});
-		
+
 		bootbox.setLocale(lang);
 	});
 });

From 2afce9f7c3d25abf6230e6a325d0d5a055661b69 Mon Sep 17 00:00:00 2001
From: Ole R <frissdiegurke@protonmail.com>
Date: Thu, 18 May 2017 11:27:41 +0200
Subject: [PATCH 02/42] Update dependency nodebb-plugin-emoji-one@1.2.0

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index dff73ec5d5..e915c853f9 100644
--- a/package.json
+++ b/package.json
@@ -57,7 +57,7 @@
     "nodebb-plugin-composer-default": "4.4.8",
     "nodebb-plugin-dbsearch": "2.0.2",
     "nodebb-plugin-emoji-extended": "1.1.1",
-    "nodebb-plugin-emoji-one": "1.1.5",
+    "nodebb-plugin-emoji-one": "1.2.0",
     "nodebb-plugin-markdown": "7.1.1",
     "nodebb-plugin-mentions": "2.0.3",
     "nodebb-plugin-soundpack-default": "1.0.0",

From 91e5266776d0de75b960dd762611662b15fc383a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Thu, 18 May 2017 13:33:04 -0400
Subject: [PATCH 03/42] up emoji one

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index dff73ec5d5..e915c853f9 100644
--- a/package.json
+++ b/package.json
@@ -57,7 +57,7 @@
     "nodebb-plugin-composer-default": "4.4.8",
     "nodebb-plugin-dbsearch": "2.0.2",
     "nodebb-plugin-emoji-extended": "1.1.1",
-    "nodebb-plugin-emoji-one": "1.1.5",
+    "nodebb-plugin-emoji-one": "1.2.0",
     "nodebb-plugin-markdown": "7.1.1",
     "nodebb-plugin-mentions": "2.0.3",
     "nodebb-plugin-soundpack-default": "1.0.0",

From 4ab514a42267d283e49aeaa55cdd77bb05f2dea2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Thu, 18 May 2017 16:59:32 -0400
Subject: [PATCH 04/42] test for .delete with zset

---
 test/database/keys.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/test/database/keys.js b/test/database/keys.js
index 157cc2ca97..afbf3c947c 100644
--- a/test/database/keys.js
+++ b/test/database/keys.js
@@ -102,6 +102,37 @@ describe('Key methods', function () {
 		});
 	});
 
+	it('should delete all sorted set elements', function (done) {
+		async.parallel([
+			function (next) {
+				db.sortedSetAdd('deletezset', 1, 'value1', next);
+			},
+			function (next) {
+				db.sortedSetAdd('deletezset', 2, 'value2', next);
+			},
+		], function (err) {
+			if (err) {
+				return done(err);
+			}
+			db.delete('deletezset', function (err) {
+				assert.ifError(err);
+				async.parallel({
+					key1exists: function (next) {
+						db.isSortedSetMember('deletezset', 'value1', next);
+					},
+					key2exists: function (next) {
+						db.isSortedSetMember('deletezset', 'value2', next);
+					},
+				}, function (err, results) {
+					assert.equal(err, null);
+					assert.equal(results.key1exists, false);
+					assert.equal(results.key2exists, false);
+					done();
+				});
+			});
+		});
+	});
+
 	describe('increment', function () {
 		it('should initialize key to 1', function (done) {
 			db.increment('keyToIncrement', function (err, value) {

From e8caee3c4c46125b628563181145c9c1d25c07cb Mon Sep 17 00:00:00 2001
From: Peter Jaszkowiak <p.jaszkow@gmail.com>
Date: Thu, 18 May 2017 17:50:49 -0600
Subject: [PATCH 05/42] Restrict total threads

So machines with a small amount of cores build faster
---
 src/meta/build.js    |  3 +--
 src/meta/minifier.js | 20 +++++++++++---------
 2 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/src/meta/build.js b/src/meta/build.js
index e88bbb17e9..cc3321923f 100644
--- a/src/meta/build.js
+++ b/src/meta/build.js
@@ -2,7 +2,6 @@
 
 var async = require('async');
 var winston = require('winston');
-var os = require('os');
 var nconf = require('nconf');
 var padstart = require('lodash.padstart');
 
@@ -181,7 +180,7 @@ function build(targets, callback) {
 	async.series([
 		beforeBuild,
 		function (next) {
-			var parallel = os.cpus().length > 1 && !nconf.get('series');
+			var parallel = !nconf.get('series');
 			if (parallel) {
 				winston.info('[build] Building in parallel mode');
 			} else {
diff --git a/src/meta/minifier.js b/src/meta/minifier.js
index b1f2888b16..53ca9f5f28 100644
--- a/src/meta/minifier.js
+++ b/src/meta/minifier.js
@@ -5,6 +5,7 @@ var async = require('async');
 var fs = require('fs');
 var childProcess = require('child_process');
 var os = require('os');
+var winston = require('winston');
 var less = require('less');
 var postcss = require('postcss');
 var autoprefixer = require('autoprefixer');
@@ -39,6 +40,10 @@ function setupDebugging() {
 
 var children = [];
 
+Minifier.maxThreads = os.cpus().length - 1;
+
+winston.verbose('[minifier] utilizing a maximum of ' + Minifier.maxThreads + ' additional threads');
+
 Minifier.killAll = function () {
 	children.forEach(function (child) {
 		child.kill('SIGTERM');
@@ -65,13 +70,14 @@ function forkAction(action, callback) {
 	children.push(proc);
 
 	proc.on('message', function (message) {
+		proc.kill();
+		removeChild(proc);
+
 		if (message.type === 'error') {
-			proc.kill();
-			return callback(new Error(message.message));
+			return callback(message.err);
 		}
 
 		if (message.type === 'end') {
-			proc.kill();
 			callback(null, message.result);
 		}
 	});
@@ -85,10 +91,6 @@ function forkAction(action, callback) {
 		type: 'action',
 		action: action,
 	});
-
-	proc.on('close', function () {
-		removeChild(proc);
-	});
 }
 
 var actions = {};
@@ -109,7 +111,7 @@ if (process.env.minifier_child) {
 				if (err) {
 					process.send({
 						type: 'error',
-						message: err.message,
+						err: err,
 					});
 					return;
 				}
@@ -124,7 +126,7 @@ if (process.env.minifier_child) {
 }
 
 function executeAction(action, fork, callback) {
-	if (fork) {
+	if (fork && children.length < Minifier.maxThreads) {
 		forkAction(action, callback);
 	} else {
 		if (typeof actions[action.act] !== 'function') {

From 9f5ce24993ff6690191c1a2c015d5c0e024498a7 Mon Sep 17 00:00:00 2001
From: Peter Jaszkowiak <p.jaszkow@gmail.com>
Date: Thu, 18 May 2017 21:20:04 -0600
Subject: [PATCH 06/42] Minify modules in a batch

---
 src/meta/js.js       |  80 ++++++++++++++++++--------------
 src/meta/minifier.js | 107 +++++++++++++++++++++++++------------------
 2 files changed, 109 insertions(+), 78 deletions(-)

diff --git a/src/meta/js.js b/src/meta/js.js
index e7b22939fc..bfae9260c2 100644
--- a/src/meta/js.js
+++ b/src/meta/js.js
@@ -88,44 +88,56 @@ module.exports = function (Meta) {
 		},
 	};
 
+	function copyFile(source, target, cb) {
+		var called = false;
+
+		var rd = fs.createReadStream(source);
+		rd.on('error', done);
+
+		var wr = fs.createWriteStream(target);
+		wr.on('error', done);
+		wr.on('close', function () {
+			done();
+		});
+		rd.pipe(wr);
+
+		function done(err) {
+			if (!called) {
+				cb(err);
+				called = true;
+			}
+		}
+	}
+
 	function minifyModules(modules, fork, callback) {
-		// for it to never fork
-		// otherwise it spawns way too many processes
-		// maybe eventually we can pool modules
-		// and pass the pools to the minifer
-		// to reduce the total number of threads
-		fork = false;
+		async.eachLimit(modules, 1000, function (mod, next) {
+			mkdirp(path.dirname(mod.destPath), next);
+		}, function (err) {
+			if (err) {
+				return callback(err);
+			}
 
-		async.eachLimit(modules, 500, function (mod, next) {
-			var srcPath = mod.srcPath;
-			var destPath = mod.destPath;
-
-			async.parallel({
-				dirped: function (cb) {
-					mkdirp(path.dirname(destPath), cb);
-				},
-				minified: function (cb) {
-					fs.readFile(srcPath, function (err, buffer) {
-						if (err) {
-							return cb(err);
-						}
-
-						if (srcPath.endsWith('.min.js') || path.dirname(srcPath).endsWith('min')) {
-							return cb(null, { code: buffer.toString() });
-						}
-
-						minifier.js.minify(buffer.toString(), fork, cb);
-					});
-				},
-			}, function (err, results) {
-				if (err) {
-					return next(err);
+			var filtered = modules.reduce(function (prev, mod) {
+				if (mod.srcPath.endsWith('.min.js') || path.dirname(mod.srcPath).endsWith('min')) {
+					prev.skip.push(mod);
+				} else {
+					prev.minify.push(mod);
 				}
 
-				var minified = results.minified;
-				fs.writeFile(destPath, minified.code, next);
-			});
-		}, callback);
+				return prev;
+			}, { minify: [], skip: [] });
+
+			async.parallel([
+				function (cb) {
+					minifier.js.minifyBatch(filtered.minify, fork, cb);
+				},
+				function (cb) {
+					async.eachLimit(filtered.skip, 500, function (mod, next) {
+						copyFile(mod.srcPath, mod.destPath, next);
+					}, cb);
+				},
+			], callback);
+		});
 	}
 
 	function linkModules(callback) {
diff --git a/src/meta/minifier.js b/src/meta/minifier.js
index 53ca9f5f28..da7c570ce7 100644
--- a/src/meta/minifier.js
+++ b/src/meta/minifier.js
@@ -38,27 +38,26 @@ function setupDebugging() {
 	return forkProcessParams;
 }
 
-var children = [];
+var pool = [];
+var free = [];
 
 Minifier.maxThreads = os.cpus().length - 1;
 
 winston.verbose('[minifier] utilizing a maximum of ' + Minifier.maxThreads + ' additional threads');
 
 Minifier.killAll = function () {
-	children.forEach(function (child) {
+	pool.forEach(function (child) {
 		child.kill('SIGTERM');
 	});
 
-	children = [];
+	pool.length = 0;
 };
 
-function removeChild(proc) {
-	children = children.filter(function (child) {
-		return child !== proc;
-	});
-}
+function getChild() {
+	if (free.length) {
+		return free.shift();
+	}
 
-function forkAction(action, callback) {
 	var forkProcessParams = setupDebugging();
 	var proc = childProcess.fork(__filename, [], Object.assign({}, forkProcessParams, {
 		cwd: __dirname,
@@ -66,12 +65,26 @@ function forkAction(action, callback) {
 			minifier_child: true,
 		},
 	}));
+	pool.push(proc);
 
-	children.push(proc);
+	return proc;
+}
+
+function freeChild(proc) {
+	proc.removeAllListeners();
+	free.push(proc);
+}
+
+function removeChild(proc) {
+	var i = pool.indexOf(proc);
+	pool.splice(i, 1);
+}
+
+function forkAction(action, callback) {
+	var proc = getChild();
 
 	proc.on('message', function (message) {
-		proc.kill();
-		removeChild(proc);
+		freeChild(proc);
 
 		if (message.type === 'error') {
 			return callback(message.err);
@@ -102,7 +115,7 @@ if (process.env.minifier_child) {
 			if (typeof actions[action.act] !== 'function') {
 				process.send({
 					type: 'error',
-					message: 'Unknown action',
+					err: Error('Unknown action'),
 				});
 				return;
 			}
@@ -126,7 +139,7 @@ if (process.env.minifier_child) {
 }
 
 function executeAction(action, fork, callback) {
-	if (fork && children.length < Minifier.maxThreads) {
+	if (fork && (pool.length - free.length) < Minifier.maxThreads) {
 		forkAction(action, callback);
 	} else {
 		if (typeof actions[action.act] !== 'function') {
@@ -155,32 +168,38 @@ function concat(data, callback) {
 actions.concat = concat;
 
 function minifyJS(data, callback) {
-	var minified;
+	if (data.batch) {
+		async.eachLimit(data.files, 1000, function (ref, next) {
+			var srcPath = ref.srcPath;
+			var destPath = ref.destPath;
 
-	if (data.fromSource) {
-		var sources = data.source;
-		var multiple = Array.isArray(sources);
-		if (!multiple) {
-			sources = [sources];
-		}
+			fs.readFile(srcPath, function (err, buffer) {
+				if (err && err.code === 'ENOENT') {
+					return next(null, null);
+				}
+				if (err) {
+					return next(err);
+				}
 
-		try {
-			minified = sources.map(function (source) {
-				return uglifyjs.minify(source, {
-					// outSourceMap: data.filename + '.map',
-					compress: data.compress,
-					fromString: true,
-					output: {
-						// suppress uglify line length warnings
-						max_line_len: 400000,
-					},
-				});
+				try {
+					var minified = uglifyjs.minify(buffer.toString(), {
+						// outSourceMap: data.filename + '.map',
+						compress: data.compress,
+						fromString: true,
+						output: {
+							// suppress uglify line length warnings
+							max_line_len: 400000,
+						},
+					});
+
+					fs.writeFile(destPath, minified.code, next);
+				} catch (e) {
+					next(e);
+				}
 			});
-		} catch (e) {
-			return callback(e);
-		}
+		}, callback);
 
-		return callback(null, multiple ? minified : minified[0]);
+		return;
 	}
 
 	if (data.files && data.files.length) {
@@ -190,16 +209,16 @@ function minifyJS(data, callback) {
 			}
 
 			try {
-				minified = uglifyjs.minify(scripts, {
+				var minified = uglifyjs.minify(scripts, {
 					// outSourceMap: data.filename + '.map',
 					compress: data.compress,
 					fromString: false,
 				});
-			} catch (e) {
-				return callback(e);
-			}
 
-			callback(null, minified);
+				callback(null, minified);
+			} catch (e) {
+				callback(e);
+			}
 		});
 
 		return;
@@ -218,11 +237,11 @@ Minifier.js.bundle = function (scripts, minify, fork, callback) {
 	}, fork, callback);
 };
 
-Minifier.js.minify = function (source, fork, callback) {
+Minifier.js.minifyBatch = function (scripts, fork, callback) {
 	executeAction({
 		act: 'minifyJS',
-		fromSource: true,
-		source: source,
+		files: scripts,
+		batch: true,
 	}, fork, callback);
 };
 

From b888ed8e1aeb29fc20d62dba378388f277b5bd10 Mon Sep 17 00:00:00 2001
From: Ole R <frissdiegurke@protonmail.com>
Date: Fri, 19 May 2017 11:07:37 +0200
Subject: [PATCH 07/42] Update package.json

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index e915c853f9..ec678b10a5 100644
--- a/package.json
+++ b/package.json
@@ -57,7 +57,7 @@
     "nodebb-plugin-composer-default": "4.4.8",
     "nodebb-plugin-dbsearch": "2.0.2",
     "nodebb-plugin-emoji-extended": "1.1.1",
-    "nodebb-plugin-emoji-one": "1.2.0",
+    "nodebb-plugin-emoji-one": "1.2.1",
     "nodebb-plugin-markdown": "7.1.1",
     "nodebb-plugin-mentions": "2.0.3",
     "nodebb-plugin-soundpack-default": "1.0.0",

From 4fadbcbbc88ad6bc53a97ccd8a710be70bf04572 Mon Sep 17 00:00:00 2001
From: "Misty (Bot)" <deploy@nodebb.org>
Date: Fri, 19 May 2017 09:23:36 +0000
Subject: [PATCH 08/42] Latest translations and fallbacks

---
 .../language/tr/admin/advanced/database.json  |  8 +++----
 public/language/tr/admin/advanced/events.json |  2 +-
 .../language/tr/admin/general/dashboard.json  | 22 +++++++++----------
 .../language/tr/admin/general/homepage.json   |  6 ++---
 .../language/tr/admin/settings/uploads.json   | 12 +++++-----
 public/language/tr/error.json                 |  4 ++--
 6 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/public/language/tr/admin/advanced/database.json b/public/language/tr/admin/advanced/database.json
index 25989418d7..39fccc540c 100644
--- a/public/language/tr/admin/advanced/database.json
+++ b/public/language/tr/admin/advanced/database.json
@@ -8,13 +8,13 @@
 	"mongo": "Mongo",
 	"mongo.version": "MongoDB Sürümü",
 	"mongo.storage-engine": "Storage Engine",
-	"mongo.collections": "Collections",
-	"mongo.objects": "Objects",
+	"mongo.collections": "Koleksiyonlar",
+	"mongo.objects": "Objeler",
 	"mongo.avg-object-size": "Avg. Object Size",
 	"mongo.data-size": "Veri Boyutu",
 	"mongo.storage-size": "Storage Size",
-	"mongo.index-size": "Index Size",
-	"mongo.file-size": "File Size",
+	"mongo.index-size": "İndex Boyutu",
+	"mongo.file-size": "Dosya Boyutu",
 	"mongo.resident-memory": "Resident Memory",
 	"mongo.virtual-memory": "Virtual Memory",
 	"mongo.mapped-memory": "Mapped Memory",
diff --git a/public/language/tr/admin/advanced/events.json b/public/language/tr/admin/advanced/events.json
index 5bac444857..bca47b6a68 100644
--- a/public/language/tr/admin/advanced/events.json
+++ b/public/language/tr/admin/advanced/events.json
@@ -1,6 +1,6 @@
 {
 	"events": "Olaylar",
 	"no-events": "Olay yok",
-	"control-panel": "Events Control Panel",
+	"control-panel": "Etkinlik Kontrol Paneli",
 	"delete-events": "Olayları Sil"
 }
\ No newline at end of file
diff --git a/public/language/tr/admin/general/dashboard.json b/public/language/tr/admin/general/dashboard.json
index 81f4fd76c6..e1145a6e63 100644
--- a/public/language/tr/admin/general/dashboard.json
+++ b/public/language/tr/admin/general/dashboard.json
@@ -5,14 +5,14 @@
 	"users": "Kullanıcılar",
 	"posts": "İletiler",
 	"topics": "Başlıklar",
-	"page-views-seven": "Last 7 Days",
-	"page-views-thirty": "Last 30 Days",
-	"page-views-last-day": "Last 24 hours",
-	"page-views-custom": "Custom Date Range",
-	"page-views-custom-start": "Range Start",
-	"page-views-custom-end": "Range End",
+	"page-views-seven": "Son 7 Gün",
+	"page-views-thirty": "Son 30 Gün",
+	"page-views-last-day": "Son 24 saat",
+	"page-views-custom": "Özel Tarih Aralığı",
+	"page-views-custom-start": "Başlangıç",
+	"page-views-custom-end": "Son",
 	"page-views-custom-help": "Enter a date range of page views you would like to view. If no date picker is available, the accepted format is <code>YYYY-MM-DD</code>",
-	"page-views-custom-error": "Please enter a valid date range in the format <code>YYYY-MM-DD</code>",
+	"page-views-custom-error": "Lütfen tarih aralığını geçerli formatta girin <code>YYYY-MM-DD</code>",
 
 	"stats.day": "Gün",
 	"stats.week": "Hafta",
@@ -36,9 +36,9 @@
 	"search-plugin-tooltip": "Install a search plugin from the plugin page in order to activate search functionality",
 
 	"control-panel": "Sistem Kontrol",
-	"reload": "Tekrar Yükle",
-	"restart": "Yeniden Başlat",
-	"restart-warning": "Reloading or Restarting your NodeBB will drop all existing connections for a few seconds.",
+	"reload": "Reload",
+	"restart": "Restart",
+	"restart-warning": "NodeBB yeniden yüklemek veya yeniden başlatmak için mevcut tüm bağlantıları birkaç saniye düşürür.",
 	"maintenance-mode": "Bakım Modu",
 	"maintenance-mode-title": "NodeBB için bakım modunu ayarlamak için buraya tıklayın",
 	"realtime-chart-updates": "Gerçek Zamanlı Grafik Güncellemeleri",
@@ -60,7 +60,7 @@
 	"recent": "Yeni",
 	"unread": "Okunmamış",
 
-	"high-presence-topics": "High Presence Topics",
+	"high-presence-topics": "Öne Çıkan Başlıklar",
 
 	"graphs.page-views": "Sayfa Gösterimi",
 	"graphs.unique-visitors": "Benzersiz Ziyaretçiler",
diff --git a/public/language/tr/admin/general/homepage.json b/public/language/tr/admin/general/homepage.json
index e38827a2b3..abca35b9e1 100644
--- a/public/language/tr/admin/general/homepage.json
+++ b/public/language/tr/admin/general/homepage.json
@@ -1,7 +1,7 @@
 {
 	"home-page": "Ana Sayfa",
 	"description": "Choose what page is shown when users navigate to the root URL of your forum.",
-	"home-page-route": "Home Page Route",
-	"custom-route": "Custom Route",
-	"allow-user-home-pages": "Allow User Home Pages"
+	"home-page-route": "Anasayfa Yolu",
+	"custom-route": "Özel Yol",
+	"allow-user-home-pages": "Kullanıcılara anasayfayı özelleştirmeye izin ver"
 }
\ No newline at end of file
diff --git a/public/language/tr/admin/settings/uploads.json b/public/language/tr/admin/settings/uploads.json
index 4daa55400b..b260563c77 100644
--- a/public/language/tr/admin/settings/uploads.json
+++ b/public/language/tr/admin/settings/uploads.json
@@ -8,19 +8,19 @@
 	"max-file-size-help": "(in kilobytes, default: 2048 KiB)",
 	"allow-topic-thumbnails": "Allow users to upload topic thumbnails",
 	"topic-thumb-size": "Topic Thumb Size",
-	"allowed-file-extensions": "Allowed File Extensions",
+	"allowed-file-extensions": "İzin Verilen Dosya Uzantıları",
 	"allowed-file-extensions-help": "Enter comma-separated list of file extensions here (e.g. <code>pdf,xls,doc</code>). An empty list means all extensions are allowed.",
-	"profile-avatars": "Profile Avatars",
+	"profile-avatars": "Profil Avatarları",
 	"allow-profile-image-uploads": "Allow users to upload profile images",
 	"convert-profile-image-png": "Convert profile image uploads to PNG",
 	"default-avatar": "Custom Default Avatar",
 	"upload": "Yükle",
-	"profile-image-dimension": "Profile Image Dimension",
-	"profile-image-dimension-help": "(in pixels, default: 128 pixels)",
+	"profile-image-dimension": "Profil Resmi Boyutu",
+	"profile-image-dimension-help": "(Piksel cinsinden, varsayılan: 128 piksel)",
 	"max-profile-image-size": "Maximum Profile Image File Size",
-	"max-profile-image-size-help": "(in kilobytes, default: 256 KiB)",
+	"max-profile-image-size-help": "(Kilobayt, varsayılan: 256 KiB)",
 	"max-cover-image-size": "Maksimum Kapak Görseli Dosya Boyutu",
-	"max-cover-image-size-help": "(in kilobytes, default: 2,048 KiB)",
+	"max-cover-image-size-help": "(Kilobayt, varsayılan: 2,048 KiB)",
 	"keep-all-user-images": "Keep old versions of avatars and profile covers on the server",
 	"profile-covers": "Profil Kapakları",
 	"default-covers": "Varsayılan Kapak Görseli",
diff --git a/public/language/tr/error.json b/public/language/tr/error.json
index 16c3a33815..f52f4aa8ea 100644
--- a/public/language/tr/error.json
+++ b/public/language/tr/error.json
@@ -30,7 +30,7 @@
     "password-too-long": "Parola çok uzun",
     "user-banned": "Kullanıcı Yasaklı",
     "user-banned-reason": "Maalesef, bu hesap yasaklandı (Sebep:% 1)",
-    "user-banned-reason-until": "Sorry, this account has been banned until %1 (Reason: %2)",
+    "user-banned-reason-until": "Maalesef, bu hesap %1 kadar yasaklandı (Sebep:  %2)",
     "user-too-new": "Özür dileriz, ilk iletinizi yapmadan önce %1 saniye beklemeniz gerekiyor",
     "blacklisted-ip": "Üzgünüz, IP adresiniz, bu toplulukta yasaklandı. Bunun bir hata olduğunu düşünüyorsanız, bir yönetici ile irtibata geçiniz.",
     "ban-expiry-missing": "Bu yasak için bir bitiş tarihi girin",
@@ -105,7 +105,7 @@
     "chat-disabled": "Sohbet özelliği kapalı",
     "too-many-messages": "Ardı ardına çok fazla mesaj yolladınız, lütfen biraz bekleyiniz.",
     "invalid-chat-message": "Geçersiz sohbet mesajı",
-    "chat-message-too-long": "Chat messages can not be longer than %1 characters.",
+    "chat-message-too-long": "Sohbet mesajı %1 karakterden daha uzun olamaz.",
     "cant-edit-chat-message": "Bu mesajı düzenlemek için izin verilmez",
     "cant-remove-last-user": "Son kullanıcıyı silemezsiniz",
     "cant-delete-chat-message": "Bu mesajı silmek için izin verilmez",

From 95196ceedcc1c05de17a0d41590b3c7beda0f7af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Fri, 19 May 2017 14:52:36 -0400
Subject: [PATCH 09/42] closes #5692

---
 src/database/redis/sorted.js | 8 +++++++-
 src/user/bans.js             | 2 +-
 test/database/hash.js        | 9 +++++++++
 test/database/sorted.js      | 2 ++
 4 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/src/database/redis/sorted.js b/src/database/redis/sorted.js
index 9bb004550a..282928da97 100644
--- a/src/database/redis/sorted.js
+++ b/src/database/redis/sorted.js
@@ -129,7 +129,13 @@ module.exports = function (redisClient, module) {
 		}
 
 		redisClient.zscore(key, value, function (err, score) {
-			callback(err, !err ? parseFloat(score) : null);
+			if (err) {
+				return callback(err);
+			}
+			if (score === null) {
+				return callback(null, score);
+			}
+			callback(null, parseFloat(score));
 		});
 	};
 
diff --git a/src/user/bans.js b/src/user/bans.js
index ad51c7c07c..e2cf2193b3 100644
--- a/src/user/bans.js
+++ b/src/user/bans.js
@@ -61,7 +61,7 @@ module.exports = function (User) {
 		async.waterfall([
 			async.apply(User.getUserFields, uid, ['banned', 'banned:expire']),
 			function (userData, next) {
-				var banned = parseInt(userData.banned, 10) === 1;
+				var banned = userData && parseInt(userData.banned, 10) === 1;
 				if (!banned) {
 					return next(null, banned);
 				}
diff --git a/test/database/hash.js b/test/database/hash.js
index 7f9dc305d0..cffa761229 100644
--- a/test/database/hash.js
+++ b/test/database/hash.js
@@ -190,6 +190,15 @@ describe('Hash methods', function () {
 				done();
 			});
 		});
+
+		it('should return undefined for all fields if object does not exist', function (done) {
+			db.getObjectsFields(['doesnotexist1', 'doesnotexist2'], ['name', 'age'], function (err, data) {
+				assert.ifError(err);
+				assert.equal(data.name, null);
+				assert.equal(data.age, null);
+				done();
+			});
+		});
 	});
 
 	describe('getObjectKeys()', function () {
diff --git a/test/database/sorted.js b/test/database/sorted.js
index b90e9cf71f..9e0178d4ed 100644
--- a/test/database/sorted.js
+++ b/test/database/sorted.js
@@ -303,6 +303,7 @@ describe('Sorted Set methods', function () {
 				assert.equal(err, null);
 				assert.equal(arguments.length, 2);
 				assert.equal(!!score, false);
+				assert.strictEqual(score, null);
 				done();
 			});
 		});
@@ -312,6 +313,7 @@ describe('Sorted Set methods', function () {
 				assert.equal(err, null);
 				assert.equal(arguments.length, 2);
 				assert.equal(!!score, false);
+				assert.strictEqual(score, null);
 				done();
 			});
 		});

From fd47e230573dee60ecc6bce43acc4fbb4a32ce3e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Fri, 19 May 2017 16:18:18 -0400
Subject: [PATCH 10/42] test login for non-existant user

---
 test/authentication.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/test/authentication.js b/test/authentication.js
index 7b49f69efa..6691a96c66 100644
--- a/test/authentication.js
+++ b/test/authentication.js
@@ -147,6 +147,33 @@ describe('authentication', function () {
 		});
 	});
 
+	it('should fail to login if user does not exist', function (done) {
+		var jar = request.jar();
+		request({
+			url: nconf.get('url') + '/api/config',
+			json: true,
+			jar: jar,
+		}, function (err, response, body) {
+			assert.ifError(err);
+
+			request.post(nconf.get('url') + '/login', {
+				form: {
+					username: 'doesnotexist',
+					password: 'nopassword',
+				},
+				json: true,
+				jar: jar,
+				headers: {
+					'x-csrf-token': body.csrf_token,
+				},
+			}, function (err, response, body) {
+				assert.equal(response.statusCode, 403);
+				assert.equal(body, '[[error:invalid-login-credentials]]');
+				done();
+			});
+		});
+	});
+
 
 	after(function (done) {
 		db.emptydb(done);

From 4c1e25c8ce752bc3130b0ac83c849e568d070cd4 Mon Sep 17 00:00:00 2001
From: Peter Jaszkowiak <p.jaszkow@gmail.com>
Date: Fri, 19 May 2017 14:27:52 -0600
Subject: [PATCH 11/42] Link instead of copying files

Only mkdirp the necessary directories
---
 src/meta/js.js | 35 ++++++++++-------------------------
 1 file changed, 10 insertions(+), 25 deletions(-)

diff --git a/src/meta/js.js b/src/meta/js.js
index bfae9260c2..d0399c70c1 100644
--- a/src/meta/js.js
+++ b/src/meta/js.js
@@ -88,31 +88,16 @@ module.exports = function (Meta) {
 		},
 	};
 
-	function copyFile(source, target, cb) {
-		var called = false;
-
-		var rd = fs.createReadStream(source);
-		rd.on('error', done);
-
-		var wr = fs.createWriteStream(target);
-		wr.on('error', done);
-		wr.on('close', function () {
-			done();
-		});
-		rd.pipe(wr);
-
-		function done(err) {
-			if (!called) {
-				cb(err);
-				called = true;
-			}
-		}
-	}
-
 	function minifyModules(modules, fork, callback) {
-		async.eachLimit(modules, 1000, function (mod, next) {
-			mkdirp(path.dirname(mod.destPath), next);
-		}, function (err) {
+		var moduleDirs = modules.reduce(function (prev, mod) {
+			var dir = path.resolve(path.dirname(mod.destPath));
+			if (prev.indexOf(dir) === -1) {
+				prev.push(dir);
+			}
+			return prev;
+		}, []);
+
+		async.eachLimit(moduleDirs, 1000, mkdirp, function (err) {
 			if (err) {
 				return callback(err);
 			}
@@ -133,7 +118,7 @@ module.exports = function (Meta) {
 				},
 				function (cb) {
 					async.eachLimit(filtered.skip, 500, function (mod, next) {
-						copyFile(mod.srcPath, mod.destPath, next);
+						file.link(mod.srcPath, mod.destPath, next);
 					}, cb);
 				},
 			], callback);

From 8f8e7202e5fef92d0f982f7aa78306c1c564e62c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Fri, 19 May 2017 16:33:40 -0400
Subject: [PATCH 12/42] fix lint

---
 test/authentication.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/authentication.js b/test/authentication.js
index 6691a96c66..9d49a8e0ff 100644
--- a/test/authentication.js
+++ b/test/authentication.js
@@ -167,6 +167,7 @@ describe('authentication', function () {
 					'x-csrf-token': body.csrf_token,
 				},
 			}, function (err, response, body) {
+				assert.ifError(err);
 				assert.equal(response.statusCode, 403);
 				assert.equal(body, '[[error:invalid-login-credentials]]');
 				done();

From 29ca1dbf0883fc6158132075696498d91deb5ffe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Fri, 19 May 2017 17:14:46 -0400
Subject: [PATCH 13/42] replies/reply fix

---
 public/language/en-GB/topic.json   |  1 +
 public/src/client/topic/replies.js | 15 ++++++-
 src/topics/posts.js                | 72 +++++++++++++++++-------------
 3 files changed, 54 insertions(+), 34 deletions(-)

diff --git a/public/language/en-GB/topic.json b/public/language/en-GB/topic.json
index b960fb0fba..727417ca5f 100644
--- a/public/language/en-GB/topic.json
+++ b/public/language/en-GB/topic.json
@@ -17,6 +17,7 @@
 	"quote": "Quote",
 	"reply": "Reply",
 	"replies_to_this_post": "%1 Replies",
+	"one_reply_to_this_post": "1 Reply",
 	"last_reply_time": "Last reply",
 	"reply-as-topic": "Reply as topic",
 	"guest-login-reply": "Log in to reply",
diff --git a/public/src/client/topic/replies.js b/public/src/client/topic/replies.js
index 7d9b9474bc..37ddd1912b 100644
--- a/public/src/client/topic/replies.js
+++ b/public/src/client/topic/replies.js
@@ -89,8 +89,19 @@ define('forum/topic/replies', ['navigator', 'components', 'forum/topic/posts'],
 		var timestamp = replyCount.find('.timeago').attr('title', post.timestampISO);
 
 		countEl.attr('data-replies', count);
-		replyCount.toggleClass('hidden', !count);
-		countEl.translateText('[[topic:replies_to_this_post, ' + count + ']]');
+		replyCount.toggleClass('hidden', count <= 0);
+		if (count > 1) {
+			countEl.translateText('[[topic:replies_to_this_post, ' + count + ']]');
+		} else {
+			countEl.translateText('[[topic:one_reply_to_this_post]]');
+		}
+
+		if (!avatars.find('[data-uid="' + post.uid + '"]').length && count < 7) {
+			app.parseAndTranslate('topic', 'posts', { posts: [{ replies: { users: [post.user] } }] }, function (html) {
+				avatars.prepend(html.find('[component="post/reply-count/avatars"] [component="user/picture"]'));
+			});
+		}
+
 		avatars.addClass('hasMore');
 
 		timestamp.data('timeago', null).timeago();
diff --git a/src/topics/posts.js b/src/topics/posts.js
index ce2b6dd457..3ed8deafc7 100644
--- a/src/topics/posts.js
+++ b/src/topics/posts.js
@@ -392,30 +392,36 @@ module.exports = function (Topics) {
 
 	function getPostReplies(pids, callerUid, callback) {
 		async.map(pids, function (pid, next) {
-			db.getSortedSetRange('pid:' + pid + ':replies', 0, -1, function (err, replyPids) {
-				if (err) {
-					return next(err);
-				}
+			var replyPids;
+			var uids = [];
+			async.waterfall([
+				function (next) {
+					db.getSortedSetRange('pid:' + pid + ':replies', 0, -1, next);
+				},
+				function (_replyPids, next) {
+					replyPids = _replyPids;
 
-				var uids = [];
-				var count = 0;
-
-				async.until(function () {
-					return count === replyPids.length || uids.length === 6;
-				}, function (next) {
-					posts.getPostField(replyPids[count], 'uid', function (err, uid) {
-						uid = parseInt(uid, 10);
-						if (uids.indexOf(uid) === -1) {
-							uids.push(uid);
-						}
-						count += 1;
-						next(err);
-					});
-				}, function (err) {
-					if (err) {
-						return next(err);
-					}
+					var count = 0;
 
+					async.until(function () {
+						return count === replyPids.length || uids.length === 6;
+					}, function (next) {
+						async.waterfall([
+							function (next) {
+								posts.getPostField(replyPids[count], 'uid', next);
+							},
+							function (uid, next) {
+								uid = parseInt(uid, 10);
+								if (uids.indexOf(uid) === -1) {
+									uids.push(uid);
+								}
+								count += 1;
+								next();
+							},
+						], next);
+					}, next);
+				},
+				function (next) {
 					async.parallel({
 						users: function (next) {
 							user.getUsersWithFields(uids, ['uid', 'username', 'userslug', 'picture'], callerUid, next);
@@ -425,17 +431,19 @@ module.exports = function (Topics) {
 								next(err, utils.toISOString(timestamp));
 							});
 						},
-					}, function (err, replies) {
-						if (replies.users.length > 5) {
-							replies.users.shift();
-							replies.hasMore = true;
-						}
+					}, next);
+				},
+				function (replies, next) {
+					if (replies.users.length > 5) {
+						replies.users.shift();
+						replies.hasMore = true;
+					}
 
-						replies.count = replyPids.length;
-						next(err, replies);
-					});
-				});
-			});
+					replies.count = replyPids.length;
+					replies.text = replies.count > 1 ? '[[topic:replies_to_this_post, ' + replies.count + ']]' : '[[topic:one_reply_to_this_post]]';
+					next(null, replies);
+				},
+			], next);
 		}, callback);
 	}
 };

From b1fe0c8f5f26c7f123abdfb01272438f2a99ac3a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Fri, 19 May 2017 18:49:34 -0400
Subject: [PATCH 14/42] up persona

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 4be80a1ce1..7d7bacd4d9 100644
--- a/package.json
+++ b/package.json
@@ -65,7 +65,7 @@
     "nodebb-plugin-spam-be-gone": "0.5.0",
     "nodebb-rewards-essentials": "0.0.9",
     "nodebb-theme-lavender": "4.0.0",
-    "nodebb-theme-persona": "5.0.0",
+    "nodebb-theme-persona": "5.0.1",
     "nodebb-theme-vanilla": "6.0.2",
     "nodebb-widget-essentials": "3.0.0",
     "nodemailer": "2.6.4",

From b3a265f981ecf720255294596b3a8ba84caacfc3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Fri, 19 May 2017 18:50:19 -0400
Subject: [PATCH 15/42] closes #5694

---
 src/topics/unread.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/topics/unread.js b/src/topics/unread.js
index ac26a277f9..f76206628f 100644
--- a/src/topics/unread.js
+++ b/src/topics/unread.js
@@ -267,6 +267,7 @@ module.exports = function (Topics) {
 				categories.markAsRead(cids, uid, next);
 			},
 			function (next) {
+				plugins.fireHook('action:topics.markAsRead', { uid: uid, tids: tids });
 				next(null, true);
 			},
 		], callback);

From 77894915eb01871844980c31f4aacd12ff322fa3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Fri, 19 May 2017 19:35:10 -0400
Subject: [PATCH 16/42] closes #5684

---
 src/controllers/topics.js              |  2 +-
 src/socket.io/topics/infinitescroll.js |  2 +-
 test/topics.js                         | 20 ++++++++++----------
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/controllers/topics.js b/src/controllers/topics.js
index ddd6fd889a..5c592f5bb3 100644
--- a/src/controllers/topics.js
+++ b/src/controllers/topics.js
@@ -49,7 +49,7 @@ topicsController.get = function (req, res, callback) {
 
 			userPrivileges = results.privileges;
 
-			if (!userPrivileges.read || !userPrivileges['topics:read'] || (parseInt(results.topic.deleted, 10) && !userPrivileges.view_deleted)) {
+			if (!userPrivileges['topics:read'] || (parseInt(results.topic.deleted, 10) && !userPrivileges.view_deleted)) {
 				return helpers.notAllowed(req, res);
 			}
 
diff --git a/src/socket.io/topics/infinitescroll.js b/src/socket.io/topics/infinitescroll.js
index 1d732de2a4..17d44712ea 100644
--- a/src/socket.io/topics/infinitescroll.js
+++ b/src/socket.io/topics/infinitescroll.js
@@ -27,7 +27,7 @@ module.exports = function (SocketTopics) {
 				}, next);
 			},
 			function (results, next) {
-				if (!results.privileges.read || (parseInt(results.topic.deleted, 10) && !results.privileges.view_deleted)) {
+				if (!results.privileges['topics:read'] || (parseInt(results.topic.deleted, 10) && !results.privileges.view_deleted)) {
 					return callback(new Error('[[error:no-privileges]]'));
 				}
 
diff --git a/test/topics.js b/test/topics.js
index c362ca0824..4551595fa6 100644
--- a/test/topics.js
+++ b/test/topics.js
@@ -760,13 +760,13 @@ describe('Topic\'s', function () {
 
 		it('should 401 if not allowed to read as guest', function (done) {
 			var privileges = require('../src/privileges');
-			privileges.categories.rescind(['read'], topicData.cid, 'guests', function (err) {
+			privileges.categories.rescind(['topics:read'], topicData.cid, 'guests', function (err) {
 				assert.ifError(err);
 				request(nconf.get('url') + '/api/topic/' + topicData.slug, function (err, response, body) {
 					assert.ifError(err);
 					assert.equal(response.statusCode, 401);
 					assert(body);
-					privileges.categories.give(['read'], topicData.cid, 'guests', done);
+					privileges.categories.give(['topics:read'], topicData.cid, 'guests', done);
 				});
 			});
 		});
@@ -1551,7 +1551,7 @@ describe('Topic\'s', function () {
 
 
 		it('should return empty array if first param is empty', function (done) {
-			topics.getTeasers([], function (err, teasers) {
+			topics.getTeasers([], 1, function (err, teasers) {
 				assert.ifError(err);
 				assert.equal(0, teasers.length);
 				done();
@@ -1559,7 +1559,7 @@ describe('Topic\'s', function () {
 		});
 
 		it('should get teasers with 2 params', function (done) {
-			topics.getTeasers([topic1.topicData, topic2.topicData], function (err, teasers) {
+			topics.getTeasers([topic1.topicData, topic2.topicData], 1, function (err, teasers) {
 				assert.ifError(err);
 				assert.deepEqual([undefined, undefined], teasers);
 				done();
@@ -1568,7 +1568,7 @@ describe('Topic\'s', function () {
 
 		it('should get teasers with first posts', function (done) {
 			meta.config.teaserPost = 'first';
-			topics.getTeasers([topic1.topicData, topic2.topicData], function (err, teasers) {
+			topics.getTeasers([topic1.topicData, topic2.topicData], 1, function (err, teasers) {
 				assert.ifError(err);
 				assert.equal(2, teasers.length);
 				assert(teasers[0]);
@@ -1581,7 +1581,7 @@ describe('Topic\'s', function () {
 		});
 
 		it('should get teasers even if one topic is falsy', function (done) {
-			topics.getTeasers([null, topic2.topicData], function (err, teasers) {
+			topics.getTeasers([null, topic2.topicData], 1, function (err, teasers) {
 				assert.ifError(err);
 				assert.equal(2, teasers.length);
 				assert.equal(undefined, teasers[0]);
@@ -1598,7 +1598,7 @@ describe('Topic\'s', function () {
 			topics.reply({ uid: adminUid, content: 'reply 1 content', tid: topic1.topicData.tid }, function (err, result) {
 				assert.ifError(err);
 				topic1.topicData.teaserPid = result.pid;
-				topics.getTeasers([topic1.topicData, topic2.topicData], function (err, teasers) {
+				topics.getTeasers([topic1.topicData, topic2.topicData], 1, function (err, teasers) {
 					assert.ifError(err);
 					assert(teasers[0]);
 					assert(teasers[1]);
@@ -1610,7 +1610,7 @@ describe('Topic\'s', function () {
 		});
 
 		it('should get teasers by tids', function (done) {
-			topics.getTeasersByTids([topic2.topicData.tid, topic1.topicData.tid], function (err, teasers) {
+			topics.getTeasersByTids([topic2.topicData.tid, topic1.topicData.tid], 1, function (err, teasers) {
 				assert.ifError(err);
 				assert(2, teasers.length);
 				assert.equal(teasers[1].content, 'reply 1 content');
@@ -1619,7 +1619,7 @@ describe('Topic\'s', function () {
 		});
 
 		it('should return empty array ', function (done) {
-			topics.getTeasersByTids([], function (err, teasers) {
+			topics.getTeasersByTids([], 1, function (err, teasers) {
 				assert.ifError(err);
 				assert.equal(0, teasers.length);
 				done();
@@ -1627,7 +1627,7 @@ describe('Topic\'s', function () {
 		});
 
 		it('should get teaser by tid', function (done) {
-			topics.getTeaser(topic2.topicData.tid, function (err, teaser) {
+			topics.getTeaser(topic2.topicData.tid, 1, function (err, teaser) {
 				assert.ifError(err);
 				assert(teaser);
 				assert.equal(teaser.content, 'content 2');

From fd0043f36a8916c59ea6b2d8f9424bea71f70e2f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Fri, 19 May 2017 20:24:54 -0400
Subject: [PATCH 17/42] more tests

---
 src/database/mongo.js      | 128 ++++++++++++++++++++-----------------
 src/database/redis.js      |  81 ++++++++++++-----------
 test/database.js           |  43 +++++++++++--
 test/database/list.js      |  45 ++++++++++++-
 test/mocks/databasemock.js |   7 ++
 5 files changed, 201 insertions(+), 103 deletions(-)

diff --git a/src/database/mongo.js b/src/database/mongo.js
index fc37c7ae74..507a9c9a86 100644
--- a/src/database/mongo.js
+++ b/src/database/mongo.js
@@ -161,8 +161,11 @@ mongoModule.createIndices = function (callback) {
 
 mongoModule.checkCompatibility = function (callback) {
 	var mongoPkg = require('mongodb/package.json');
+	mongoModule.checkCompatibilityVersion(mongoPkg.version, callback);
+};
 
-	if (semver.lt(mongoPkg.version, '2.0.0')) {
+mongoModule.checkCompatibilityVersion = function (version, callback) {
+	if (semver.lt(version, '2.0.0')) {
 		return callback(new Error('The `mongodb` package is out-of-date, please run `./nodebb setup` again.'));
 	}
 
@@ -173,66 +176,75 @@ mongoModule.info = function (db, callback) {
 	if (!db) {
 		return callback();
 	}
-	async.parallel({
-		serverStatus: function (next) {
-			db.command({ serverStatus: 1 }, next);
+	async.waterfall([
+		function (next) {
+			async.parallel({
+				serverStatus: function (next) {
+					db.command({ serverStatus: 1 }, next);
+				},
+				stats: function (next) {
+					db.command({ dbStats: 1 }, next);
+				},
+				listCollections: function (next) {
+					getCollectionStats(db, next);
+				},
+			}, next);
 		},
-		stats: function (next) {
-			db.command({ dbStats: 1 }, next);
-		},
-		listCollections: function (next) {
-			db.listCollections().toArray(function (err, items) {
-				if (err) {
-					return next(err);
-				}
-				async.map(items, function (collection, next) {
-					db.collection(collection.name).stats(next);
-				}, next);
+		function (results, next) {
+			var stats = results.stats;
+			var scale = 1024 * 1024 * 1024;
+
+			results.listCollections = results.listCollections.map(function (collectionInfo) {
+				return {
+					name: collectionInfo.ns,
+					count: collectionInfo.count,
+					size: collectionInfo.size,
+					avgObjSize: collectionInfo.avgObjSize,
+					storageSize: collectionInfo.storageSize,
+					totalIndexSize: collectionInfo.totalIndexSize,
+					indexSizes: collectionInfo.indexSizes,
+				};
 			});
+
+			stats.mem = results.serverStatus.mem;
+			stats.mem = results.serverStatus.mem;
+			stats.mem.resident = (stats.mem.resident / 1024).toFixed(2);
+			stats.mem.virtual = (stats.mem.virtual / 1024).toFixed(2);
+			stats.mem.mapped = (stats.mem.mapped / 1024).toFixed(2);
+			stats.collectionData = results.listCollections;
+			stats.network = results.serverStatus.network;
+			stats.raw = JSON.stringify(stats, null, 4);
+
+			stats.avgObjSize = stats.avgObjSize.toFixed(2);
+			stats.dataSize = (stats.dataSize / scale).toFixed(2);
+			stats.storageSize = (stats.storageSize / scale).toFixed(2);
+			stats.fileSize = stats.fileSize ? (stats.fileSize / scale).toFixed(2) : 0;
+			stats.indexSize = (stats.indexSize / scale).toFixed(2);
+			stats.storageEngine = results.serverStatus.storageEngine ? results.serverStatus.storageEngine.name : 'mmapv1';
+			stats.host = results.serverStatus.host;
+			stats.version = results.serverStatus.version;
+			stats.uptime = results.serverStatus.uptime;
+			stats.mongo = true;
+
+			next(null, stats);
 		},
-	}, function (err, results) {
-		if (err) {
-			return callback(err);
-		}
-		var stats = results.stats;
-		var scale = 1024 * 1024 * 1024;
-
-		results.listCollections = results.listCollections.map(function (collectionInfo) {
-			return {
-				name: collectionInfo.ns,
-				count: collectionInfo.count,
-				size: collectionInfo.size,
-				avgObjSize: collectionInfo.avgObjSize,
-				storageSize: collectionInfo.storageSize,
-				totalIndexSize: collectionInfo.totalIndexSize,
-				indexSizes: collectionInfo.indexSizes,
-			};
-		});
-
-		stats.mem = results.serverStatus.mem;
-		stats.mem = results.serverStatus.mem;
-		stats.mem.resident = (stats.mem.resident / 1024).toFixed(2);
-		stats.mem.virtual = (stats.mem.virtual / 1024).toFixed(2);
-		stats.mem.mapped = (stats.mem.mapped / 1024).toFixed(2);
-		stats.collectionData = results.listCollections;
-		stats.network = results.serverStatus.network;
-		stats.raw = JSON.stringify(stats, null, 4);
-
-		stats.avgObjSize = stats.avgObjSize.toFixed(2);
-		stats.dataSize = (stats.dataSize / scale).toFixed(2);
-		stats.storageSize = (stats.storageSize / scale).toFixed(2);
-		stats.fileSize = stats.fileSize ? (stats.fileSize / scale).toFixed(2) : 0;
-		stats.indexSize = (stats.indexSize / scale).toFixed(2);
-		stats.storageEngine = results.serverStatus.storageEngine ? results.serverStatus.storageEngine.name : 'mmapv1';
-		stats.host = results.serverStatus.host;
-		stats.version = results.serverStatus.version;
-		stats.uptime = results.serverStatus.uptime;
-		stats.mongo = true;
-
-		callback(null, stats);
-	});
+	], callback);
 };
 
-mongoModule.close = function () {
-	db.close();
+function getCollectionStats(db, callback) {
+	async.waterfall([
+		function (next) {
+			db.listCollections().toArray(next);
+		},
+		function (items, next) {
+			async.map(items, function (collection, next) {
+				db.collection(collection.name).stats(next);
+			}, next);
+		},
+	], callback);
+}
+
+mongoModule.close = function (callback) {
+	callback = callback || function () {};
+	db.close(callback);
 };
diff --git a/src/database/redis.js b/src/database/redis.js
index 9ebc154705..d0d80d0038 100644
--- a/src/database/redis.js
+++ b/src/database/redis.js
@@ -1,6 +1,7 @@
 'use strict';
 
 var _ = require('underscore');
+var async = require('async');
 var winston = require('winston');
 var nconf = require('nconf');
 var semver = require('semver');
@@ -71,10 +72,6 @@ redisModule.connect = function (options) {
 	var redis_socket_or_host = nconf.get('redis:host');
 	var cxn;
 
-	if (!redis) {
-		redis = require('redis');
-	}
-
 	options = options || {};
 
 	if (nconf.get('redis:password')) {
@@ -101,10 +98,10 @@ redisModule.connect = function (options) {
 	}
 
 	var dbIdx = parseInt(nconf.get('redis:database'), 10);
-	if (dbIdx) {
-		cxn.select(dbIdx, function (error) {
-			if (error) {
-				winston.error('NodeBB could not connect to your Redis database. Redis returned the following error: ' + error.message);
+	if (dbIdx >= 0) {
+		cxn.select(dbIdx, function (err) {
+			if (err) {
+				winston.error('NodeBB could not connect to your Redis database. Redis returned the following error: ' + err.message);
 				process.exit();
 			}
 		});
@@ -118,46 +115,52 @@ redisModule.createIndices = function (callback) {
 };
 
 redisModule.checkCompatibility = function (callback) {
-	redisModule.info(redisModule.client, function (err, info) {
-		if (err) {
-			return callback(err);
-		}
-
-		if (semver.lt(info.redis_version, '2.8.9')) {
-			return callback(new Error('Your Redis version is not new enough to support NodeBB, please upgrade Redis to v2.8.9 or higher.'));
-		}
-
-		callback();
-	});
+	async.waterfall([
+		function (next) {
+			redisModule.info(redisModule.client, next);
+		},
+		function (info, next) {
+			redisModule.checkCompatibilityVersion(info.redis_version, next);
+		},
+	], callback);
 };
 
-redisModule.close = function () {
-	redisClient.quit();
+redisModule.checkCompatibilityVersion = function (version, callback) {
+	if (semver.lt(version, '2.8.9')) {
+		return callback(new Error('Your Redis version is not new enough to support NodeBB, please upgrade Redis to v2.8.9 or higher.'));
+	}
+	callback();
+};
+
+redisModule.close = function (callback) {
+	callback = callback || function () {};
+	redisClient.quit(callback);
 };
 
 redisModule.info = function (cxn, callback) {
 	if (!cxn) {
 		return callback();
 	}
-	cxn.info(function (err, data) {
-		if (err) {
-			return callback(err);
-		}
+	async.waterfall([
+		function (next) {
+			cxn.info(next);
+		},
+		function (data, next) {
+			var lines = data.toString().split('\r\n').sort();
+			var redisData = {};
+			lines.forEach(function (line) {
+				var parts = line.split(':');
+				if (parts[1]) {
+					redisData[parts[0]] = parts[1];
+				}
+			});
+			redisData.used_memory_human = (redisData.used_memory / (1024 * 1024 * 1024)).toFixed(2);
+			redisData.raw = JSON.stringify(redisData, null, 4);
+			redisData.redis = true;
 
-		var lines = data.toString().split('\r\n').sort();
-		var redisData = {};
-		lines.forEach(function (line) {
-			var parts = line.split(':');
-			if (parts[1]) {
-				redisData[parts[0]] = parts[1];
-			}
-		});
-		redisData.used_memory_human = (redisData.used_memory / (1024 * 1024 * 1024)).toFixed(2);
-		redisData.raw = JSON.stringify(redisData, null, 4);
-		redisData.redis = true;
-
-		callback(null, redisData);
-	});
+			next(null, redisData);
+		},
+	], callback);
 };
 
 redisModule.helpers = redisModule.helpers || {};
diff --git a/test/database.js b/test/database.js
index f55bf78edb..327d8095cf 100644
--- a/test/database.js
+++ b/test/database.js
@@ -2,6 +2,7 @@
 
 
 var	assert = require('assert');
+var nconf = require('nconf');
 var db = require('./mocks/databasemock');
 
 
@@ -12,14 +13,46 @@ describe('Test database', function () {
 		});
 	});
 
-	it('should return info about database', function (done) {
-		db.info(db.client, function (err, info) {
-			assert.ifError(err);
-			assert(info);
-			done();
+	describe('info', function () {
+		it('should return info about database', function (done) {
+			db.info(db.client, function (err, info) {
+				assert.ifError(err);
+				assert(info);
+				done();
+			});
+		});
+
+		it('should not error and return null if client is falsy', function (done) {
+			db.info(null, function (err, info) {
+				assert.ifError(err);
+				assert.equal(info, null);
+				done();
+			});
 		});
 	});
 
+	describe('checkCompatibility', function () {
+		it('should not throw', function (done) {
+			db.checkCompatibility(done);
+		});
+
+		it('should return error with a too low version', function (done) {
+			var dbName = nconf.get('database');
+			if (dbName === 'redis') {
+				db.checkCompatibilityVersion('2.4.0', function (err) {
+					assert.equal(err.message, 'Your Redis version is not new enough to support NodeBB, please upgrade Redis to v2.8.9 or higher.');
+					done();
+				});
+			} else if (dbName === 'mongo') {
+				db.checkCompatibilityVersion('1.8.0', function (err) {
+					assert.equal(err.message, 'The `mongodb` package is out-of-date, please run `./nodebb setup` again.');
+					done();
+				});
+			}
+		});
+	});
+
+
 	require('./database/keys');
 	require('./database/list');
 	require('./database/sets');
diff --git a/test/database/list.js b/test/database/list.js
index 8475ad2f52..1f5d72c6c3 100644
--- a/test/database/list.js
+++ b/test/database/list.js
@@ -9,11 +9,18 @@ describe('List methods', function () {
 	describe('listAppend()', function () {
 		it('should append to a list', function (done) {
 			db.listAppend('testList1', 5, function (err) {
-				assert.equal(err, null);
+				assert.ifError(err);
 				assert.equal(arguments.length, 1);
 				done();
 			});
 		});
+
+		it('should not add anyhing if key is falsy', function (done) {
+			db.listAppend(null, 3, function (err) {
+				assert.ifError(err);
+				done();
+			});
+		});
 	});
 
 	describe('listPrepend()', function () {
@@ -38,6 +45,13 @@ describe('List methods', function () {
 				done();
 			});
 		});
+
+		it('should not add anyhing if key is falsy', function (done) {
+			db.listPrepend(null, 3, function (err) {
+				assert.ifError(err);
+				done();
+			});
+		});
 	});
 
 	describe('getListRange()', function () {
@@ -83,6 +97,14 @@ describe('List methods', function () {
 				done();
 			});
 		});
+
+		it('should not get anyhing if key is falsy', function (done) {
+			db.getListRange(null, 0, -1, function (err, data) {
+				assert.ifError(err);
+				assert.equal(data, undefined);
+				done();
+			});
+		});
 	});
 
 	describe('listRemoveLast()', function () {
@@ -105,6 +127,13 @@ describe('List methods', function () {
 				done();
 			});
 		});
+
+		it('should not remove anyhing if key is falsy', function (done) {
+			db.listRemoveLast(null, function (err) {
+				assert.ifError(err);
+				done();
+			});
+		});
 	});
 
 	describe('listRemoveAll()', function () {
@@ -132,6 +161,13 @@ describe('List methods', function () {
 				});
 			});
 		});
+
+		it('should not remove anyhing if key is falsy', function (done) {
+			db.listRemoveAll(null, 3, function (err) {
+				assert.ifError(err);
+				done();
+			});
+		});
 	});
 
 	describe('listTrim()', function () {
@@ -156,6 +192,13 @@ describe('List methods', function () {
 				});
 			});
 		});
+
+		it('should not add anyhing if key is falsy', function (done) {
+			db.listTrim(null, 0, 3, function (err) {
+				assert.ifError(err);
+				done();
+			});
+		});
 	});
 
 
diff --git a/test/mocks/databasemock.js b/test/mocks/databasemock.js
index 4432f944f1..5b186e7f35 100644
--- a/test/mocks/databasemock.js
+++ b/test/mocks/databasemock.js
@@ -81,6 +81,10 @@
 
 	var db = require('../../src/database');
 
+	after(function (done) {
+		db.close(done);
+	});
+
 	before(function (done) {
 		this.timeout(30000);
 		var meta;
@@ -91,6 +95,9 @@
 			function (next) {
 				db.emptydb(next);
 			},
+			function (next) {
+				db.createIndices(next);
+			},
 			function (next) {
 				winston.info('test_database flushed');
 				meta = require('../../src/meta');

From fe0a5aaf28a281ce8b8f6376d7667524ab5f1d78 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Fri, 19 May 2017 20:32:31 -0400
Subject: [PATCH 18/42] fix redis tests

---
 src/database/redis/list.js | 18 ++++++++++++++++++
 test/database/list.js      |  2 +-
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/src/database/redis/list.js b/src/database/redis/list.js
index fb445573ff..f8108a194d 100644
--- a/src/database/redis/list.js
+++ b/src/database/redis/list.js
@@ -3,6 +3,9 @@
 module.exports = function (redisClient, module) {
 	module.listPrepend = function (key, value, callback) {
 		callback = callback || function () {};
+		if (!key) {
+			return callback();
+		}
 		redisClient.lpush(key, value, function (err) {
 			callback(err);
 		});
@@ -10,6 +13,9 @@ module.exports = function (redisClient, module) {
 
 	module.listAppend = function (key, value, callback) {
 		callback = callback || function () {};
+		if (!key) {
+			return callback();
+		}
 		redisClient.rpush(key, value, function (err) {
 			callback(err);
 		});
@@ -17,11 +23,17 @@ module.exports = function (redisClient, module) {
 
 	module.listRemoveLast = function (key, callback) {
 		callback = callback || function () {};
+		if (!key) {
+			return callback();
+		}
 		redisClient.rpop(key, callback);
 	};
 
 	module.listRemoveAll = function (key, value, callback) {
 		callback = callback || function () {};
+		if (!key) {
+			return callback();
+		}
 		redisClient.lrem(key, 0, value, function (err) {
 			callback(err);
 		});
@@ -29,6 +41,9 @@ module.exports = function (redisClient, module) {
 
 	module.listTrim = function (key, start, stop, callback) {
 		callback = callback || function () {};
+		if (!key) {
+			return callback();
+		}
 		redisClient.ltrim(key, start, stop, function (err) {
 			callback(err);
 		});
@@ -36,6 +51,9 @@ module.exports = function (redisClient, module) {
 
 	module.getListRange = function (key, start, stop, callback) {
 		callback = callback || function () {};
+		if (!key) {
+			return callback();
+		}
 		redisClient.lrange(key, start, stop, callback);
 	};
 };
diff --git a/test/database/list.js b/test/database/list.js
index 1f5d72c6c3..7d00df3e8d 100644
--- a/test/database/list.js
+++ b/test/database/list.js
@@ -98,7 +98,7 @@ describe('List methods', function () {
 			});
 		});
 
-		it('should not get anyhing if key is falsy', function (done) {
+		it('should not get anything if key is falsy', function (done) {
 			db.getListRange(null, 0, -1, function (err, data) {
 				assert.ifError(err);
 				assert.equal(data, undefined);

From 4b94446cd9ed98b09ff52f009dd814c802fbdbc7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Sat, 20 May 2017 16:26:56 -0400
Subject: [PATCH 19/42] more user search tests

---
 src/user/search.js | 78 ++++++++++++++++++++++++----------------------
 test/user.js       | 64 +++++++++++++++++++++++++++++++++++++
 2 files changed, 104 insertions(+), 38 deletions(-)

diff --git a/src/user/search.js b/src/user/search.js
index 4583e0e28f..967c32c32b 100644
--- a/src/user/search.js
+++ b/src/user/search.js
@@ -68,16 +68,17 @@ module.exports = function (User) {
 		var resultsPerPage = parseInt(meta.config.userSearchResultsPerPage, 10) || 20;
 		var hardCap = resultsPerPage * 10;
 
-		db.getSortedSetRangeByLex(searchBy + ':sorted', min, max, 0, hardCap, function (err, data) {
-			if (err) {
-				return callback(err);
-			}
-
-			var uids = data.map(function (data) {
-				return data.split(':')[1];
-			});
-			callback(null, uids);
-		});
+		async.waterfall([
+			function (next) {
+				db.getSortedSetRangeByLex(searchBy + ':sorted', min, max, 0, hardCap, next);
+			},
+			function (data, next) {
+				var uids = data.map(function (data) {
+					return data.split(':')[1];
+				});
+				next(null, uids);
+			},
+		], callback);
 	}
 
 	function filterAndSortUids(uids, data, callback) {
@@ -94,37 +95,38 @@ module.exports = function (User) {
 			fields.push('flags');
 		}
 
-		User.getUsersFields(uids, fields, function (err, userData) {
-			if (err) {
-				return callback(err);
-			}
+		async.waterfall([
+			function (next) {
+				User.getUsersFields(uids, fields, next);
+			},
+			function (userData, next) {
+				if (data.onlineOnly) {
+					userData = userData.filter(function (user) {
+						return user && user.status !== 'offline' && (Date.now() - parseInt(user.lastonline, 10) < 300000);
+					});
+				}
 
-			if (data.onlineOnly) {
-				userData = userData.filter(function (user) {
-					return user && user.status !== 'offline' && (Date.now() - parseInt(user.lastonline, 10) < 300000);
+				if (data.bannedOnly) {
+					userData = userData.filter(function (user) {
+						return user && parseInt(user.banned, 10) === 1;
+					});
+				}
+
+				if (data.flaggedOnly) {
+					userData = userData.filter(function (user) {
+						return user && parseInt(user.flags, 10) > 0;
+					});
+				}
+
+				sortUsers(userData, sortBy);
+
+				uids = userData.map(function (user) {
+					return user && user.uid;
 				});
-			}
 
-			if (data.bannedOnly) {
-				userData = userData.filter(function (user) {
-					return user && user.banned;
-				});
-			}
-
-			if (data.flaggedOnly) {
-				userData = userData.filter(function (user) {
-					return user && parseInt(user.flags, 10) > 0;
-				});
-			}
-
-			sortUsers(userData, sortBy);
-
-			uids = userData.map(function (user) {
-				return user && user.uid;
-			});
-
-			callback(null, uids);
-		});
+				next(null, uids);
+			},
+		], callback);
 	}
 
 	function sortUsers(userData, sortBy) {
diff --git a/test/user.js b/test/user.js
index f7d9986336..fd40b990dd 100644
--- a/test/user.js
+++ b/test/user.js
@@ -237,6 +237,70 @@ describe('User', function () {
 				done();
 			});
 		});
+
+		it('should search users by ip', function (done) {
+			User.create({ username: 'ipsearch' }, function (err, uid) {
+				assert.ifError(err);
+				db.sortedSetAdd('ip:1.1.1.1:uid', [1, 1], [testUid, uid], function (err) {
+					assert.ifError(err);
+					socketUser.search({ uid: testUid }, { query: '1.1.1.1', searchBy: 'ip' }, function (err, data) {
+						assert.ifError(err);
+						assert(Array.isArray(data.users));
+						assert.equal(data.users.length, 2);
+						done();
+					});
+				});
+			});
+		});
+
+		it('should return empty array if query is empty', function (done) {
+			socketUser.search({ uid: testUid }, { query: '' }, function (err, data) {
+				assert.ifError(err);
+				assert.equal(data.users.length, 0);
+				done();
+			});
+		});
+
+		it('should filter users', function (done) {
+			User.create({ username: 'ipsearch_filter' }, function (err, uid) {
+				assert.ifError(err);
+				User.setUserFields(uid, { banned: 1, flags: 10 }, function (err) {
+					assert.ifError(err);
+					socketUser.search({ uid: testUid }, {
+						query: 'ipsearch',
+						onlineOnly: true,
+						bannedOnly: true,
+						flaggedOnly: true,
+					}, function (err, data) {
+						assert.ifError(err);
+						assert.equal(data.users[0].username, 'ipsearch_filter');
+						done();
+					});
+				});
+			});
+		});
+
+		it('should sort results by username', function (done) {
+			async.waterfall([
+				function (next) {
+					User.create({ username: 'brian' }, next);
+				},
+				function (uid, next) {
+					User.create({ username: 'baris' }, next);
+				},
+				function (uid, next) {
+					socketUser.search({ uid: testUid }, {
+						query: 'b',
+						sortBy: 'username',
+					}, next);
+				},
+			], function (err, data) {
+				assert.ifError(err);
+				assert.equal(data.users[0].username, 'baris');
+				assert.equal(data.users[1].username, 'brian');
+				done();
+			});
+		});
 	});
 
 	describe('.delete()', function () {

From 9fdd313e308539c5845be3c742390efbb0309f54 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Sat, 20 May 2017 16:46:07 -0400
Subject: [PATCH 20/42] tweak test

---
 test/user.js | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/test/user.js b/test/user.js
index fd40b990dd..6f5b2e3150 100644
--- a/test/user.js
+++ b/test/user.js
@@ -288,16 +288,21 @@ describe('User', function () {
 				function (uid, next) {
 					User.create({ username: 'baris' }, next);
 				},
+				function (uid, next) {
+					User.create({ username: 'bzari' }, next);
+				},
 				function (uid, next) {
 					socketUser.search({ uid: testUid }, {
 						query: 'b',
 						sortBy: 'username',
+						paginate: false,
 					}, next);
 				},
 			], function (err, data) {
 				assert.ifError(err);
 				assert.equal(data.users[0].username, 'baris');
 				assert.equal(data.users[1].username, 'brian');
+				assert.equal(data.users[2].username, 'bzari');
 				done();
 			});
 		});

From 769d2b00b1fce4e2ac14429624014b2c942a34a2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Sat, 20 May 2017 17:08:20 -0400
Subject: [PATCH 21/42] change test method call

---
 test/user.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/user.js b/test/user.js
index 6f5b2e3150..fd1d720ab5 100644
--- a/test/user.js
+++ b/test/user.js
@@ -292,7 +292,8 @@ describe('User', function () {
 					User.create({ username: 'bzari' }, next);
 				},
 				function (uid, next) {
-					socketUser.search({ uid: testUid }, {
+					User.search({
+						uid: testUid,
 						query: 'b',
 						sortBy: 'username',
 						paginate: false,

From edeb22fcdfb872ed6dae334a258e84db58cb90c5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Sat, 20 May 2017 20:02:53 -0400
Subject: [PATCH 22/42] change style of meta.js

---
 src/meta.js | 118 ++++++++++++++++++++++++++--------------------------
 1 file changed, 59 insertions(+), 59 deletions(-)

diff --git a/src/meta.js b/src/meta.js
index 1fb0170297..59c3447cf4 100644
--- a/src/meta.js
+++ b/src/meta.js
@@ -8,71 +8,71 @@ var nconf = require('nconf');
 var pubsub = require('./pubsub');
 var utils = require('./utils');
 
-(function (Meta) {
-	Meta.reloadRequired = false;
+var Meta = module.exports;
 
-	require('./meta/configs')(Meta);
-	require('./meta/themes')(Meta);
-	require('./meta/js')(Meta);
-	require('./meta/css')(Meta);
-	require('./meta/sounds')(Meta);
-	require('./meta/settings')(Meta);
-	require('./meta/logs')(Meta);
-	require('./meta/errors')(Meta);
-	require('./meta/tags')(Meta);
-	require('./meta/dependencies')(Meta);
-	Meta.templates = require('./meta/templates');
-	Meta.blacklist = require('./meta/blacklist');
-	Meta.languages = require('./meta/languages');
+Meta.reloadRequired = false;
 
-	/* Assorted */
-	Meta.userOrGroupExists = function (slug, callback) {
-		var user = require('./user');
-		var groups = require('./groups');
-		slug = utils.slugify(slug);
-		async.parallel([
-			async.apply(user.existsBySlug, slug),
-			async.apply(groups.existsBySlug, slug),
-		], function (err, results) {
-			callback(err, results ? results.some(function (result) { return result; }) : false);
-		});
-	};
+require('./meta/configs')(Meta);
+require('./meta/themes')(Meta);
+require('./meta/js')(Meta);
+require('./meta/css')(Meta);
+require('./meta/sounds')(Meta);
+require('./meta/settings')(Meta);
+require('./meta/logs')(Meta);
+require('./meta/errors')(Meta);
+require('./meta/tags')(Meta);
+require('./meta/dependencies')(Meta);
+Meta.templates = require('./meta/templates');
+Meta.blacklist = require('./meta/blacklist');
+Meta.languages = require('./meta/languages');
 
-	/**
-	 * Reload deprecated as of v1.1.2+, remove in v2.x
-	 */
-	Meta.reload = function (callback) {
-		restart();
-		callback();
-	};
+/* Assorted */
+Meta.userOrGroupExists = function (slug, callback) {
+	var user = require('./user');
+	var groups = require('./groups');
+	slug = utils.slugify(slug);
+	async.parallel([
+		async.apply(user.existsBySlug, slug),
+		async.apply(groups.existsBySlug, slug),
+	], function (err, results) {
+		callback(err, results ? results.some(function (result) { return result; }) : false);
+	});
+};
 
-	Meta.restart = function () {
-		pubsub.publish('meta:restart', { hostname: os.hostname() });
-		restart();
-	};
+/**
+ * Reload deprecated as of v1.1.2+, remove in v2.x
+ */
+Meta.reload = function (callback) {
+	restart();
+	callback();
+};
 
-	Meta.getSessionTTLSeconds = function () {
-		var ttlDays = 60 * 60 * 24 * (parseInt(Meta.config.loginDays, 10) || 0);
-		var ttlSeconds = (parseInt(Meta.config.loginSeconds, 10) || 0);
-		var ttl = ttlSeconds || ttlDays || 1209600; // Default to 14 days
-		return ttl;
-	};
+Meta.restart = function () {
+	pubsub.publish('meta:restart', { hostname: os.hostname() });
+	restart();
+};
 
-	if (nconf.get('isPrimary') === 'true') {
-		pubsub.on('meta:restart', function (data) {
-			if (data.hostname !== os.hostname()) {
-				restart();
-			}
-		});
-	}
+Meta.getSessionTTLSeconds = function () {
+	var ttlDays = 60 * 60 * 24 * (parseInt(Meta.config.loginDays, 10) || 0);
+	var ttlSeconds = (parseInt(Meta.config.loginSeconds, 10) || 0);
+	var ttl = ttlSeconds || ttlDays || 1209600; // Default to 14 days
+	return ttl;
+};
 
-	function restart() {
-		if (process.send) {
-			process.send({
-				action: 'restart',
-			});
-		} else {
-			winston.error('[meta.restart] Could not restart, are you sure NodeBB was started with `./nodebb start`?');
+if (nconf.get('isPrimary') === 'true') {
+	pubsub.on('meta:restart', function (data) {
+		if (data.hostname !== os.hostname()) {
+			restart();
 		}
+	});
+}
+
+function restart() {
+	if (process.send) {
+		process.send({
+			action: 'restart',
+		});
+	} else {
+		winston.error('[meta.restart] Could not restart, are you sure NodeBB was started with `./nodebb start`?');
 	}
-}(exports));
+}

From 7fb45cc14822a77be643fe106bf316c26313f862 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Sat, 20 May 2017 20:03:41 -0400
Subject: [PATCH 23/42] more tests

---
 src/socket.io/modules.js   | 125 ++++++++-------
 test/messaging.js          | 298 ++++++++++++++++++++++++++++++++++-
 test/meta.js               |  15 ++
 test/mocks/databasemock.js | 307 ++++++++++++++++++-------------------
 4 files changed, 528 insertions(+), 217 deletions(-)

diff --git a/src/socket.io/modules.js b/src/socket.io/modules.js
index a3a9ff4fe3..172d91e60f 100644
--- a/src/socket.io/modules.js
+++ b/src/socket.io/modules.js
@@ -12,16 +12,16 @@ var utils = require('../utils');
 var server = require('./');
 var user = require('../user');
 
-var SocketModules = {
-	chats: {},
-	sounds: {},
-	settings: {},
-};
+var SocketModules = module.exports;
+
+SocketModules.chats = {};
+SocketModules.sounds = {};
+SocketModules.settings = {};
 
 /* Chat */
 
 SocketModules.chats.getRaw = function (socket, data, callback) {
-	if (!data || !data.hasOwnProperty('mid')) {
+	if (!data || !data.hasOwnProperty('mid') || !data.hasOwnProperty('roomId')) {
 		return callback(new Error('[[error:invalid-data]]'));
 	}
 	async.waterfall([
@@ -57,13 +57,14 @@ SocketModules.chats.newRoom = function (socket, data, callback) {
 		return callback(new Error('[[error:too-many-messages]]'));
 	}
 
-	Messaging.canMessageUser(socket.uid, data.touid, function (err) {
-		if (err) {
-			return callback(err);
-		}
-
-		Messaging.newRoom(socket.uid, [data.touid], callback);
-	});
+	async.waterfall([
+		function (next) {
+			Messaging.canMessageUser(socket.uid, data.touid, next);
+		},
+		function (next) {
+			Messaging.newRoom(socket.uid, [data.touid], next);
+		},
+	], callback);
 };
 
 SocketModules.chats.send = function (socket, data, callback) {
@@ -223,17 +224,21 @@ SocketModules.chats.leave = function (socket, roomid, callback) {
 
 
 SocketModules.chats.edit = function (socket, data, callback) {
-	if (!data || !data.roomId) {
+	if (!data || !data.roomId || !data.message) {
 		return callback(new Error('[[error:invalid-data]]'));
 	}
 
-	Messaging.canEdit(data.mid, socket.uid, function (err, allowed) {
-		if (err || !allowed) {
-			return callback(err || new Error('[[error:cant-edit-chat-message]]'));
-		}
-
-		Messaging.editMessage(socket.uid, data.mid, data.roomId, data.message, callback);
-	});
+	async.waterfall([
+		function (next) {
+			Messaging.canEdit(data.mid, socket.uid, next);
+		},
+		function (allowed, next) {
+			if (!allowed) {
+				return next(new Error('[[error:cant-edit-chat-message]]'));
+			}
+			Messaging.editMessage(socket.uid, data.mid, data.roomId, data.message, next);
+		},
+	], callback);
 };
 
 SocketModules.chats.delete = function (socket, data, callback) {
@@ -241,13 +246,18 @@ SocketModules.chats.delete = function (socket, data, callback) {
 		return callback(new Error('[[error:invalid-data]]'));
 	}
 
-	Messaging.canEdit(data.messageId, socket.uid, function (err, allowed) {
-		if (err || !allowed) {
-			return callback(err || new Error('[[error:cant-delete-chat-message]]'));
-		}
+	async.waterfall([
+		function (next) {
+			Messaging.canEdit(data.messageId, socket.uid, next);
+		},
+		function (allowed, next) {
+			if (!allowed) {
+				return next(new Error('[[error:cant-delete-chat-message]]'));
+			}
 
-		Messaging.deleteMessage(data.messageId, data.roomId, callback);
-	});
+			Messaging.deleteMessage(data.messageId, data.roomId, next);
+		},
+	], callback);
 };
 
 SocketModules.chats.canMessage = function (socket, roomId, callback) {
@@ -255,37 +265,38 @@ SocketModules.chats.canMessage = function (socket, roomId, callback) {
 };
 
 SocketModules.chats.markRead = function (socket, roomId, callback) {
-	if (!socket.uid) {
+	if (!socket.uid || !roomId) {
 		return callback(new Error('[[error:invalid-data]]'));
 	}
-	async.parallel({
-		uidsInRoom: async.apply(Messaging.getUidsInRoom, roomId, 0, -1),
-		markRead: async.apply(Messaging.markRead, socket.uid, roomId),
-	}, function (err, results) {
-		if (err) {
-			return callback(err);
-		}
+	async.waterfall([
+		function (next) {
+			async.parallel({
+				uidsInRoom: async.apply(Messaging.getUidsInRoom, roomId, 0, -1),
+				markRead: async.apply(Messaging.markRead, socket.uid, roomId),
+			}, next);
+		},
+		function (results, next) {
+			Messaging.pushUnreadCount(socket.uid);
+			server.in('uid_' + socket.uid).emit('event:chats.markedAsRead', { roomId: roomId });
 
-		Messaging.pushUnreadCount(socket.uid);
-		server.in('uid_' + socket.uid).emit('event:chats.markedAsRead', { roomId: roomId });
+			if (results.uidsInRoom.indexOf(socket.uid.toString()) === -1) {
+				return callback();
+			}
 
-		if (results.uidsInRoom.indexOf(socket.uid.toString()) === -1) {
-			return callback();
-		}
+			// Mark notification read
+			var nids = results.uidsInRoom.filter(function (uid) {
+				return parseInt(uid, 10) !== socket.uid;
+			}).map(function (uid) {
+				return 'chat_' + uid + '_' + roomId;
+			});
 
-		// Mark notification read
-		var nids = results.uidsInRoom.filter(function (uid) {
-			return parseInt(uid, 10) !== socket.uid;
-		}).map(function (uid) {
-			return 'chat_' + uid + '_' + roomId;
-		});
+			notifications.markReadMultiple(nids, socket.uid, function () {
+				user.notifications.pushCount(socket.uid);
+			});
 
-		notifications.markReadMultiple(nids, socket.uid, function () {
-			user.notifications.pushCount(socket.uid);
-		});
-
-		callback();
-	});
+			next();
+		},
+	], callback);
 };
 
 SocketModules.chats.markAllRead = function (socket, data, callback) {
@@ -301,8 +312,8 @@ SocketModules.chats.markAllRead = function (socket, data, callback) {
 };
 
 SocketModules.chats.renameRoom = function (socket, data, callback) {
-	if (!data) {
-		return callback(new Error('[[error:invalid-name]]'));
+	if (!data || !data.roomId || !data.newName) {
+		return callback(new Error('[[error:invalid-data]]'));
 	}
 
 	async.waterfall([
@@ -333,13 +344,13 @@ SocketModules.chats.getRecentChats = function (socket, data, callback) {
 
 SocketModules.chats.hasPrivateChat = function (socket, uid, callback) {
 	if (!socket.uid || !uid) {
-		return callback(null, new Error('[[error:invalid-data]]'));
+		return callback(new Error('[[error:invalid-data]]'));
 	}
 	Messaging.hasPrivateChat(socket.uid, uid, callback);
 };
 
 SocketModules.chats.getMessages = function (socket, data, callback) {
-	if (!socket.uid || !data.uid || !data.roomId) {
+	if (!socket.uid || !data || !data.uid || !data.roomId) {
 		return callback(new Error('[[error:invalid-data]]'));
 	}
 
@@ -358,5 +369,3 @@ SocketModules.chats.getMessages = function (socket, data, callback) {
 SocketModules.sounds.getUserSoundMap = function getUserSoundMap(socket, data, callback) {
 	meta.sounds.getUserSoundMap(socket.uid, callback);
 };
-
-module.exports = SocketModules;
diff --git a/test/messaging.js b/test/messaging.js
index 436fd78a87..a009d5ad21 100644
--- a/test/messaging.js
+++ b/test/messaging.js
@@ -11,7 +11,7 @@ var User = require('../src/user');
 var Groups = require('../src/groups');
 var Messaging = require('../src/messaging');
 var helpers = require('./helpers');
-
+var socketModules = require('../src/socket.io/modules');
 
 describe('Messaging Library', function () {
 	var fooUid;
@@ -55,7 +55,10 @@ describe('Messaging Library', function () {
 				assert.ifError(err);
 				Messaging.canMessageUser(herpUid, bazUid, function (err) {
 					assert.strictEqual(err.message, '[[error:chat-restricted]]');
-					done();
+					socketModules.chats.addUserToRoom({ uid: herpUid }, { roomId: 1, username: 'baz' }, function (err) {
+						assert.equal(err.message, '[[error:chat-restricted]]');
+						done();
+					});
 				});
 			});
 		});
@@ -78,23 +81,93 @@ describe('Messaging Library', function () {
 	});
 
 	describe('rooms', function () {
-		var socketModules = require('../src/socket.io/modules');
+		it('should fail to create a new chat room with invalid data', function (done) {
+			socketModules.chats.newRoom({ uid: fooUid }, null, function (err) {
+				assert.equal(err.message, '[[error:invalid-data]]');
+				done();
+			});
+		});
+
+		it('should return rate limit error on second try', function (done) {
+			var socketMock = { uid: fooUid };
+			socketModules.chats.newRoom(socketMock, { touid: bazUid }, function (err) {
+				assert.ifError(err);
+				socketModules.chats.newRoom(socketMock, { touid: bazUid }, function (err) {
+					assert.equal(err.message, '[[error:too-many-messages]]');
+					done();
+				});
+			});
+		});
+
 		it('should create a new chat room', function (done) {
 			socketModules.chats.newRoom({ uid: fooUid }, { touid: bazUid }, function (err, _roomId) {
 				roomId = _roomId;
 				assert.ifError(err);
 				assert(roomId);
-				done();
+				socketModules.chats.canMessage({ uid: fooUid }, _roomId, function (err) {
+					assert.ifError(err);
+					done();
+				});
+			});
+		});
+
+		it('should fail to add user to room with invalid data', function (done) {
+			socketModules.chats.addUserToRoom({ uid: fooUid }, null, function (err) {
+				assert.equal(err.message, '[[error:invalid-data]]');
+				socketModules.chats.addUserToRoom({ uid: fooUid }, { roomId: null }, function (err) {
+					assert.equal(err.message, '[[error:invalid-data]]');
+					socketModules.chats.addUserToRoom({ uid: fooUid }, { roomId: roomId, username: null }, function (err) {
+						assert.equal(err.message, '[[error:invalid-data]]');
+						done();
+					});
+				});
 			});
 		});
 
 		it('should add a user to room', function (done) {
 			socketModules.chats.addUserToRoom({ uid: fooUid }, { roomId: roomId, username: 'herp' }, function (err) {
 				assert.ifError(err);
+				Messaging.isUserInRoom(herpUid, roomId, function (err, isInRoom) {
+					assert.ifError(err);
+					assert(isInRoom);
+					done();
+				});
+			});
+		});
+
+		it('should fail to add users to room if max is reached', function (done) {
+			meta.config.maximumUsersInChatRoom = 2;
+			socketModules.chats.addUserToRoom({ uid: fooUid }, { roomId: roomId, username: 'test' }, function (err) {
+				assert.equal(err.message, '[[error:cant-add-more-users-to-chat-room]]');
+				meta.config.maximumUsersInChatRoom = 0;
 				done();
 			});
 		});
 
+		it('should fail to add users to room if user does not exist', function (done) {
+			socketModules.chats.addUserToRoom({ uid: fooUid }, { roomId: roomId, username: 'doesnotexist' }, function (err) {
+				assert.equal(err.message, '[[error:no-user]]');
+				done();
+			});
+		});
+
+		it('should fail to add self to room', function (done) {
+			socketModules.chats.addUserToRoom({ uid: fooUid }, { roomId: roomId, username: 'foo' }, function (err) {
+				assert.equal(err.message, '[[error:cant-add-self-to-chat-room]]');
+				done();
+			});
+		});
+
+		it('should fail to leave room with invalid data', function (done) {
+			socketModules.chats.leave({ uid: null }, roomId, function (err) {
+				assert.equal(err.message, '[[error:invalid-data]]');
+				socketModules.chats.leave({ uid: fooUid }, null, function (err) {
+					assert.equal(err.message, '[[error:invalid-data]]');
+					done();
+				});
+			});
+		});
+
 		it('should leave the chat room', function (done) {
 			socketModules.chats.leave({ uid: bazUid }, roomId, function (err) {
 				assert.ifError(err);
@@ -106,6 +179,60 @@ describe('Messaging Library', function () {
 			});
 		});
 
+		it('should fail to remove user from room', function (done) {
+			socketModules.chats.removeUserFromRoom({ uid: fooUid }, null, function (err) {
+				assert.equal(err.message, '[[error:invalid-data]]');
+				socketModules.chats.removeUserFromRoom({ uid: fooUid }, {}, function (err) {
+					assert.equal(err.message, '[[error:invalid-data]]');
+					done();
+				});
+			});
+		});
+
+		it('should fail to remove user from room if user does not exist', function (done) {
+			socketModules.chats.removeUserFromRoom({ uid: fooUid }, { roomId: roomId, username: 'doesnotexist' }, function (err) {
+				assert.equal(err.message, '[[error:no-user]]');
+				done();
+			});
+		});
+
+		it('should remove user from room', function (done) {
+			socketModules.chats.newRoom({ uid: fooUid }, { touid: herpUid }, function (err, roomId) {
+				assert.ifError(err);
+				Messaging.isUserInRoom(herpUid, roomId, function (err, isInRoom) {
+					assert.ifError(err);
+					assert(isInRoom);
+					socketModules.chats.removeUserFromRoom({ uid: fooUid }, { roomId: roomId, username: 'herp' }, function (err) {
+						assert.equal(err.message, '[[error:cant-remove-last-user]]');
+						socketModules.chats.addUserToRoom({ uid: fooUid }, { roomId: roomId, username: 'baz' }, function (err) {
+							assert.ifError(err);
+							socketModules.chats.removeUserFromRoom({ uid: fooUid }, { roomId: roomId, username: 'herp' }, function (err) {
+								assert.ifError(err);
+								Messaging.isUserInRoom(herpUid, roomId, function (err, isInRoom) {
+									assert.ifError(err);
+									assert(!isInRoom);
+									done();
+								});
+							});
+						});
+					});
+				});
+			});
+		});
+
+		it('should fail to send a message to room with invalid data', function (done) {
+			socketModules.chats.send({ uid: fooUid }, null, function (err) {
+				assert.equal(err.message, '[[error:invalid-data]]');
+				socketModules.chats.send({ uid: fooUid }, { roomId: null }, function (err) {
+					assert.equal(err.message, '[[error:invalid-data]]');
+					socketModules.chats.send({ uid: null }, { roomId: 1 }, function (err) {
+						assert.equal(err.message, '[[error:invalid-data]]');
+						done();
+					});
+				});
+			});
+		});
+
 		it('should send a message to a room', function (done) {
 			socketModules.chats.send({ uid: fooUid }, { roomId: roomId, message: 'first chat message' }, function (err, messageData) {
 				assert.ifError(err);
@@ -116,11 +243,39 @@ describe('Messaging Library', function () {
 				socketModules.chats.getRaw({ uid: fooUid }, { roomId: roomId, mid: messageData.mid }, function (err, raw) {
 					assert.ifError(err);
 					assert.equal(raw, 'first chat message');
+					setTimeout(done, 300);
+				});
+			});
+		});
+
+		it('should fail to send second message due to rate limit', function (done) {
+			var socketMock = { uid: fooUid };
+			socketModules.chats.send(socketMock, { roomId: roomId, message: 'first chat message' }, function (err) {
+				assert.ifError(err);
+				socketModules.chats.send(socketMock, { roomId: roomId, message: 'first chat message' }, function (err) {
+					assert.equal(err.message, '[[error:too-many-messages]]');
 					done();
 				});
 			});
 		});
 
+		it('should return invalid-data error', function (done) {
+			socketModules.chats.getRaw({ uid: fooUid }, null, function (err) {
+				assert.equal(err.message, '[[error:invalid-data]]');
+				socketModules.chats.getRaw({ uid: fooUid }, { }, function (err) {
+					assert.equal(err.message, '[[error:invalid-data]]');
+					done();
+				});
+			});
+		});
+
+		it('should return not in room error', function (done) {
+			socketModules.chats.getRaw({ uid: 0 }, { roomId: roomId, mid: 1 }, function (err) {
+				assert.equal(err.message, '[[error:not-allowed]]');
+				done();
+			});
+		});
+
 		it('should notify offline users of message', function (done) {
 			Messaging.notificationSendDelay = 100;
 
@@ -143,6 +298,22 @@ describe('Messaging Library', function () {
 			});
 		});
 
+		it('should fail to get messages from room with invalid data', function (done) {
+			socketModules.chats.getMessages({ uid: null }, null, function (err, messages) {
+				assert.equal(err.message, '[[error:invalid-data]]');
+				socketModules.chats.getMessages({ uid: fooUid }, null, function (err, messages) {
+					assert.equal(err.message, '[[error:invalid-data]]');
+					socketModules.chats.getMessages({ uid: fooUid }, { uid: null }, function (err, messages) {
+						assert.equal(err.message, '[[error:invalid-data]]');
+						socketModules.chats.getMessages({ uid: fooUid }, { uid: 1, roomId: null }, function (err, messages) {
+							assert.equal(err.message, '[[error:invalid-data]]');
+							done();
+						});
+					});
+				});
+			});
+		});
+
 		it('should get messages from room', function (done) {
 			socketModules.chats.getMessages({ uid: fooUid }, {
 				uid: fooUid,
@@ -157,6 +328,23 @@ describe('Messaging Library', function () {
 			});
 		});
 
+		it('should fail to mark read with invalid data', function (done) {
+			socketModules.chats.markRead({ uid: null }, roomId, function (err) {
+				assert.equal(err.message, '[[error:invalid-data]]');
+				socketModules.chats.markRead({ uid: fooUid }, null, function (err) {
+					assert.equal(err.message, '[[error:invalid-data]]');
+					done();
+				});
+			});
+		});
+
+		it('should not error if user is not in room', function (done) {
+			socketModules.chats.markRead({ uid: herpUid }, roomId, function (err) {
+				assert.ifError(err);
+				done();
+			});
+		});
+
 		it('should mark room read', function (done) {
 			socketModules.chats.markRead({ uid: fooUid }, roomId, function (err) {
 				assert.ifError(err);
@@ -171,10 +359,39 @@ describe('Messaging Library', function () {
 			});
 		});
 
+		it('should fail to rename room with invalid data', function (done) {
+			socketModules.chats.renameRoom({ uid: fooUid }, null, function (err) {
+				assert.equal(err.message, '[[error:invalid-data]]');
+				socketModules.chats.renameRoom({ uid: fooUid }, { roomId: null }, function (err) {
+					assert.equal(err.message, '[[error:invalid-data]]');
+					socketModules.chats.renameRoom({ uid: fooUid }, { roomId: roomId, newName: null }, function (err) {
+						assert.equal(err.message, '[[error:invalid-data]]');
+						done();
+					});
+				});
+			});
+		});
+
 		it('should rename room', function (done) {
 			socketModules.chats.renameRoom({ uid: fooUid }, { roomId: roomId, newName: 'new room name' }, function (err) {
 				assert.ifError(err);
+				done();
+			});
+		});
 
+		it('should fail to load room with invalid-data', function (done) {
+			socketModules.chats.loadRoom({ uid: fooUid }, null, function (err) {
+				assert.equal(err.message, '[[error:invalid-data]]');
+				socketModules.chats.loadRoom({ uid: fooUid }, { roomId: null }, function (err) {
+					assert.equal(err.message, '[[error:invalid-data]]');
+					done();
+				});
+			});
+		});
+
+		it('should fail to load room if user is not in', function (done) {
+			socketModules.chats.loadRoom({ uid: 0 }, { roomId: roomId }, function (err) {
+				assert.equal(err.message, '[[error:not-allowed]]');
 				done();
 			});
 		});
@@ -198,6 +415,45 @@ describe('Messaging Library', function () {
 				});
 			});
 		});
+
+		it('should fail to load recent chats with invalid data', function (done) {
+			socketModules.chats.getRecentChats({ uid: fooUid }, null, function (err) {
+				assert.equal(err.message, '[[error:invalid-data]]');
+				socketModules.chats.getRecentChats({ uid: fooUid }, { after: null }, function (err) {
+					assert.equal(err.message, '[[error:invalid-data]]');
+					socketModules.chats.getRecentChats({ uid: fooUid }, { after: 0, uid: null }, function (err) {
+						assert.equal(err.message, '[[error:invalid-data]]');
+						done();
+					});
+				});
+			});
+		});
+
+		it('should load recent chats of user', function (done) {
+			socketModules.chats.getRecentChats({ uid: fooUid }, { after: 0, uid: fooUid }, function (err, data) {
+				assert.ifError(err);
+				assert(Array.isArray(data.rooms));
+				done();
+			});
+		});
+
+		it('should fail to check if user has private chat with invalid data', function (done) {
+			socketModules.chats.hasPrivateChat({ uid: null }, null, function (err) {
+				assert.equal(err.message, '[[error:invalid-data]]');
+				socketModules.chats.hasPrivateChat({ uid: fooUid }, null, function (err) {
+					assert.equal(err.message, '[[error:invalid-data]]');
+					done();
+				});
+			});
+		});
+
+		it('should check if user has private chat with another uid', function (done) {
+			socketModules.chats.hasPrivateChat({ uid: fooUid }, herpUid, function (err, roomId) {
+				assert.ifError(err);
+				assert(roomId);
+				done();
+			});
+		});
 	});
 
 	describe('edit/delete', function () {
@@ -211,6 +467,26 @@ describe('Messaging Library', function () {
 			});
 		});
 
+		it('should fail to edit message with invalid data', function (done) {
+			socketModules.chats.edit({ uid: fooUid }, null, function (err) {
+				assert.equal(err.message, '[[error:invalid-data]]');
+				socketModules.chats.edit({ uid: fooUid }, { roomId: null }, function (err) {
+					assert.equal(err.message, '[[error:invalid-data]]');
+					socketModules.chats.edit({ uid: fooUid }, { roomId: 1, message: null }, function (err) {
+						assert.equal(err.message, '[[error:invalid-data]]');
+						done();
+					});
+				});
+			});
+		});
+
+		it('should fail to edit message if not own message', function (done) {
+			socketModules.chats.edit({ uid: herpUid }, { mid: 5, roomId: roomId, message: 'message edited' }, function (err) {
+				assert.equal(err.message, '[[error:cant-edit-chat-message]]');
+				done();
+			});
+		});
+
 		it('should edit message', function (done) {
 			socketModules.chats.edit({ uid: fooUid }, { mid: mid, roomId: roomId, message: 'message edited' }, function (err) {
 				assert.ifError(err);
@@ -222,6 +498,20 @@ describe('Messaging Library', function () {
 			});
 		});
 
+		it('should fail to delete message with invalid data', function (done) {
+			socketModules.chats.delete({ uid: fooUid }, null, function (err) {
+				assert.equal(err.message, '[[error:invalid-data]]');
+				socketModules.chats.delete({ uid: fooUid }, { roomId: null }, function (err) {
+					assert.equal(err.message, '[[error:invalid-data]]');
+					socketModules.chats.delete({ uid: fooUid }, { roomId: 1, messageId: null }, function (err) {
+						assert.equal(err.message, '[[error:invalid-data]]');
+						done();
+					});
+				});
+			});
+		});
+
+
 		it('should delete message', function (done) {
 			socketModules.chats.delete({ uid: fooUid }, { messageId: mid, roomId: roomId }, function (err) {
 				assert.ifError(err);
diff --git a/test/meta.js b/test/meta.js
index 8b32e90070..a92f6c74f6 100644
--- a/test/meta.js
+++ b/test/meta.js
@@ -262,6 +262,21 @@ describe('meta', function () {
 	});
 
 
+	describe('sounds', function () {
+		var socketModules = require('../src/socket.io/modules');
+
+		it('should getUserMap', function (done) {
+			socketModules.sounds.getUserSoundMap({ uid: 1 }, null, function (err, data) {
+				assert.ifError(err);
+				assert(data.hasOwnProperty('chat-incoming'));
+				assert(data.hasOwnProperty('chat-outgoing'));
+				assert(data.hasOwnProperty('notification'));
+				done();
+			});
+		});
+	});
+
+
 	after(function (done) {
 		db.emptydb(done);
 	});
diff --git a/test/mocks/databasemock.js b/test/mocks/databasemock.js
index 5b186e7f35..bd7831ac82 100644
--- a/test/mocks/databasemock.js
+++ b/test/mocks/databasemock.js
@@ -5,181 +5,178 @@
  * ATTENTION: testing db is flushed before every use!
  */
 
-(function (module) {
-	var async = require('async');
-	var winston = require('winston');
-	var path = require('path');
-	var nconf = require('nconf');
-	var url = require('url');
-	var errorText;
+var async = require('async');
+var winston = require('winston');
+var path = require('path');
+var nconf = require('nconf');
+var url = require('url');
+var errorText;
 
 
-	nconf.file({ file: path.join(__dirname, '../../config.json') });
-	nconf.defaults({
-		base_dir: path.join(__dirname, '../..'),
-		themes_path: path.join(__dirname, '../../node_modules'),
-		upload_path: 'public/uploads',
-		views_dir: path.join(__dirname, '../../build/public/templates'),
-		relative_path: '',
-	});
+nconf.file({ file: path.join(__dirname, '../../config.json') });
+nconf.defaults({
+	base_dir: path.join(__dirname, '../..'),
+	themes_path: path.join(__dirname, '../../node_modules'),
+	upload_path: 'public/uploads',
+	views_dir: path.join(__dirname, '../../build/public/templates'),
+	relative_path: '',
+});
 
-	if (!nconf.get('isCluster')) {
-		nconf.set('isPrimary', 'true');
-		nconf.set('isCluster', 'false');
-	}
+if (!nconf.get('isCluster')) {
+	nconf.set('isPrimary', 'true');
+	nconf.set('isCluster', 'false');
+}
 
-	var dbType = nconf.get('database');
-	var testDbConfig = nconf.get('test_database');
-	var productionDbConfig = nconf.get(dbType);
+var dbType = nconf.get('database');
+var testDbConfig = nconf.get('test_database');
+var productionDbConfig = nconf.get(dbType);
 
-	if (!testDbConfig) {
-		errorText = 'test_database is not defined';
-		winston.info(
-			'\n===========================================================\n' +
-			'Please, add parameters for test database in config.json\n' +
-			'For example (redis):\n' +
-			'"test_database": {\n' +
-			'    "host": "127.0.0.1",\n' +
-			'    "port": "6379",\n' +
-			'    "password": "",\n' +
-			'    "database": "1"\n' +
-			'}\n' +
-			' or (mongo):\n' +
-			'"test_database": {\n' +
-			'    "host": "127.0.0.1",\n' +
-			'    "port": "27017",\n' +
-			'    "password": "",\n' +
-			'    "database": "1\n' +
-			'}\n' +
-			' or (mongo) in a replicaset\n' +
-			'"test_database": {\n' +
-			'    "host": "127.0.0.1,127.0.0.1,127.0.0.1",\n' +
-			'    "port": "27017,27018,27019",\n' +
-			'    "username": "",\n' +
-			'    "password": "",\n' +
-			'    "database": "nodebb_test"\n' +
-			'}\n' +
-			'==========================================================='
-		);
-		winston.error(errorText);
-		throw new Error(errorText);
-	}
+if (!testDbConfig) {
+	errorText = 'test_database is not defined';
+	winston.info(
+		'\n===========================================================\n' +
+		'Please, add parameters for test database in config.json\n' +
+		'For example (redis):\n' +
+		'"test_database": {\n' +
+		'    "host": "127.0.0.1",\n' +
+		'    "port": "6379",\n' +
+		'    "password": "",\n' +
+		'    "database": "1"\n' +
+		'}\n' +
+		' or (mongo):\n' +
+		'"test_database": {\n' +
+		'    "host": "127.0.0.1",\n' +
+		'    "port": "27017",\n' +
+		'    "password": "",\n' +
+		'    "database": "1\n' +
+		'}\n' +
+		' or (mongo) in a replicaset\n' +
+		'"test_database": {\n' +
+		'    "host": "127.0.0.1,127.0.0.1,127.0.0.1",\n' +
+		'    "port": "27017,27018,27019",\n' +
+		'    "username": "",\n' +
+		'    "password": "",\n' +
+		'    "database": "nodebb_test"\n' +
+		'}\n' +
+		'==========================================================='
+	);
+	winston.error(errorText);
+	throw new Error(errorText);
+}
 
-	if (testDbConfig.database === productionDbConfig.database &&
-		testDbConfig.host === productionDbConfig.host &&
-		testDbConfig.port === productionDbConfig.port) {
-		errorText = 'test_database has the same config as production db';
-		winston.error(errorText);
-		throw new Error(errorText);
-	}
+if (testDbConfig.database === productionDbConfig.database &&
+	testDbConfig.host === productionDbConfig.host &&
+	testDbConfig.port === productionDbConfig.port) {
+	errorText = 'test_database has the same config as production db';
+	winston.error(errorText);
+	throw new Error(errorText);
+}
 
-	nconf.set(dbType, testDbConfig);
+nconf.set(dbType, testDbConfig);
 
-	winston.info('database config');
-	winston.info(dbType);
-	winston.info(testDbConfig);
+winston.info('database config');
+winston.info(dbType);
+winston.info(testDbConfig);
 
-	var db = require('../../src/database');
+var db = require('../../src/database');
+module.exports = db;
 
-	after(function (done) {
-		db.close(done);
-	});
+after(function (done) {
+	db.close(done);
+});
 
-	before(function (done) {
-		this.timeout(30000);
-		var meta;
-		async.waterfall([
-			function (next) {
-				db.init(next);
-			},
-			function (next) {
-				db.emptydb(next);
-			},
-			function (next) {
-				db.createIndices(next);
-			},
-			function (next) {
-				winston.info('test_database flushed');
-				meta = require('../../src/meta');
-				setupDefaultConfigs(meta, next);
-			},
-			function (next) {
-				meta.configs.init(next);
-			},
-			function (next) {
-				db.initSessionStore(next);
-			},
-			function (next) {
-				meta.dependencies.check(next);
-			},
-			function (next) {
-				meta.config.postDelay = 0;
-				meta.config.initialPostDelay = 0;
-				meta.config.newbiePostDelay = 0;
+before(function (done) {
+	this.timeout(30000);
+	var meta;
+	async.waterfall([
+		function (next) {
+			db.init(next);
+		},
+		function (next) {
+			db.emptydb(next);
+		},
+		function (next) {
+			db.createIndices(next);
+		},
+		function (next) {
+			winston.info('test_database flushed');
+			meta = require('../../src/meta');
+			setupDefaultConfigs(meta, next);
+		},
+		function (next) {
+			meta.configs.init(next);
+		},
+		function (next) {
+			db.initSessionStore(next);
+		},
+		function (next) {
+			meta.dependencies.check(next);
+		},
+		function (next) {
+			meta.config.postDelay = 0;
+			meta.config.initialPostDelay = 0;
+			meta.config.newbiePostDelay = 0;
 
-				enableDefaultPlugins(next);
-			},
-			function (next) {
-				meta.themes.set({
-					type: 'local',
-					id: 'nodebb-theme-persona',
-				}, next);
-			},
-			function (next) {
-				// nconf defaults, if not set in config
-				if (!nconf.get('sessionKey')) {
-					nconf.set('sessionKey', 'express.sid');
-				}
-				// Parse out the relative_url and other goodies from the configured URL
-				var urlObject = url.parse(nconf.get('url'));
-				var relativePath = urlObject.pathname !== '/' ? urlObject.pathname : '';
-				nconf.set('base_url', urlObject.protocol + '//' + urlObject.host);
-				nconf.set('secure', urlObject.protocol === 'https:');
-				nconf.set('use_port', !!urlObject.port);
-				nconf.set('relative_path', relativePath);
-				nconf.set('port', urlObject.port || nconf.get('port') || nconf.get('PORT') || (nconf.get('PORT_ENV_VAR') ? nconf.get(nconf.get('PORT_ENV_VAR')) : false) || 4567);
-				nconf.set('upload_path', path.join(nconf.get('base_dir'), nconf.get('upload_path')));
+			enableDefaultPlugins(next);
+		},
+		function (next) {
+			meta.themes.set({
+				type: 'local',
+				id: 'nodebb-theme-persona',
+			}, next);
+		},
+		function (next) {
+			// nconf defaults, if not set in config
+			if (!nconf.get('sessionKey')) {
+				nconf.set('sessionKey', 'express.sid');
+			}
+			// Parse out the relative_url and other goodies from the configured URL
+			var urlObject = url.parse(nconf.get('url'));
+			var relativePath = urlObject.pathname !== '/' ? urlObject.pathname : '';
+			nconf.set('base_url', urlObject.protocol + '//' + urlObject.host);
+			nconf.set('secure', urlObject.protocol === 'https:');
+			nconf.set('use_port', !!urlObject.port);
+			nconf.set('relative_path', relativePath);
+			nconf.set('port', urlObject.port || nconf.get('port') || nconf.get('PORT') || (nconf.get('PORT_ENV_VAR') ? nconf.get(nconf.get('PORT_ENV_VAR')) : false) || 4567);
+			nconf.set('upload_path', path.join(nconf.get('base_dir'), nconf.get('upload_path')));
 
-				nconf.set('core_templates_path', path.join(__dirname, '../../src/views'));
-				nconf.set('base_templates_path', path.join(nconf.get('themes_path'), 'nodebb-theme-persona/templates'));
-				nconf.set('theme_templates_path', meta.config['theme:templates'] ? path.join(nconf.get('themes_path'), meta.config['theme:id'], meta.config['theme:templates']) : nconf.get('base_templates_path'));
-				nconf.set('theme_config', path.join(nconf.get('themes_path'), 'nodebb-theme-persona', 'theme.json'));
-				nconf.set('bcrypt_rounds', 1);
+			nconf.set('core_templates_path', path.join(__dirname, '../../src/views'));
+			nconf.set('base_templates_path', path.join(nconf.get('themes_path'), 'nodebb-theme-persona/templates'));
+			nconf.set('theme_templates_path', meta.config['theme:templates'] ? path.join(nconf.get('themes_path'), meta.config['theme:id'], meta.config['theme:templates']) : nconf.get('base_templates_path'));
+			nconf.set('theme_config', path.join(nconf.get('themes_path'), 'nodebb-theme-persona', 'theme.json'));
+			nconf.set('bcrypt_rounds', 1);
 
-				next();
-			},
-			function (next) {
-				var	webserver = require('../../src/webserver');
-				var sockets = require('../../src/socket.io');
-				sockets.init(webserver.server);
+			next();
+		},
+		function (next) {
+			var	webserver = require('../../src/webserver');
+			var sockets = require('../../src/socket.io');
+			sockets.init(webserver.server);
 
-				require('../../src/notifications').startJobs();
-				require('../../src/user').startJobs();
+			require('../../src/notifications').startJobs();
+			require('../../src/user').startJobs();
 
-				webserver.listen(next);
-			},
-		], done);
-	});
+			webserver.listen(next);
+		},
+	], done);
+});
 
-	function setupDefaultConfigs(meta, next) {
-		winston.info('Populating database with default configs, if not already set...\n');
+function setupDefaultConfigs(meta, next) {
+	winston.info('Populating database with default configs, if not already set...\n');
 
-		var defaults = require(path.join(nconf.get('base_dir'), 'install/data/defaults.json'));
+	var defaults = require(path.join(nconf.get('base_dir'), 'install/data/defaults.json'));
 
-		meta.configs.setOnEmpty(defaults, next);
-	}
+	meta.configs.setOnEmpty(defaults, next);
+}
 
-	function enableDefaultPlugins(callback) {
-		winston.info('Enabling default plugins\n');
+function enableDefaultPlugins(callback) {
+	winston.info('Enabling default plugins\n');
 
-		var defaultEnabled = [
-			'nodebb-plugin-dbsearch',
-		];
+	var defaultEnabled = [
+		'nodebb-plugin-dbsearch',
+	];
 
-		winston.info('[install/enableDefaultPlugins] activating default plugins', defaultEnabled);
+	winston.info('[install/enableDefaultPlugins] activating default plugins', defaultEnabled);
 
-		db.sortedSetAdd('plugins:active', [0], defaultEnabled, callback);
-	}
-
-	module.exports = db;
-}(module));
+	db.sortedSetAdd('plugins:active', [0], defaultEnabled, callback);
+}

From c364cebbe490489637432906d9989bb2d06349ad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Sat, 20 May 2017 20:20:53 -0400
Subject: [PATCH 24/42] more tests

---
 test/messaging.js | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/test/messaging.js b/test/messaging.js
index a009d5ad21..5a9b0ac4a3 100644
--- a/test/messaging.js
+++ b/test/messaging.js
@@ -339,7 +339,7 @@ describe('Messaging Library', function () {
 		});
 
 		it('should not error if user is not in room', function (done) {
-			socketModules.chats.markRead({ uid: herpUid }, roomId, function (err) {
+			socketModules.chats.markRead({ uid: herpUid }, 10, function (err) {
 				assert.ifError(err);
 				done();
 			});
@@ -511,6 +511,13 @@ describe('Messaging Library', function () {
 			});
 		});
 
+		it('should fail to delete message if not owner', function (done) {
+			socketModules.chats.delete({ uid: herpUid }, { messageId: mid, roomId: roomId }, function (err) {
+				assert.equal(err.message, '[[error:cant-delete-chat-message]]');
+				done();
+			});
+		});
+
 
 		it('should delete message', function (done) {
 			socketModules.chats.delete({ uid: fooUid }, { messageId: mid, roomId: roomId }, function (err) {

From 59387540c757658fa6509a4767a8bd683897a92e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Sat, 20 May 2017 20:26:54 -0400
Subject: [PATCH 25/42] style

---
 src/messaging/rooms.js | 48 ++++++++++++++++++++++++------------------
 1 file changed, 28 insertions(+), 20 deletions(-)

diff --git a/src/messaging/rooms.js b/src/messaging/rooms.js
index ead62fee4d..0d7e1d2b1f 100644
--- a/src/messaging/rooms.js
+++ b/src/messaging/rooms.js
@@ -9,26 +9,33 @@ var plugins = require('../plugins');
 
 module.exports = function (Messaging) {
 	Messaging.getRoomData = function (roomId, callback) {
-		db.getObject('chat:room:' + roomId, function (err, data) {
-			if (err || !data) {
-				return callback(err || new Error('[[error:no-chat-room]]'));
-			}
-			modifyRoomData([data]);
-			callback(null, data);
-		});
+		async.waterfall([
+			function (next) {
+				db.getObject('chat:room:' + roomId, next);
+			},
+			function (data, next) {
+				if (!data) {
+					return callback(new Error('[[error:no-chat-room]]'));
+				}
+				modifyRoomData([data]);
+				next(null, data);
+			},
+		], callback);
 	};
 
 	Messaging.getRoomsData = function (roomIds, callback) {
 		var keys = roomIds.map(function (roomId) {
 			return 'chat:room:' + roomId;
 		});
-		db.getObjects(keys, function (err, roomData) {
-			if (err) {
-				return callback(err);
+		async.waterfall([
+			function (next) {
+				db.getObjects(keys, next);
+			},
+			function (roomData, next) {
+				modifyRoomData(roomData);
+				next(null, roomData);
 			}
-			modifyRoomData(roomData);
-			callback(null, roomData);
-		});
+		], callback);
 	};
 
 	function modifyRoomData(rooms) {
@@ -96,13 +103,14 @@ module.exports = function (Messaging) {
 	};
 
 	Messaging.isRoomOwner = function (uid, roomId, callback) {
-		db.getObjectField('chat:room:' + roomId, 'owner', function (err, owner) {
-			if (err) {
-				return callback(err);
-			}
-
-			callback(null, parseInt(uid, 10) === parseInt(owner, 10));
-		});
+		async.waterfall([
+			function (next) {
+				db.getObjectField('chat:room:' + roomId, 'owner', next);
+			},
+			function (owner, next) {
+				next(null, parseInt(uid, 10) === parseInt(owner, 10));
+			},
+		], callback);
 	};
 
 	Messaging.addUsersToRoom = function (uid, uids, roomId, callback) {

From 9af252b8998932fdced017f380df1b7f1dcea7ed Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Sat, 20 May 2017 21:01:55 -0400
Subject: [PATCH 26/42] notifications tests

---
 src/messaging/rooms.js   |   2 +-
 src/notifications.js     | 145 ++++++++++++++++++++-------------------
 src/socket.io/helpers.js |  33 +++++----
 test/notifications.js    |  96 +++++++++++++++++++++++++-
 4 files changed, 187 insertions(+), 89 deletions(-)

diff --git a/src/messaging/rooms.js b/src/messaging/rooms.js
index 0d7e1d2b1f..41f09c5125 100644
--- a/src/messaging/rooms.js
+++ b/src/messaging/rooms.js
@@ -34,7 +34,7 @@ module.exports = function (Messaging) {
 			function (roomData, next) {
 				modifyRoomData(roomData);
 				next(null, roomData);
-			}
+			},
 		], callback);
 	};
 
diff --git a/src/notifications.js b/src/notifications.js
index 931e0ad293..d5505f88dd 100644
--- a/src/notifications.js
+++ b/src/notifications.js
@@ -29,7 +29,7 @@ Notifications.get = function (nid, callback) {
 };
 
 Notifications.getMultiple = function (nids, callback) {
-	if (!nids.length) {
+	if (!Array.isArray(nids) || !nids.length) {
 		return setImmediate(callback, null, []);
 	}
 	var keys = nids.map(function (nid) {
@@ -106,50 +106,47 @@ Notifications.findRelated = function (mergeIds, set, callback) {
 
 			db.getObjectsFields(keys, ['mergeId'], next);
 		},
-	], function (err, sets) {
-		if (err) {
-			return callback(err);
-		}
+		function (sets, next) {
+			sets = sets.map(function (set) {
+				return set.mergeId;
+			});
 
-		sets = sets.map(function (set) {
-			return set.mergeId;
-		});
-
-		callback(null, _nids.filter(function (nid, idx) {
-			return mergeIds.indexOf(sets[idx]) !== -1;
-		}));
-	});
+			next(null, _nids.filter(function (nid, idx) {
+				return mergeIds.indexOf(sets[idx]) !== -1;
+			}));
+		},
+	], callback);
 };
 
 Notifications.create = function (data, callback) {
 	if (!data.nid) {
-		return callback(new Error('no-notification-id'));
+		return callback(new Error('[[error:no-notification-id]]'));
 	}
 	data.importance = data.importance || 5;
-	db.getObject('notifications:' + data.nid, function (err, oldNotification) {
-		if (err) {
-			return callback(err);
-		}
-
-		if (oldNotification) {
-			if (parseInt(oldNotification.pid, 10) === parseInt(data.pid, 10) && parseInt(oldNotification.importance, 10) > parseInt(data.importance, 10)) {
-				return callback(null, null);
+	async.waterfall([
+		function (next) {
+			db.getObject('notifications:' + data.nid, next);
+		},
+		function (oldNotification, next) {
+			if (oldNotification) {
+				if (parseInt(oldNotification.pid, 10) === parseInt(data.pid, 10) && parseInt(oldNotification.importance, 10) > parseInt(data.importance, 10)) {
+					return callback(null, null);
+				}
 			}
-		}
-
-		var now = Date.now();
-		data.datetime = now;
-		async.parallel([
-			function (next) {
-				db.sortedSetAdd('notifications', now, data.nid, next);
-			},
-			function (next) {
-				db.setObject('notifications:' + data.nid, data, next);
-			},
-		], function (err) {
-			callback(err, data);
-		});
-	});
+			var now = Date.now();
+			data.datetime = now;
+			async.parallel([
+				function (next) {
+					db.sortedSetAdd('notifications', now, data.nid, next);
+				},
+				function (next) {
+					db.setObject('notifications:' + data.nid, data, next);
+				},
+			], function (err) {
+				next(err, data);
+			});
+		},
+	], callback);
 };
 
 Notifications.push = function (notification, uids, callback) {
@@ -233,25 +230,31 @@ function pushToUids(uids, notification, callback) {
 
 Notifications.pushGroup = function (notification, groupName, callback) {
 	callback = callback || function () {};
-	groups.getMembers(groupName, 0, -1, function (err, members) {
-		if (err || !Array.isArray(members) || !members.length) {
-			return callback(err);
-		}
+	async.waterfall([
+		function (next) {
+			groups.getMembers(groupName, 0, -1, next);
+		},
+		function (members, next) {
+			if (!Array.isArray(members) || !members.length) {
+				return callback();
+			}
 
-		Notifications.push(notification, members, callback);
-	});
+			Notifications.push(notification, members, next);
+		},
+	], callback);
 };
 
 Notifications.pushGroups = function (notification, groupNames, callback) {
 	callback = callback || function () {};
-	groups.getMembersOfGroups(groupNames, function (err, groupMembers) {
-		if (err) {
-			return callback(err);
-		}
-
-		var members = _.unique(_.flatten(groupMembers));
-		Notifications.push(notification, members, callback);
-	});
+	async.waterfall([
+		function (next) {
+			groups.getMembersOfGroups(groupNames, next);
+		},
+		function (groupMembers, next) {
+			var members = _.unique(_.flatten(groupMembers));
+			Notifications.push(notification, members, next);
+		},
+	], callback);
 };
 
 Notifications.rescind = function (nid, callback) {
@@ -261,13 +264,7 @@ Notifications.rescind = function (nid, callback) {
 		async.apply(db.sortedSetRemove, 'notifications', nid),
 		async.apply(db.delete, 'notifications:' + nid),
 	], function (err) {
-		if (err) {
-			winston.error('Encountered error rescinding notification (' + nid + '): ' + err.message);
-		} else {
-			winston.verbose('[notifications/rescind] Rescinded notification "' + nid + '"');
-		}
-
-		callback(err, nid);
+		callback(err);
 	});
 };
 
@@ -284,18 +281,22 @@ Notifications.markUnread = function (nid, uid, callback) {
 	if (!parseInt(uid, 10) || !nid) {
 		return callback();
 	}
+	async.waterfall([
+		function (next) {
+			db.getObject('notifications:' + nid, next);
+		},
+		function (notification, next) {
+			if (!notification) {
+				return callback(new Error('[[error:no-notification]]'));
+			}
+			notification.datetime = notification.datetime || Date.now();
 
-	db.getObject('notifications:' + nid, function (err, notification) {
-		if (err || !notification) {
-			return callback(err || new Error('[[error:no-notification]]'));
-		}
-		notification.datetime = notification.datetime || Date.now();
-
-		async.parallel([
-			async.apply(db.sortedSetRemove, 'uid:' + uid + ':notifications:read', nid),
-			async.apply(db.sortedSetAdd, 'uid:' + uid + ':notifications:unread', notification.datetime, nid),
-		], callback);
-	});
+			async.parallel([
+				async.apply(db.sortedSetRemove, 'uid:' + uid + ':notifications:read', nid),
+				async.apply(db.sortedSetAdd, 'uid:' + uid + ':notifications:unread', notification.datetime, nid),
+			], next);
+		},
+	], callback);
 };
 
 Notifications.markReadMultiple = function (nids, uid, callback) {
@@ -377,9 +378,9 @@ Notifications.markAllRead = function (uid, callback) {
 
 Notifications.prune = function (callback) {
 	callback = callback || function () {};
-	var	week = 604800000;
+	var week = 604800000;
 
-	var	cutoffTime = Date.now() - week;
+	var cutoffTime = Date.now() - week;
 
 	async.waterfall([
 		function (next) {
@@ -390,7 +391,7 @@ Notifications.prune = function (callback) {
 				return callback();
 			}
 
-			var	keys = nids.map(function (nid) {
+			var keys = nids.map(function (nid) {
 				return 'notifications:' + nid;
 			});
 
diff --git a/src/socket.io/helpers.js b/src/socket.io/helpers.js
index 241937d5fb..9eedab2fb0 100644
--- a/src/socket.io/helpers.js
+++ b/src/socket.io/helpers.js
@@ -169,21 +169,26 @@ SocketHelpers.sendNotificationToTopicOwner = function (tid, fromuid, command, no
 };
 
 SocketHelpers.rescindUpvoteNotification = function (pid, fromuid) {
-	var nid = 'upvote:post:' + pid + ':uid:' + fromuid;
-	notifications.rescind(nid);
-
-	posts.getPostField(pid, 'uid', function (err, uid) {
-		if (err) {
-			return winston.error(err);
-		}
-
-		user.notifications.getUnreadCount(uid, function (err, count) {
-			if (err) {
-				return winston.error(err);
-			}
-
+	var uid;
+	async.waterfall([
+		function (next) {
+			notifications.rescind('upvote:post:' + pid + ':uid:' + fromuid, next);
+		},
+		function (next) {
+			posts.getPostField(pid, 'uid', next);
+		},
+		function (_uid, next) {
+			uid = _uid;
+			user.notifications.getUnreadCount(uid, next);
+		},
+		function (count, next) {
 			websockets.in('uid_' + uid).emit('event:notifications.updateCount', count);
-		});
+			next();
+		},
+	], function (err) {
+		if (err) {
+			winston.error(err);
+		}
 	});
 };
 
diff --git a/test/notifications.js b/test/notifications.js
index c5a22a6d2c..fbbf4fd49b 100644
--- a/test/notifications.js
+++ b/test/notifications.js
@@ -24,11 +24,19 @@ describe('Notifications', function () {
 		});
 	});
 
+	it('should fail to create notification without a nid', function (done) {
+		notifications.create({}, function (err) {
+			assert.equal(err.message, '[[error:no-notification-id]]');
+			done();
+		});
+	});
+
 	it('should create a notification', function (done) {
 		notifications.create({
 			bodyShort: 'bodyShort',
 			nid: 'notification_id',
 			path: '/notification/path',
+			pid: 1,
 		}, function (err, _notification) {
 			notification = _notification;
 			assert.ifError(err);
@@ -45,6 +53,29 @@ describe('Notifications', function () {
 		});
 	});
 
+	it('should return null if pid is same and importance is lower', function (done) {
+		notifications.create({
+			bodyShort: 'bodyShort',
+			nid: 'notification_id',
+			path: '/notification/path',
+			pid: 1,
+			importance: 1,
+		}, function (err, notification) {
+			assert.ifError(err);
+			assert.strictEqual(notification, null);
+			done();
+		});
+	});
+
+	it('should get empty array', function (done) {
+		notifications.getMultiple(null, function (err, data) {
+			assert.ifError(err);
+			assert(Array.isArray(data));
+			assert.equal(data.length, 0);
+			done();
+		});
+	});
+
 	it('should get notifications', function (done) {
 		notifications.getMultiple([notification.nid], function (err, notificationsData) {
 			assert.ifError(err);
@@ -55,6 +86,19 @@ describe('Notifications', function () {
 		});
 	});
 
+	it('should do nothing', function (done) {
+		notifications.push(null, [], function (err) {
+			assert.ifError(err);
+			notifications.push({ nid: null }, [], function (err) {
+				assert.ifError(err);
+				notifications.push(notification, [], function (err) {
+					assert.ifError(err);
+					done();
+				});
+			});
+		});
+	});
+
 	it('should push a notification to uid', function (done) {
 		notifications.push(notification, [uid], function (err) {
 			assert.ifError(err);
@@ -94,6 +138,16 @@ describe('Notifications', function () {
 		});
 	});
 
+	it('should not mark anything with invalid uid or nid', function (done) {
+		socketNotifications.markRead({ uid: null }, null, function (err) {
+			assert.ifError(err);
+			socketNotifications.markRead({ uid: uid }, null, function (err) {
+				assert.ifError(err);
+				done();
+			});
+		});
+	});
+
 	it('should mark a notification read', function (done) {
 		socketNotifications.markRead({ uid: uid }, notification.nid, function (err) {
 			assert.ifError(err);
@@ -109,6 +163,23 @@ describe('Notifications', function () {
 		});
 	});
 
+	it('should not mark anything with invalid uid or nid', function (done) {
+		socketNotifications.markUnread({ uid: null }, null, function (err) {
+			assert.ifError(err);
+			socketNotifications.markUnread({ uid: uid }, null, function (err) {
+				assert.ifError(err);
+				done();
+			});
+		});
+	});
+
+	it('should error if notification does not exist', function (done) {
+		socketNotifications.markUnread({ uid: uid }, 123123, function (err) {
+			assert.equal(err.message, '[[error:no-notification]]');
+			done();
+		});
+	});
+
 	it('should mark a notification unread', function (done) {
 		socketNotifications.markUnread({ uid: uid }, notification.nid, function (err) {
 			assert.ifError(err);
@@ -143,6 +214,13 @@ describe('Notifications', function () {
 		});
 	});
 
+	it('should not do anything', function (done) {
+		socketNotifications.markAllRead({ uid: 1000 }, null, function (err) {
+			assert.ifError(err);
+			done();
+		});
+	});
+
 	it('should link to the first unread post in a watched topic', function (done) {
 		var categories = require('../src/categories');
 		var topics = require('../src/topics');
@@ -256,9 +334,23 @@ describe('Notifications', function () {
 			bodyShort: 'bodyShort',
 			nid: 'tobedeleted',
 			path: '/notification/path',
-		}, function (err) {
+		}, function (err, notification) {
 			assert.ifError(err);
-			notifications.prune(done);
+			notifications.prune(function (err) {
+				assert.ifError(err);
+				var week = 604800000;
+				db.sortedSetAdd('notifications', Date.now() - (2 * week), notification.nid, function (err) {
+					assert.ifError(err);
+					notifications.prune(function (err) {
+						assert.ifError(err);
+						notifications.get(notification.nid, function (err, data) {
+							assert.ifError(err);
+							assert(!data);
+							done();
+						});
+					});
+				});
+			});
 		});
 	});
 

From c5c755fbb0bcdebde136147d47718e22e509101c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Sat, 20 May 2017 22:30:12 -0400
Subject: [PATCH 27/42] more notification tests

---
 src/user/follow.js        |   4 +-
 src/user/notifications.js | 589 +++++++++++++++++++-------------------
 test/notifications.js     | 122 ++++++++
 3 files changed, 425 insertions(+), 290 deletions(-)

diff --git a/src/user/follow.js b/src/user/follow.js
index fe3dc0931d..d2056065b4 100644
--- a/src/user/follow.js
+++ b/src/user/follow.js
@@ -57,7 +57,9 @@ module.exports = function (User) {
 					], next);
 				}
 			},
-		], callback);
+		], function (err) {
+			callback(err);
+		});
 	}
 
 	User.getFollowing = function (uid, start, stop, callback) {
diff --git a/src/user/notifications.js b/src/user/notifications.js
index 318794fb20..953caeb2c2 100644
--- a/src/user/notifications.js
+++ b/src/user/notifications.js
@@ -10,16 +10,17 @@ var meta = require('../meta');
 var notifications = require('../notifications');
 var privileges = require('../privileges');
 
-(function (UserNotifications) {
-	UserNotifications.get = function (uid, callback) {
-		if (!parseInt(uid, 10)) {
-			return callback(null, { read: [], unread: [] });
-		}
-		getNotifications(uid, 0, 9, function (err, notifications) {
-			if (err) {
-				return callback(err);
-			}
+var UserNotifications = module.exports;
 
+UserNotifications.get = function (uid, callback) {
+	if (!parseInt(uid, 10)) {
+		return callback(null, { read: [], unread: [] });
+	}
+	async.waterfall([
+		function (next) {
+			getNotifications(uid, 0, 9, next);
+		},
+		function (notifications, next) {
 			notifications.read = notifications.read.filter(Boolean);
 			notifications.unread = notifications.unread.filter(Boolean);
 
@@ -28,200 +29,209 @@ var privileges = require('../privileges');
 				notifications.read.length = maxNotifs - notifications.unread.length;
 			}
 
-			callback(null, notifications);
-		});
-	};
+			next(null, notifications);
+		},
+	], callback);
+};
 
-	function filterNotifications(nids, filter, callback) {
-		if (!filter) {
-			return setImmediate(callback, null, nids);
-		}
-		async.waterfall([
-			function (next) {
-				var keys = nids.map(function (nid) {
-					return 'notifications:' + nid;
-				});
-				db.getObjectsFields(keys, ['nid', 'type'], next);
-			},
-			function (notifications, next) {
-				nids = notifications.filter(function (notification) {
-					return notification && notification.nid && notification.type === filter;
-				}).map(function (notification) {
-					return notification.nid;
-				});
-				next(null, nids);
-			},
-		], callback);
+function filterNotifications(nids, filter, callback) {
+	if (!filter) {
+		return setImmediate(callback, null, nids);
 	}
+	async.waterfall([
+		function (next) {
+			var keys = nids.map(function (nid) {
+				return 'notifications:' + nid;
+			});
+			db.getObjectsFields(keys, ['nid', 'type'], next);
+		},
+		function (notifications, next) {
+			nids = notifications.filter(function (notification) {
+				return notification && notification.nid && notification.type === filter;
+			}).map(function (notification) {
+				return notification.nid;
+			});
+			next(null, nids);
+		},
+	], callback);
+}
 
-	UserNotifications.getAll = function (uid, filter, callback) {
-		var nids;
-		async.waterfall([
-			function (next) {
-				async.parallel({
-					unread: function (next) {
-						db.getSortedSetRevRange('uid:' + uid + ':notifications:unread', 0, -1, next);
-					},
-					read: function (next) {
-						db.getSortedSetRevRange('uid:' + uid + ':notifications:read', 0, -1, next);
-					},
-				}, next);
-			},
-			function (results, next) {
-				nids = results.unread.concat(results.read);
-				db.isSortedSetMembers('notifications', nids, next);
-			},
-			function (exists, next) {
-				var deleteNids = [];
+UserNotifications.getAll = function (uid, filter, callback) {
+	var nids;
+	async.waterfall([
+		function (next) {
+			async.parallel({
+				unread: function (next) {
+					db.getSortedSetRevRange('uid:' + uid + ':notifications:unread', 0, -1, next);
+				},
+				read: function (next) {
+					db.getSortedSetRevRange('uid:' + uid + ':notifications:read', 0, -1, next);
+				},
+			}, next);
+		},
+		function (results, next) {
+			nids = results.unread.concat(results.read);
+			db.isSortedSetMembers('notifications', nids, next);
+		},
+		function (exists, next) {
+			var deleteNids = [];
 
-				nids = nids.filter(function (nid, index) {
-					if (!nid || !exists[index]) {
-						deleteNids.push(nid);
-					}
-					return nid && exists[index];
-				});
-
-				deleteUserNids(deleteNids, uid, next);
-			},
-			function (next) {
-				filterNotifications(nids, filter, next);
-			},
-		], callback);
-	};
-
-	function deleteUserNids(nids, uid, callback) {
-		callback = callback || function () {};
-		if (!nids.length) {
-			return setImmediate(callback);
-		}
-		async.parallel([
-			function (next) {
-				db.sortedSetRemove('uid:' + uid + ':notifications:read', nids, next);
-			},
-			function (next) {
-				db.sortedSetRemove('uid:' + uid + ':notifications:unread', nids, next);
-			},
-		], function (err) {
-			callback(err);
-		});
-	}
-
-	function getNotifications(uid, start, stop, callback) {
-		async.parallel({
-			unread: function (next) {
-				getNotificationsFromSet('uid:' + uid + ':notifications:unread', false, uid, start, stop, next);
-			},
-			read: function (next) {
-				getNotificationsFromSet('uid:' + uid + ':notifications:read', true, uid, start, stop, next);
-			},
-		}, callback);
-	}
-
-	function getNotificationsFromSet(set, read, uid, start, stop, callback) {
-		async.waterfall([
-			function (next) {
-				db.getSortedSetRevRange(set, start, stop, next);
-			},
-			function (nids, next) {
-				if (!Array.isArray(nids) || !nids.length) {
-					return callback(null, []);
+			nids = nids.filter(function (nid, index) {
+				if (!nid || !exists[index]) {
+					deleteNids.push(nid);
 				}
+				return nid && exists[index];
+			});
 
-				UserNotifications.getNotifications(nids, uid, next);
-			},
-		], callback);
+			deleteUserNids(deleteNids, uid, next);
+		},
+		function (next) {
+			filterNotifications(nids, filter, next);
+		},
+	], callback);
+};
+
+function deleteUserNids(nids, uid, callback) {
+	callback = callback || function () {};
+	if (!nids.length) {
+		return setImmediate(callback);
 	}
+	async.parallel([
+		function (next) {
+			db.sortedSetRemove('uid:' + uid + ':notifications:read', nids, next);
+		},
+		function (next) {
+			db.sortedSetRemove('uid:' + uid + ':notifications:unread', nids, next);
+		},
+	], function (err) {
+		callback(err);
+	});
+}
 
-	UserNotifications.getNotifications = function (nids, uid, callback) {
-		var notificationData = [];
-		async.waterfall([
-			function (next) {
-				async.parallel({
-					notifications: function (next) {
-						notifications.getMultiple(nids, next);
-					},
-					hasRead: function (next) {
-						db.isSortedSetMembers('uid:' + uid + ':notifications:read', nids, next);
-					},
-				}, next);
-			},
-			function (results, next) {
-				var deletedNids = [];
-				notificationData = results.notifications.filter(function (notification, index) {
-					if (!notification || !notification.nid) {
-						deletedNids.push(nids[index]);
-					}
-					if (notification) {
-						notification.read = results.hasRead[index];
-						notification.readClass = !notification.read ? 'unread' : '';
-					}
-
-					return notification && notification.path;
-				});
-
-				deleteUserNids(deletedNids, uid, next);
-			},
-			function (next) {
-				notifications.merge(notificationData, next);
-			},
-		], callback);
-	};
-
-	UserNotifications.getDailyUnread = function (uid, callback) {
-		var yesterday = Date.now() - (1000 * 60 * 60 * 24);	// Approximate, can be more or less depending on time changes, makes no difference really.
-
-		db.getSortedSetRevRangeByScore('uid:' + uid + ':notifications:unread', 0, 20, '+inf', yesterday, function (err, nids) {
-			if (err) {
-				return callback(err);
-			}
+function getNotifications(uid, start, stop, callback) {
+	async.parallel({
+		unread: function (next) {
+			getNotificationsFromSet('uid:' + uid + ':notifications:unread', false, uid, start, stop, next);
+		},
+		read: function (next) {
+			getNotificationsFromSet('uid:' + uid + ':notifications:read', true, uid, start, stop, next);
+		},
+	}, callback);
+}
 
+function getNotificationsFromSet(set, read, uid, start, stop, callback) {
+	async.waterfall([
+		function (next) {
+			db.getSortedSetRevRange(set, start, stop, next);
+		},
+		function (nids, next) {
 			if (!Array.isArray(nids) || !nids.length) {
 				return callback(null, []);
 			}
 
-			UserNotifications.getNotifications(nids, uid, callback);
-		});
-	};
+			UserNotifications.getNotifications(nids, uid, next);
+		},
+	], callback);
+}
 
-	UserNotifications.getUnreadCount = function (uid, callback) {
-		if (!parseInt(uid, 10)) {
-			return callback(null, 0);
-		}
+UserNotifications.getNotifications = function (nids, uid, callback) {
+	var notificationData = [];
+	async.waterfall([
+		function (next) {
+			async.parallel({
+				notifications: function (next) {
+					notifications.getMultiple(nids, next);
+				},
+				hasRead: function (next) {
+					db.isSortedSetMembers('uid:' + uid + ':notifications:read', nids, next);
+				},
+			}, next);
+		},
+		function (results, next) {
+			var deletedNids = [];
+			notificationData = results.notifications.filter(function (notification, index) {
+				if (!notification || !notification.nid) {
+					deletedNids.push(nids[index]);
+				}
+				if (notification) {
+					notification.read = results.hasRead[index];
+					notification.readClass = !notification.read ? 'unread' : '';
+				}
 
-		// Collapse any notifications with identical mergeIds
-		async.waterfall([
-			async.apply(db.getSortedSetRevRange, 'uid:' + uid + ':notifications:unread', 0, 99),
-			async.apply(notifications.filterExists),
-			function (nids, next) {
-				var keys = nids.map(function (nid) {
-					return 'notifications:' + nid;
-				});
+				return notification && notification.path;
+			});
 
-				db.getObjectsFields(keys, ['mergeId'], next);
-			},
-			function (mergeIds, next) {
-				mergeIds = mergeIds.map(function (set) {
-					return set.mergeId;
-				});
+			deleteUserNids(deletedNids, uid, next);
+		},
+		function (next) {
+			notifications.merge(notificationData, next);
+		},
+	], callback);
+};
 
-				next(null, mergeIds.reduce(function (count, mergeId, idx, arr) {
-					// A missing (null) mergeId means that notification is counted separately.
-					if (mergeId === null || idx === arr.indexOf(mergeId)) {
-						count += 1;
-					}
+UserNotifications.getDailyUnread = function (uid, callback) {
+	var yesterday = Date.now() - (1000 * 60 * 60 * 24);	// Approximate, can be more or less depending on time changes, makes no difference really.
 
-					return count;
-				}, 0));
-			},
-		], callback);
-	};
-
-	UserNotifications.getUnreadByField = function (uid, field, values, callback) {
-		db.getSortedSetRevRange('uid:' + uid + ':notifications:unread', 0, 99, function (err, nids) {
-			if (err) {
-				return callback(err);
+	async.waterfall([
+		function (next) {
+			db.getSortedSetRevRangeByScore('uid:' + uid + ':notifications:unread', 0, 20, '+inf', yesterday, next);
+		},
+		function (nids, next) {
+			if (!Array.isArray(nids) || !nids.length) {
+				return callback(null, []);
 			}
 
+			UserNotifications.getNotifications(nids, uid, next);
+		},
+	], callback);
+};
+
+UserNotifications.getUnreadCount = function (uid, callback) {
+	if (!parseInt(uid, 10)) {
+		return callback(null, 0);
+	}
+
+
+	async.waterfall([
+		function (next) {
+			db.getSortedSetRevRange('uid:' + uid + ':notifications:unread', 0, 99, next);
+		},
+		function (nids, next) {
+			notifications.filterExists(nids, next);
+		},
+		function (nids, next) {
+			var keys = nids.map(function (nid) {
+				return 'notifications:' + nid;
+			});
+
+			db.getObjectsFields(keys, ['mergeId'], next);
+		},
+		function (mergeIds, next) {
+			// Collapse any notifications with identical mergeIds
+			mergeIds = mergeIds.map(function (set) {
+				return set.mergeId;
+			});
+
+			next(null, mergeIds.reduce(function (count, mergeId, idx, arr) {
+				// A missing (null) mergeId means that notification is counted separately.
+				if (mergeId === null || idx === arr.indexOf(mergeId)) {
+					count += 1;
+				}
+
+				return count;
+			}, 0));
+		},
+	], callback);
+};
+
+UserNotifications.getUnreadByField = function (uid, field, values, callback) {
+	var nids;
+	async.waterfall([
+		function (next) {
+			db.getSortedSetRevRange('uid:' + uid + ':notifications:unread', 0, 99, next);
+		},
+		function (_nids, next) {
+			nids = _nids;
 			if (!Array.isArray(nids) || !nids.length) {
 				return callback(null, []);
 			}
@@ -230,124 +240,125 @@ var privileges = require('../privileges');
 				return 'notifications:' + nid;
 			});
 
-			db.getObjectsFields(keys, ['nid', field], function (err, notifications) {
-				if (err) {
-					return callback(err);
-				}
-
-				values = values.map(function () { return values.toString(); });
-				nids = notifications.filter(function (notification) {
-					return notification && notification[field] && values.indexOf(notification[field].toString()) !== -1;
-				}).map(function (notification) {
-					return notification.nid;
-				});
-
-				callback(null, nids);
+			db.getObjectsFields(keys, ['nid', field], next);
+		},
+		function (notifications, next) {
+			values = values.map(function () { return values.toString(); });
+			nids = notifications.filter(function (notification) {
+				return notification && notification[field] && values.indexOf(notification[field].toString()) !== -1;
+			}).map(function (notification) {
+				return notification.nid;
 			});
-		});
-	};
 
-	UserNotifications.deleteAll = function (uid, callback) {
-		if (!parseInt(uid, 10)) {
-			return callback();
-		}
-		async.parallel([
-			function (next) {
-				db.delete('uid:' + uid + ':notifications:unread', next);
-			},
-			function (next) {
-				db.delete('uid:' + uid + ':notifications:read', next);
-			},
-		], callback);
-	};
+			next(null, nids);
+		},
+	], callback);
+};
 
-	UserNotifications.sendTopicNotificationToFollowers = function (uid, topicData, postData) {
-		var followers;
-		async.waterfall([
-			function (next) {
-				db.getSortedSetRange('followers:' + uid, 0, -1, next);
-			},
-			function (followers, next) {
-				if (!Array.isArray(followers) || !followers.length) {
-					return;
-				}
-				privileges.categories.filterUids('read', topicData.cid, followers, next);
-			},
-			function (_followers, next) {
-				followers = _followers;
-				if (!followers.length) {
-					return;
-				}
+UserNotifications.deleteAll = function (uid, callback) {
+	if (!parseInt(uid, 10)) {
+		return callback();
+	}
+	async.parallel([
+		function (next) {
+			db.delete('uid:' + uid + ':notifications:unread', next);
+		},
+		function (next) {
+			db.delete('uid:' + uid + ':notifications:read', next);
+		},
+	], callback);
+};
 
-				var title = topicData.title;
-				if (title) {
-					title = S(title).decodeHTMLEntities().s;
-				}
-
-				notifications.create({
-					type: 'new-topic',
-					bodyShort: '[[notifications:user_posted_topic, ' + postData.user.username + ', ' + title + ']]',
-					bodyLong: postData.content,
-					pid: postData.pid,
-					path: '/post/' + postData.pid,
-					nid: 'tid:' + postData.tid + ':uid:' + uid,
-					tid: postData.tid,
-					from: uid,
-				}, next);
-			},
-		], function (err, notification) {
-			if (err) {
-				return winston.error(err);
+UserNotifications.sendTopicNotificationToFollowers = function (uid, topicData, postData) {
+	var followers;
+	async.waterfall([
+		function (next) {
+			db.getSortedSetRange('followers:' + uid, 0, -1, next);
+		},
+		function (followers, next) {
+			if (!Array.isArray(followers) || !followers.length) {
+				return;
+			}
+			privileges.categories.filterUids('read', topicData.cid, followers, next);
+		},
+		function (_followers, next) {
+			followers = _followers;
+			if (!followers.length) {
+				return;
 			}
 
-			if (notification) {
-				notifications.push(notification, followers);
+			var title = topicData.title;
+			if (title) {
+				title = S(title).decodeHTMLEntities().s;
 			}
-		});
-	};
 
-	UserNotifications.sendWelcomeNotification = function (uid, callback) {
-		callback = callback || function () {};
-		if (!meta.config.welcomeNotification) {
-			return callback();
+			notifications.create({
+				type: 'new-topic',
+				bodyShort: '[[notifications:user_posted_topic, ' + postData.user.username + ', ' + title + ']]',
+				bodyLong: postData.content,
+				pid: postData.pid,
+				path: '/post/' + postData.pid,
+				nid: 'tid:' + postData.tid + ':uid:' + uid,
+				tid: postData.tid,
+				from: uid,
+			}, next);
+		},
+	], function (err, notification) {
+		if (err) {
+			return winston.error(err);
 		}
 
-		var path = meta.config.welcomeLink ? meta.config.welcomeLink : '#';
+		if (notification) {
+			notifications.push(notification, followers);
+		}
+	});
+};
 
-		notifications.create({
-			bodyShort: meta.config.welcomeNotification,
-			path: path,
-			nid: 'welcome_' + uid,
-		}, function (err, notification) {
-			if (err || !notification) {
-				return callback(err);
+UserNotifications.sendWelcomeNotification = function (uid, callback) {
+	callback = callback || function () {};
+	if (!meta.config.welcomeNotification) {
+		return callback();
+	}
+
+	var path = meta.config.welcomeLink ? meta.config.welcomeLink : '#';
+
+	async.waterfall([
+		function (next) {
+			notifications.create({
+				bodyShort: meta.config.welcomeNotification,
+				path: path,
+				nid: 'welcome_' + uid,
+			}, next);
+		},
+		function (notification, next) {
+			if (!notification) {
+				return next();
 			}
+			notifications.push(notification, [uid], next);
+		},
+	], callback);
+};
 
-			notifications.push(notification, [uid], callback);
-		});
-	};
+UserNotifications.sendNameChangeNotification = function (uid, username) {
+	notifications.create({
+		bodyShort: '[[user:username_taken_workaround, ' + username + ']]',
+		image: 'brand:logo',
+		nid: 'username_taken:' + uid,
+		datetime: Date.now(),
+	}, function (err, notification) {
+		if (!err && notification) {
+			notifications.push(notification, uid);
+		}
+	});
+};
 
-	UserNotifications.sendNameChangeNotification = function (uid, username) {
-		notifications.create({
-			bodyShort: '[[user:username_taken_workaround, ' + username + ']]',
-			image: 'brand:logo',
-			nid: 'username_taken:' + uid,
-			datetime: Date.now(),
-		}, function (err, notification) {
-			if (!err && notification) {
-				notifications.push(notification, uid);
-			}
-		});
-	};
+UserNotifications.pushCount = function (uid) {
+	var websockets = require('./../socket.io');
+	UserNotifications.getUnreadCount(uid, function (err, count) {
+		if (err) {
+			return winston.error(err.stack);
+		}
 
-	UserNotifications.pushCount = function (uid) {
-		var websockets = require('./../socket.io');
-		UserNotifications.getUnreadCount(uid, function (err, count) {
-			if (err) {
-				return winston.error(err.stack);
-			}
-
-			websockets.in('uid_' + uid).emit('event:notifications.updateCount', count);
-		});
-	};
-}(exports));
+		websockets.in('uid_' + uid).emit('event:notifications.updateCount', count);
+	});
+};
diff --git a/test/notifications.js b/test/notifications.js
index fbbf4fd49b..d2585e4029 100644
--- a/test/notifications.js
+++ b/test/notifications.js
@@ -5,7 +5,11 @@ var assert = require('assert');
 var async = require('async');
 
 var db = require('./mocks/databasemock');
+var meta = require('../src/meta');
 var user = require('../src/user');
+var topics = require('../src/topics');
+var categories = require('../src/categories');
+var groups = require('../src/groups');
 var notifications = require('../src/notifications');
 var socketNotifications = require('../src/socket.io/notifications');
 
@@ -14,6 +18,7 @@ describe('Notifications', function () {
 	var notification;
 
 	before(function (done) {
+		groups.resetCache();
 		user.create({ username: 'poster' }, function (err, _uid) {
 			if (err) {
 				return done(err);
@@ -329,6 +334,123 @@ describe('Notifications', function () {
 		});
 	});
 
+	it('should return empty with falsy uid', function (done) {
+		user.notifications.get(0, function (err, data) {
+			assert.ifError(err);
+			assert.equal(data.read.length, 0);
+			assert.equal(data.unread.length, 0);
+			done();
+		});
+	});
+
+	it('should get all notifications and filter', function (done) {
+		var nid = 'willbefiltered';
+		notifications.create({
+			bodyShort: 'bodyShort',
+			nid: nid,
+			path: '/notification/path',
+			type: 'post',
+		}, function (err, notification) {
+			assert.ifError(err);
+			notifications.push(notification, [uid], function (err) {
+				assert.ifError(err);
+				setTimeout(function () {
+					user.notifications.getAll(uid, 'post', function (err, nids) {
+						assert.ifError(err);
+						assert.notEqual(nids.indexOf(nid), -1);
+						done();
+					});
+				}, 1500);
+			});
+		});
+	});
+
+	it('should not get anything if notifications does not exist', function (done) {
+		user.notifications.getNotifications(['doesnotexistnid1', 'doesnotexistnid2'], uid, function (err, data) {
+			assert.ifError(err);
+			assert.deepEqual(data, []);
+			done();
+		});
+	});
+
+	it('should get daily notifications', function (done) {
+		user.notifications.getDailyUnread(uid, function (err, data) {
+			assert.ifError(err);
+			assert.equal(data[0].nid, 'willbefiltered');
+			done();
+		});
+	});
+
+	it('should return 0 for falsy uid', function (done) {
+		user.notifications.getUnreadCount(0, function (err, count) {
+			assert.ifError(err);
+			assert.equal(count, 0);
+			done();
+		});
+	});
+
+	it('should not do anything if uid is falsy', function (done) {
+		user.notifications.deleteAll(0, function (err) {
+			assert.ifError(err);
+			done();
+		});
+	});
+
+	it('should send notification to followers of user when he posts', function (done) {
+		var followerUid;
+		async.waterfall([
+			function (next) {
+				user.create({ username: 'follower' }, next);
+			},
+			function (_followerUid, next) {
+				followerUid = _followerUid;
+				user.follow(followerUid, uid, next);
+			},
+			function (next) {
+				categories.create({
+					name: 'Test Category',
+					description: 'Test category created by testing script',
+				}, next);
+			},
+			function (category, next) {
+				topics.post({
+					uid: uid,
+					cid: category.cid,
+					title: 'Test Topic Title',
+					content: 'The content of test topic',
+				}, next);
+			},
+			function (data, next) {
+				setTimeout(next, 1100);
+			},
+			function (next) {
+				user.notifications.getAll(followerUid, '', next);
+			},
+		], function (err, data) {
+			assert.ifError(err);
+			assert(data);
+			done();
+		});
+	});
+
+	it('should send welcome notification', function (done) {
+		meta.config.welcomeNotification = 'welcome to the forums';
+		user.notifications.sendWelcomeNotification(uid, function (err) {
+			assert.ifError(err);
+			user.notifications.sendWelcomeNotification(uid, function (err) {
+				assert.ifError(err);
+				setTimeout(function () {
+					user.notifications.getAll(uid, '', function (err, data) {
+						meta.config.welcomeNotification = '';
+						assert.ifError(err);
+						assert.notEqual(data.indexOf('welcome_' + uid), -1);
+						done();
+					});
+				}, 1100);
+			});
+		});
+	});
+
 	it('should prune notifications', function (done) {
 		notifications.create({
 			bodyShort: 'bodyShort',

From 57c5e0b554a02201ff7decb23fc37016e56e8b96 Mon Sep 17 00:00:00 2001
From: "Misty (Bot)" <deploy@nodebb.org>
Date: Sun, 21 May 2017 09:23:08 +0000
Subject: [PATCH 28/42] Latest translations and fallbacks

---
 public/language/es/admin/extend/plugins.json  | 12 ++---
 public/language/th/category.json              | 28 +++++------
 public/language/th/email.json                 | 48 +++++++++----------
 public/language/th/error.json                 | 32 ++++++-------
 public/language/th/uploads.json               |  8 ++--
 public/language/th/user.json                  |  2 +-
 .../tr/admin/appearance/customise.json        |  8 ++--
 .../language/tr/admin/appearance/skins.json   |  8 ++--
 .../language/tr/admin/appearance/themes.json  | 12 ++---
 public/language/tr/admin/general/sounds.json  |  6 +--
 .../language/tr/admin/manage/categories.json  | 40 ++++++++--------
 public/language/tr/admin/manage/users.json    |  6 +--
 public/language/tr/email.json                 |  8 ++--
 public/language/tr/modules.json               |  2 +-
 public/language/tr/notifications.json         |  2 +-
 15 files changed, 111 insertions(+), 111 deletions(-)

diff --git a/public/language/es/admin/extend/plugins.json b/public/language/es/admin/extend/plugins.json
index dba3e65d87..c2414d3a25 100644
--- a/public/language/es/admin/extend/plugins.json
+++ b/public/language/es/admin/extend/plugins.json
@@ -7,7 +7,7 @@
 	"none-active": "No hay Plug-ins activos",
 	"find-plugins": "Buscar Plug-in",
 
-	"plugin-search": "Plug-in de Búsqueda",
+	"plugin-search": "Buscar",
 	"plugin-search-placeholder": "Búscando Plug-in",
 	"reorder-plugins": "Re-ordenar Plug-ins",
 	"order-active": "Ordenar Plug-ins Activos",
@@ -18,14 +18,14 @@
 	"order.explanation": "Los plug-in son cargados en el orden especificado, de arriba a abajo.",
 	
 	"plugin-item.themes": "Temas",
-	"plugin-item.deactivate": "Desactivado",
-	"plugin-item.activate": "Activado",
+	"plugin-item.deactivate": "Desactivar",
+	"plugin-item.activate": "Activar",
 	"plugin-item.install": "Instalar",
 	"plugin-item.uninstall": "Desinstalar",
 	"plugin-item.settings": "Configuraciones",
 	"plugin-item.installed": "Instalados",
 	"plugin-item.latest": "Ultimos",
-	"plugin-item.upgrade": "Actualizado",
+	"plugin-item.upgrade": "Actualizar",
 	"plugin-item.more-info": "Para mas información:",
 	"plugin-item.unknown": "Desconocido",
 	"plugin-item.unknown-explanation": "El estado de este plug-in no puede determinsarse, posiblemente es debido a un error de configuración.",
@@ -35,9 +35,9 @@
 	"alert.upgraded": "Plug-in Actualizado",
 	"alert.installed": "Plug-in Instalado",
 	"alert.uninstalled": "Plug-in Desinstalado",
-	"alert.activate-success": "Por favor reinicia NodeBB para activar el plug-in por completo",
+	"alert.activate-success": "Por favor reiniciá NodeBB para activar el plug-in por completo",
 	"alert.deactivate-success": "Plugin successfully deactivated",
-	"alert.upgrade-success": "Please reload your NodeBB to fully upgrade this plugin",
+	"alert.upgrade-success": "Por favor recargá NodeBB para actualizar el plug-in por completo",
 	"alert.install-success": "Plugin successfully installed, please activate the plugin.",
 	"alert.uninstall-success": "The plugin has been successfully deactivated and uninstalled.",
 	"alert.suggest-error": "<p>NodeBB could not reach the package manager, proceed with installation of latest version?</p><div class=\"alert alert-danger\"><strong>Server returned (%1)</strong>: %2</div>",
diff --git a/public/language/th/category.json b/public/language/th/category.json
index 1802bb7f1b..8daa641ba5 100644
--- a/public/language/th/category.json
+++ b/public/language/th/category.json
@@ -1,20 +1,20 @@
 {
-    "category": "Category",
-    "subcategories": "Subcategories",
-    "new_topic_button": "กระทู้",
-    "guest-login-post": "เข้าสู่ระบบเพื่อโพส",
+    "category": "หมวดหมู่",
+    "subcategories": "หมวดหมู่ย่อย",
+    "new_topic_button": "ตั้งกระทู้",
+    "guest-login-post": "เข้าสู่ระบบเพื่อโพสต์",
     "no_topics": "<strong>ยังไม่มีกระทู้ในหมวดนี้</strong><br />โพสต์กระทู้แรก?",
     "browsing": "เรียกดู",
     "no_replies": "ยังไม่มีใครตอบ",
-    "no_new_posts": "No new posts.",
-    "share_this_category": "แชร์ Category นี้",
-    "watch": "Watch",
+    "no_new_posts": "ไม่มีกระทู้ใหม่",
+    "share_this_category": "แชร์หมวดนี้",
+    "watch": "ตามดู",
     "ignore": "ไม่ต้องสนใจอีก",
-    "watching": "Watching",
-    "ignoring": "Ignoring",
-    "watching.description": "Show topics in unread",
-    "ignoring.description": "Do not show topics in unread",
-    "watch.message": "You are now watching updates from this category and all subcategories",
-    "ignore.message": "You are now ignoring updates from this category and all subcategories",
-    "watched-categories": "Watched categories"
+    "watching": "กำลังตามดู",
+    "ignoring": "เมินเฉย",
+    "watching.description": "แสดงกระทู้ที่ยังไม่ได้อ่าน",
+    "ignoring.description": "ไม่แสดงกระทู้ที่ยังไม่ได้อ่าน",
+    "watch.message": "ตอนนี้คุณกำลังตามดูอัพเดทจากกระทู้หมวดนี้และหมวดหมู่ย่อยทั้งหมดในนี้",
+    "ignore.message": "ตอนนี้คุณกำลังเมินเฉยต่ออัพเดทจากกระทู้หมวดนี้และหมวดหมู่ย่อยทั้งหมดในนี้",
+    "watched-categories": "หมวดหมู่ที่ดูแล้ว"
 }
\ No newline at end of file
diff --git a/public/language/th/email.json b/public/language/th/email.json
index f6e3cd7e5b..609703602e 100644
--- a/public/language/th/email.json
+++ b/public/language/th/email.json
@@ -1,40 +1,40 @@
 {
-    "password-reset-requested": "Password Reset Requested - %1!",
+    "password-reset-requested": "ส่งคำขอตั้งค่ารหัสผ่านใหม่แล้ว -   %1!",
     "welcome-to": "ยินดีต้อนรับ %1",
-    "invite": "Invitation from %1",
+    "invite": "คำเชิญจาก %1",
     "greeting_no_name": "สวัสดี",
     "greeting_with_name": "สวัสดี %1",
     "welcome.text1": "ขอบคุณที่ลงทะเบียนกับ %1",
-    "welcome.text2": "To fully activate your account, we need to verify that you own the email address you registered with.",
-    "welcome.text3": "An administrator has accepted your registration application. You can login with your username/password now.",
+    "welcome.text2": "เพื่อให้การบัญชีของคุณใช้งานได้อย่างเสร็จสมบูรณ์ เราจำเป็นต้องยืนยันว่าคุณเป็นเจ้าของที่แท้จริงอีเมล์ที่ใช้สมัครสมาชิก",
+    "welcome.text3": "ผู้ดูแลระบบได้ทำการยอมรับการสมัครสมาชิกของคุณแล้ว คุณสามารถเข้าสู่ระบบด้วย ชื่อผู้ใช้/รหัสผ่าน ได้แล้วตอนนี้",
     "welcome.cta": "กดตรงนี้เพื่อยืนยันอีเมลของคุณ",
-    "invitation.text1": "%1 has invited you to join %2",
-    "invitation.ctr": "Click here to create your account.",
-    "reset.text1": "We received a request to reset your password, possibly because you have forgotten it. If this is not the case, please ignore this email.",
+    "invitation.text1": "%1 ได้เชิญคุณให้เข้าร่วม %2",
+    "invitation.ctr": "คลิกที่นี่เพื่อสร้างบัญชีของคุณ",
+    "reset.text1": "เราได้รับคำร้องให้ตั้งค่ารหัสผ่านใหม่ของคุณ อาจจะเป็นเพราะว่าคุณลืมรหัสผ่านและได้ทำการส่งคำขอเข้ามา หากไม่ใช่ กรุณาเพิกเฉยต่ออีเมล์นี้และไม่ต้องดำเนินการใดๆทั้งสิ้น",
     "reset.text2": "เพื่อดำเนินการตั้งรหัสผ่านใหม่ต่อไป, โปรดกดที่ลิ้งค์นี้:",
     "reset.cta": "กดตรงนี้เพื่อตั้งรหัสผ่านใหม่",
-    "reset.notify.subject": "Password successfully changed",
-    "reset.notify.text1": "We are notifying you that on %1, your password was changed successfully.",
-    "reset.notify.text2": "If you did not authorise this, please notify an administrator immediately.",
+    "reset.notify.subject": "ตั้งค่ารหัสผ่านใหม่เรียบร้อยแล้ว",
+    "reset.notify.text1": "เรากำลังแจ้งคุณว่าตอน %1 รหัสผ่านของคุณถูกเปลี่ยนเรียบร้อยแล้ว",
+    "reset.notify.text2": "หากคุณไม่ได้เป็นคนอนุญาตสิ่งนี้ กรุณาแจ้งไปยังผู้ดูแลระบบโดยทันที",
     "digest.notifications": "คุณมีข้อความแจ้งเตือนที่ยังไม่ได้อ่านจาก %1:",
     "digest.latest_topics": "หัวข้อสนทนาล่าสุดจาก %1",
     "digest.cta": "กดตรงนี้เพื่อเข้าดู %1",
-    "digest.unsub.info": "This digest was sent to you due to your subscription settings.",
-    "digest.no_topics": "There have been no active topics in the past %1",
-    "digest.day": "day",
-    "digest.week": "week",
-    "digest.month": "month",
-    "digest.subject": "Digest for %1",
-    "notif.chat.subject": "New chat message received from %1",
+    "digest.unsub.info": "คำชี้แจงถูกส่งไปให้คุณแล้ว เนื่องมาจากการตั้งค่าสมาชิกของคุณ",
+    "digest.no_topics": "ไม่มีกระทู้ใดๆเลยใน %1 ที่ผ่านมา",
+    "digest.day": "วัน",
+    "digest.week": "สัปดาห์",
+    "digest.month": "เดือน",
+    "digest.subject": "คำชี้แจงสำหรับ %1",
+    "notif.chat.subject": "ได้รับข้อความแชทใหม่จาก %1",
     "notif.chat.cta": "กดตรงนี้เพื่อกลับไปยังบทสนทนา",
-    "notif.chat.unsub.info": "This chat notification was sent to you due to your subscription settings.",
-    "notif.post.cta": "Click here to read the full topic",
-    "notif.post.unsub.info": "This post notification was sent to you due to your subscription settings.",
+    "notif.chat.unsub.info": "การแจ้งเตือนแชทนี้ถูกส่งไปหาคุณเนื่องจากการตั้งค่าสมาชิกของคุณ",
+    "notif.post.cta": "คลิกที่นี่เพื่ออ่านกระทู้ฉบับเต็ม",
+    "notif.post.unsub.info": "การแจ้งเตือนกระทู้นี้ถูกส่งไปยังคุณเนื่องการตั้งค่าสมาชิกของคุณ",
     "test.text1": "นี่คืออีเมลทดสอบเพื่อยืนยันว่าระบบอีเมลมีการตั้งค่าที่ถูกต้องสำหรับ NodeBB ของคุณ",
     "unsub.cta": "กดตรงนี้เพื่อเปลี่ยนแปลงการตั้งค่า",
-    "banned.subject": "You have been banned from %1",
-    "banned.text1": "The user %1 has been banned from %2.",
-    "banned.text2": "This ban will last until %1.",
-    "banned.text3": "This is the reason why you have been banned:",
+    "banned.subject": "คุณถูกแบนจาก  %1 แล้ว",
+    "banned.text1": "ผู้ใช้   %1 ได้ถูกแบนจาก  %2",
+    "banned.text2": "การแบนนี้จะใช้เวลาจนถึง %1",
+    "banned.text3": "นี่คือเหตุผลที่ทำไมคุณถึงถูกแบน",
     "closing": "ขอบคุณ!"
 }
\ No newline at end of file
diff --git a/public/language/th/error.json b/public/language/th/error.json
index 4d5cf25465..96c3592123 100644
--- a/public/language/th/error.json
+++ b/public/language/th/error.json
@@ -2,7 +2,7 @@
     "invalid-data": "ข้อมูลไม่ถูกต้อง",
     "not-logged-in": "คุณยังไม่ได้ลงชื่อเข้าระบบ",
     "account-locked": "บัญชีของคุณถูกระงับการใช้งานชั่วคราว",
-    "search-requires-login": "Searching requires an account - please login or register.",
+    "search-requires-login": "\"ฟังก์ชั่นการค้นหา\" ต้องการบัญชีผู้ใช้ กรุณาเข้าสู่ระบบหรือสมัครสมาชิก",
     "invalid-cid": "Category ID ไม่ถูกต้อง",
     "invalid-tid": "Topic ID ไม่ถูกต้อง",
     "invalid-pid": "Post ID ไม่ถูกต้อง",
@@ -14,35 +14,35 @@
     "invalid-password": "รหัสผ่านไม่ถูกต้อง",
     "invalid-username-or-password": "กรุณาระบุชื่อผู้ใช้และรหัสผ่าน",
     "invalid-search-term": "ข้อความค้นหาไม่ถูกต้อง",
-    "csrf-invalid": "We were unable to log you in, likely due to an expired session. Please try again",
-    "invalid-pagination-value": "Invalid pagination value, must be at least %1 and at most %2",
+    "csrf-invalid": "เราไม่สามารถนำท่านเข้าสู่ระบบได้ เหมือนกับว่าเซสชั่นหมดอายุแล้ว กรุณาลองใหม่อีกครั้ง",
+    "invalid-pagination-value": "หมายเลขหน้าไม่ถูกต้อง จำเป็นต้องเป็นตัวเลขอย่างน้อย  %1  และอย่างมาก %2",
     "username-taken": "ชื่อผู้ใช้นี้มีการใช้แล้ว",
     "email-taken": "อีเมลนี้มีการใช้แล้ว",
     "email-not-confirmed": "ยังไม่มีการยืนยันอีเมลของคุณ, โปรดกดยืนยันอีเมลของคุณตรงนี้",
-    "email-not-confirmed-chat": "You are unable to chat until your email is confirmed, please click here to confirm your email.",
-    "email-not-confirmed-email-sent": "Your email has not been confirmed yet, please check your inbox for the confirmation email.",
+    "email-not-confirmed-chat": "คุณไม่สามารถแชทได้จนกว่าอีเมล์ของคุณจะได้รับการยืนยัน กรุณาคลิกที่นี่เพื่อยืนยันอีกมเมล์ของคุณ",
+    "email-not-confirmed-email-sent": "อีเมล์ของคุณยังไม่ได้รับการยืนยัน กรุณาเช็คกล่องข้อความในอีเมล์เพื่อกดยืนยัน",
     "no-email-to-confirm": "Forum นี้ต้องการการยืนยันอีเมล กรุณากดที่นี่เพื่อระบุอีเมล",
     "email-confirm-failed": "เราไม่สามารถยืนยันอีเมลของคุณ ณ ขณะนี้ กรุณาลองใหม่อีกครั้งภายหลัง",
-    "confirm-email-already-sent": "Confirmation email already sent, please wait %1 minute(s) to send another one.",
-    "sendmail-not-found": "The sendmail executable could not be found, please ensure it is installed and executable by the user running NodeBB.",
+    "confirm-email-already-sent": "อีเมล์ยืนยันตัวตนถูกส่งไปยังคุณเรียบร้อยแล้ว กรุณารอ %1  นาที(s) ก่อนการตัดสินใจส่งอีกครั้ง",
+    "sendmail-not-found": "ไม่พบการประมวลผลสำหรับการส่งอีเมล์ กรุณาตรวจสอบให้แน่ใจว่าได้มีการติดตั้งโปรแกรมการประมวลผลแล้วโดยผู้ใช้ที่กำลังใช้ NodeBB",
     "username-too-short": "ชื่อบัญชีผู้ใช้ สั้นเกินไป",
     "username-too-long": "ชื่อบัญชีผู้ใช้ ยาวเกินไป",
-    "password-too-long": "Password too long",
-    "user-banned": "User banned",
-    "user-banned-reason": "Sorry, this account has been banned (Reason: %1)",
-    "user-banned-reason-until": "Sorry, this account has been banned until %1 (Reason: %2)",
-    "user-too-new": "Sorry, you are required to wait %1 second(s) before making your first post",
-    "blacklisted-ip": "Sorry, your IP address has been banned from this community. If you feel this is in error, please contact an administrator.",
-    "ban-expiry-missing": "Please provide an end date for this ban",
+    "password-too-long": "รหัสผ่านยาวเกินไป",
+    "user-banned": "ผู้ใช้ได้รับการแบน",
+    "user-banned-reason": "ขออภัย บัญชีผู้ใช้นี้ได้รับการแบน (เหตุผล : %1)",
+    "user-banned-reason-until": "ขออภัย บัญชีผู้ใช้นี้ได้รับการแบนจนถึง  %1  (เหตุผล : %2)",
+    "user-too-new": "ขออภัย คุณจำเป็นต้องรอ  %1 วินาที(s) ก่อนการสร้างกระทู้แรกของคุณ",
+    "blacklisted-ip": "ขออภัย IP Address ของคุณถูกแบนจากชุมชนนี้ หากคุณคิดว่านี่เป็นเออเร่อของระบบ กรุณาติดต่อผู้ดูแลระบบ",
+    "ban-expiry-missing": "กรุณาระบุวันสิ้นสุดสำหรับการแบนในครั้งนี้",
     "no-category": "ยังไม่มี Category นี้",
     "no-topic": "ยังไม่มี Topic นี้",
     "no-post": "ยังไม่มี Post นี้",
     "no-group": "ยังไม่มี Group นี้",
     "no-user": "ยังไม่มีผู้ใช้งานนี้",
-    "no-teaser": "Teaser does not exist",
+    "no-teaser": "ยังไม่มีทีเซอร์นี้",
     "no-privileges": "คุณมีสิทธิ์ไม่เพียงพอที่จะทำรายการนี้",
     "category-disabled": "Category นี้ถูกปิดการใช้งานแล้ว",
-    "topic-locked": "Topic Locked",
+    "topic-locked": "กระทู้ถูกล็อก",
     "post-edit-duration-expired": "You are only allowed to edit posts for %1 second(s) after posting",
     "post-edit-duration-expired-minutes": "You are only allowed to edit posts for %1 minute(s) after posting",
     "post-edit-duration-expired-minutes-seconds": "You are only allowed to edit posts for %1 minute(s) %2 second(s) after posting",
diff --git a/public/language/th/uploads.json b/public/language/th/uploads.json
index 1622cb5693..b43c5bcae6 100644
--- a/public/language/th/uploads.json
+++ b/public/language/th/uploads.json
@@ -1,6 +1,6 @@
 {
-    "uploading-file": "Uploading the file...",
-    "select-file-to-upload": "Select a file to upload!",
-    "upload-success": "File uploaded successfully!",
-    "maximum-file-size": "Maximum %1 kb"
+    "uploading-file": "กำลังอัพโหลดไฟล์ ...",
+    "select-file-to-upload": "กรุณาเลือกไฟล์ที่จะอัพโหลด",
+    "upload-success": "อัพโหลดไฟล์เรียบร้อยแล้ว",
+    "maximum-file-size": "มากที่สุดได้ %1 kb"
 }
\ No newline at end of file
diff --git a/public/language/th/user.json b/public/language/th/user.json
index 538c59c7f7..a426a45a2e 100644
--- a/public/language/th/user.json
+++ b/public/language/th/user.json
@@ -104,7 +104,7 @@
     "open_links_in_new_tab": "เปิดลิงค์ในแท็บใหม่",
     "enable_topic_searching": "เปิดใช้การค้นหาแบบ In-Topic",
     "topic_search_help": "หากเปิดใช้งาน, \"การค้นหาภายในกระทู้\" จะแทนที่ระบบ \"การค้นหาจากค่าเริ่มต้นของเบราเซอร์\" และจะทำให้คุณค้นหาข้อมูลต่างๆภายในกระทู้ได้ แทนที่จะเป็นการหาแค่สิ่งที่แสดงบนหน้าจอเท่านั้น",
-    "delay_image_loading": "Delay Image Loading",
+    "delay_image_loading": "การโหลดรูปภาพช้าลง",
     "image_load_delay_help": "หากเปิดใช้งาน, รูปภาพในกระทู้จะไม่โหลดจนกว่าจะมีการเลื่อนไปดู",
     "scroll_to_my_post": "After posting a reply, show the new post",
     "follow_topics_you_reply_to": "ดูกระทู้ที่คุณตอบ",
diff --git a/public/language/tr/admin/appearance/customise.json b/public/language/tr/admin/appearance/customise.json
index 83e506e854..afcc788881 100644
--- a/public/language/tr/admin/appearance/customise.json
+++ b/public/language/tr/admin/appearance/customise.json
@@ -1,9 +1,9 @@
 {
 	"custom-css": "Özel CSS",
-	"custom-css.description": "Enter your own CSS declarations here, which will be applied after all other styles.",
-	"custom-css.enable": "Özel CSS Aktif",
+	"custom-css.description": "Özel CSS kodlarınızı bu alana girin.",
+	"custom-css.enable": "Özel CSS Etkinleştir",
 
 	"custom-header": "Özel Header",
-	"custom-header.description": "Enter custom HTML here (ex. JavaScript, Meta Tags, etc.), which will be appended to the <code>&lt;head&gt;</code> section of your forum's markup.",
-	"custom-header.enable": "Enable Custom Header"
+	"custom-header.description": "Forumunuzun biçimlendirmesini sağlayacak  <code>&lt;head&gt;</code> bölümüne eklenecek özel HTML'yi (ör. JavaScript, Meta Etiketler vb.) Girin.",
+	"custom-header.enable": "Özel Header'ı Etkinleştir"
 }
\ No newline at end of file
diff --git a/public/language/tr/admin/appearance/skins.json b/public/language/tr/admin/appearance/skins.json
index 57638271e7..335dd89547 100644
--- a/public/language/tr/admin/appearance/skins.json
+++ b/public/language/tr/admin/appearance/skins.json
@@ -2,8 +2,8 @@
 	"loading": "Deriler yükleniyor...",
 	"homepage": "Anasayfa",
 	"select-skin": "Deri Seç",
-	"current-skin": "Current Skin",
-	"skin-updated": "Skin Updated",
-	"applied-success": "%1 skin was succesfully applied",
-	"revert-success": "Skin reverted to base colours"
+	"current-skin": "Mevcut Deri",
+	"skin-updated": "Deri Güncellendi",
+	"applied-success": "%1 deri başarıyla uygulandı",
+	"revert-success": "Deri taban renkleri geri döndürüldü"
 }
\ No newline at end of file
diff --git a/public/language/tr/admin/appearance/themes.json b/public/language/tr/admin/appearance/themes.json
index 9cdc64769e..e8df4d06b8 100644
--- a/public/language/tr/admin/appearance/themes.json
+++ b/public/language/tr/admin/appearance/themes.json
@@ -2,10 +2,10 @@
     "checking-for-installed": "Yüklü temalar kontrol ediliyor...",
     "homepage": "Anasayfa",
     "select-theme": "Tema Seç",
-    "current-theme": "Current Theme",
-    "no-themes": "No installed themes found",
-    "revert-confirm": "Are you sure you wish to restore the default NodeBB theme?",
-    "theme-changed": "Theme Changed",
-    "revert-success": "You have successfully reverted your NodeBB back to it's default theme.",
-    "restart-to-activate": "Please restart your NodeBB to fully activate this theme"
+    "current-theme": "Geçerli Tema",
+    "no-themes": "Yüklü tema bulunamadı",
+    "revert-confirm": "Varsayılan NodeBB temasını geri yüklemek istediğinizden emin misiniz?",
+    "theme-changed": "Tema Değiştirildi",
+    "revert-success": "NodeBB'nin varsayılan temasına başarıyla geri dönüş yaptınız.",
+    "restart-to-activate": "Temayı tamamen aktif hale getirebilmek için NodeBB'yi yeniden başlat"
 }
\ No newline at end of file
diff --git a/public/language/tr/admin/general/sounds.json b/public/language/tr/admin/general/sounds.json
index b2c52aa9f1..be203d3582 100644
--- a/public/language/tr/admin/general/sounds.json
+++ b/public/language/tr/admin/general/sounds.json
@@ -2,8 +2,8 @@
 	"notifications": "Bildiriler",
 	"chat-messages": "Sohbet Mesajları",
 	"play-sound": "Oynat",
-	"incoming-message": "Incoming Message",
-	"outgoing-message": "Outgoing Message",
+	"incoming-message": "Gelen İleti",
+	"outgoing-message": "Giden İleti",
 	"upload-new-sound": "Yeni Ses Yükle",
-	"saved": "Settings Saved"
+	"saved": "Ayarlar Kaydedildi"
 }
\ No newline at end of file
diff --git a/public/language/tr/admin/manage/categories.json b/public/language/tr/admin/manage/categories.json
index d5cb9e7729..930d9590bf 100644
--- a/public/language/tr/admin/manage/categories.json
+++ b/public/language/tr/admin/manage/categories.json
@@ -1,30 +1,30 @@
 {
 	"settings": "Kategori Ayarları",
-	"privileges": "Privileges",
+	"privileges": "İzinler",
 
 	"name": "Kategori Adı",
-	"description": "Category Description",
-	"bg-color": "Background Colour",
+	"description": "Kategori Açıklama",
+	"bg-color": "Arkaplan Rengi",
 	"text-color": "Yazı Rengi",
 	"bg-image-size": "Arkaplan Görseli Boyutu",
 	"custom-class": "Özel Sınıf",
 	"num-recent-replies": "# of Recent Replies",
-	"ext-link": "External Link",
+	"ext-link": "Harici Bağlantı",
 	"upload-image": "Görsel Yükle",
-	"delete-image": "Remove",
-	"category-image": "Category Image",
+	"delete-image": "Sil",
+	"category-image": "Kategori Görseli",
 	"parent-category": "Parent Category",
 	"optional-parent-category": "(Optional) Parent Category",
-	"parent-category-none": "(None)",
+	"parent-category-none": "(Hiçbiri)",
 	"copy-settings": "Copy Settings From",
 	"optional-clone-settings": "(Optional) Clone Settings From Category",
 	"purge": "Purge Category",
 
-	"enable": "Enable",
-	"disable": "Disable",
-	"edit": "Edit",
+	"enable": "Etkinleştir",
+	"disable": "Devredışı",
+	"edit": "Düzenle",
 
-	"select-category": "Select Category",
+	"select-category": "Kategori Seç",
 	"set-parent-category": "Set Parent Category",
 
 	"privileges.description": "You can configure the access control privileges for this category in this section. Privileges can be granted on a per-user or a per-group basis. You can add a new user to this table by searching for them in the form below.",
@@ -32,27 +32,27 @@
 	"privileges.section-viewing": "Viewing Privileges",
 	"privileges.section-posting": "Posting Privileges",
 	"privileges.section-moderation": "Moderation Privileges",
-	"privileges.section-user": "User",
-	"privileges.search-user": "Add User",
+	"privileges.section-user": "Kullanıcı",
+	"privileges.search-user": "Kullanıcı Ekle",
 	"privileges.no-users": "No user-specific privileges in this category.",
-	"privileges.section-group": "Group",
-	"privileges.group-private": "This group is private",
-	"privileges.search-group": "Add Group",
+	"privileges.section-group": "Grup",
+	"privileges.group-private": "Bu grup gizlidir",
+	"privileges.search-group": "Grup Ekle",
 	"privileges.copy-to-children": "Copy to Children",
 	"privileges.copy-from-category": "Copy from Category",
 	"privileges.inherit": "If the <code>registered-users</code> group is granted a specific privilege, all other groups receive an <strong>implicit privilege</strong>, even if they are not explicitly defined/checked. This implicit privilege is shown to you because all users are part of the <code>registered-users</code> user group, and so, privileges for additional groups need not be explicitly granted.",
 
-	"analytics.back": "Back to Categories List",
+	"analytics.back": "Kategori listesine geri dön",
 	"analytics.title": "Analytics for \"%1\" category",
 	"analytics.pageviews-hourly": "<strong>Figure 1</strong> &ndash; Hourly page views for this category</small>",
 	"analytics.pageviews-daily": "<strong>Figure 2</strong> &ndash; Daily page views for this category</small>",
 	"analytics.topics-daily": "<strong>Figure 3</strong> &ndash; Daily topics created in this category</small>",
 	"analytics.posts-daily": "<strong>Figure 4</strong> &ndash; Daily posts made in this category</small>",
 
-	"alert.created": "Created",
+	"alert.created": "Yaratıldı",
 	"alert.create-success": "Category successfully created!",
 	"alert.none-active": "You have no active categories.",
-	"alert.create": "Create a Category",
+	"alert.create": "Bir Kategori Yarat",
 	"alert.confirm-moderate": "<strong>Are you sure you wish to grant the moderation privilege to this user group?</strong> This group is public, and any users can join at will.",
 	"alert.confirm-purge": "<p class=\"lead\">Do you really want to purge this category \"%1\"?</p><h5><strong class=\"text-danger\">Warning!</strong> All topics and posts in this category will be purged!</h5> <p class=\"help-block\">Purging a category will remove all topics and posts, and delete the category from the database. If you want to remove a category <em>temporarily</em>, you'll want to \"disable\" the category instead.</p>",
 	"alert.purge-success": "Category purged!",
@@ -61,7 +61,7 @@
 	"alert.updated": "Updated Categories",
 	"alert.updated-success": "Category IDs %1 successfully updated.",
 	"alert.upload-image": "Kategori görseli yükle",
-	"alert.find-user": "Find a User",
+	"alert.find-user": "Bir Kullanıcı Ara",
 	"alert.user-search": "Search for a user here...",
 	"alert.find-group": "Find a Group",
 	"alert.group-search": "Search for a group here..."
diff --git a/public/language/tr/admin/manage/users.json b/public/language/tr/admin/manage/users.json
index 0f1a1c7b8d..6cacd0e9b9 100644
--- a/public/language/tr/admin/manage/users.json
+++ b/public/language/tr/admin/manage/users.json
@@ -2,7 +2,7 @@
 	"users": "Kullanıcılar",
 	"edit": "Düzenle",
 	"make-admin": "Yönetici Yap",
-	"remove-admin": "Remove Admin",
+	"remove-admin": "Yöneticiliği Sil",
 	"validate-email": "Validate Email",
 	"send-validation-email": "Send Validation Email",
 	"password-reset-email": "Send Password Reset Email",
@@ -10,7 +10,7 @@
 	"temp-ban": "Ban User(s) Temporarily",
 	"unban": "Unban User(s)",
 	"reset-lockout": "Reset Lockout",
-	"reset-flags": "Reset Flags",
+	"reset-flags": "Bayrakları Sıfırla",
 	"delete": "Delete User(s)",
 	"purge": "Delete User(s) and Content",
 	"download-csv": "Download CSV",
@@ -24,7 +24,7 @@
 	"pills.top-rep": "Most Reputation",
 	"pills.inactive": "Inactive",
 	"pills.flagged": "Most Flagged",
-	"pills.banned": "Banned",
+	"pills.banned": "Yasaklandı",
 	"pills.search": "User Search",
 
 	"search.username": "By User Name",
diff --git a/public/language/tr/email.json b/public/language/tr/email.json
index 4cf508e292..5c1233f451 100644
--- a/public/language/tr/email.json
+++ b/public/language/tr/email.json
@@ -32,9 +32,9 @@
     "notif.post.unsub.info": "Bu yazı bildirimi size abonelik ayarlarınız nedeni ile gönderilmiştir.",
     "test.text1": "Bu ileti NodeBB e-posta ayarlarınızın doğru çalışıp çalışmadığını kontrol etmek için gönderildi.",
     "unsub.cta": "Buraya tıklayarak ayarlarınızı değiştirebilirsiniz.",
-    "banned.subject": "You have been banned from %1",
-    "banned.text1": "The user %1 has been banned from %2.",
-    "banned.text2": "This ban will last until %1.",
-    "banned.text3": "This is the reason why you have been banned:",
+    "banned.subject": "%1 'den yasaklandınız",
+    "banned.text1": "%1 kullanıcısı %2 'den yasaklandı.",
+    "banned.text2": "Bu yasak %1 'e kadar sürecek.",
+    "banned.text3": "Yasaklanmanın nedeni:",
     "closing": "Teşekkürler!"
 }
\ No newline at end of file
diff --git a/public/language/tr/modules.json b/public/language/tr/modules.json
index a96b07be46..0ec408ba31 100644
--- a/public/language/tr/modules.json
+++ b/public/language/tr/modules.json
@@ -20,7 +20,7 @@
     "chat.three_months": "3 Ay",
     "chat.delete_message_confirm": "Bu mesajı silmek istediğinden emin misin?",
     "chat.add-users-to-room": "Odaya Kullanıcı Ekle",
-    "chat.confirm-chat-with-dnd-user": "This user has set their status to DnD(Do not disturb). Do you still want to chat with them?",
+    "chat.confirm-chat-with-dnd-user": "Bu kullanıcı durumunu rahatsız etmeyin olarak ayarladı. Hala onunla sohbet etmek istiyor musun?",
     "composer.compose": "Yaz",
     "composer.show_preview": "Önizleme Göster",
     "composer.hide_preview": "Önizleme Sakla",
diff --git a/public/language/tr/notifications.json b/public/language/tr/notifications.json
index b4e317f224..dce29e6f2b 100644
--- a/public/language/tr/notifications.json
+++ b/public/language/tr/notifications.json
@@ -40,7 +40,7 @@
     "user_started_following_you_multiple": "<strong>%1</strong> ve %2 kişi daha seni takip etmeye başladı.",
     "new_register": "<strong>%1</strong> kayıt olma isteği gönderdi.",
     "new_register_multiple": "Beklemede <strong>%1</strong> kayıt olma isteği bulunmaktadır.",
-    "flag_assigned_to_you": "<strong>Flag %1</strong> has been assigned to you",
+    "flag_assigned_to_you": "<Strong>Bayrak %1</ strong> size devredildi",
     "email-confirmed": "E-posta onaylandı",
     "email-confirmed-message": "E-postanızı onaylandığınız için teşekkürler. Hesabınız tamamen aktive edildi.",
     "email-confirm-error-message": "E-posta adresinizi onaylarken bir hata oluştu. Kodunuz geçersiz ya da eski olabilir.",

From a4ba88dc60a7b809b6c83644568779d6560e0f54 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Sun, 21 May 2017 19:45:25 -0400
Subject: [PATCH 29/42] more feed tests

---
 src/controllers/404.js |  24 ++--
 src/routes/feeds.js    | 258 +++++++++++++++++++----------------------
 test/feeds.js          | 119 +++++++++++++++++++
 3 files changed, 252 insertions(+), 149 deletions(-)
 create mode 100644 test/feeds.js

diff --git a/src/controllers/404.js b/src/controllers/404.js
index bc4e2e1d00..44dcf59174 100644
--- a/src/controllers/404.js
+++ b/src/controllers/404.js
@@ -30,18 +30,20 @@ exports.handle404 = function (req, res) {
 		}
 
 		meta.errors.log404(req.path.replace(/^\/api/, '') || '');
-		res.status(404);
-
-		var path = String(req.path || '');
-
-		if (res.locals.isAPI) {
-			return res.json({ path: validator.escape(path.replace(/^\/api/, '')), title: '[[global:404.title]]' });
-		}
-		var middleware = require('../middleware');
-		middleware.buildHeader(req, res, function () {
-			res.render('404', { path: validator.escape(path), title: '[[global:404.title]]' });
-		});
+		exports.send404(req, res);
 	} else {
 		res.status(404).type('txt').send('Not found');
 	}
 };
+
+exports.send404 = function (req, res) {
+	res.status(404);
+	var path = String(req.path || '');
+	if (res.locals.isAPI) {
+		return res.json({ path: validator.escape(path.replace(/^\/api/, '')), title: '[[global:404.title]]' });
+	}
+	var middleware = require('../middleware');
+	middleware.buildHeader(req, res, function () {
+		res.render('404', { path: validator.escape(path), title: '[[global:404.title]]' });
+	});
+};
diff --git a/src/routes/feeds.js b/src/routes/feeds.js
index 5e3d75c34d..3171babbf6 100644
--- a/src/routes/feeds.js
+++ b/src/routes/feeds.js
@@ -12,6 +12,7 @@ var categories = require('../categories');
 var meta = require('../meta');
 var helpers = require('../controllers/helpers');
 var privileges = require('../privileges');
+var controllers404 = require('../controllers/404.js');
 
 module.exports = function (app, middleware) {
 	app.get('/topic/:topic_id.rss', middleware.maintenanceMode, generateForTopic);
@@ -25,10 +26,9 @@ module.exports = function (app, middleware) {
 	app.get('/tags/:tag.rss', middleware.maintenanceMode, generateForTag);
 };
 
-
 function generateForTopic(req, res, callback) {
 	if (parseInt(meta.config['feeds:disableRSS'], 10) === 1) {
-		return callback();
+		return controllers404.send404(req, res);
 	}
 
 	var tid = req.params.topic_id;
@@ -45,65 +45,59 @@ function generateForTopic(req, res, callback) {
 			}, next);
 		},
 		function (results, next) {
-			if (!results.topic) {
-				return callback();
+			if (!results.topic || (parseInt(results.topic.deleted, 10) && !results.privileges.view_deleted)) {
+				return controllers404.send404(req, res);
 			}
-			if (parseInt(results.topic.deleted, 10) && !results.privileges.view_deleted) {
-				return callback();
-			}
-			if (!results.privileges.read || !results.privileges['topics:read']) {
+			if (!results.privileges['topics:read']) {
 				return helpers.notAllowed(req, res);
 			}
 			userPrivileges = results.privileges;
 			topics.getTopicWithPosts(results.topic, 'tid:' + tid + ':posts', req.uid, 0, 25, false, next);
 		},
-	], function (err, topicData) {
-		if (err) {
-			return callback(err);
-		}
+		function (topicData) {
+			topics.modifyPostsByPrivilege(topicData, userPrivileges);
 
-		topics.modifyPostsByPrivilege(topicData, userPrivileges);
+			var description = topicData.posts.length ? topicData.posts[0].content : '';
+			var image_url = topicData.posts.length ? topicData.posts[0].picture : '';
+			var author = topicData.posts.length ? topicData.posts[0].username : '';
 
-		var description = topicData.posts.length ? topicData.posts[0].content : '';
-		var image_url = topicData.posts.length ? topicData.posts[0].picture : '';
-		var author = topicData.posts.length ? topicData.posts[0].username : '';
+			var feed = new rss({
+				title: topicData.title,
+				description: description,
+				feed_url: nconf.get('url') + '/topic/' + tid + '.rss',
+				site_url: nconf.get('url') + '/topic/' + topicData.slug,
+				image_url: image_url,
+				author: author,
+				ttl: 60,
+			});
+			var dateStamp;
 
-		var feed = new rss({
-			title: topicData.title,
-			description: description,
-			feed_url: nconf.get('url') + '/topic/' + tid + '.rss',
-			site_url: nconf.get('url') + '/topic/' + topicData.slug,
-			image_url: image_url,
-			author: author,
-			ttl: 60,
-		});
-		var dateStamp;
-
-		if (topicData.posts.length > 0) {
-			feed.pubDate = new Date(parseInt(topicData.posts[0].timestamp, 10)).toUTCString();
-		}
-
-		topicData.posts.forEach(function (postData) {
-			if (!postData.deleted) {
-				dateStamp = new Date(parseInt(parseInt(postData.edited, 10) === 0 ? postData.timestamp : postData.edited, 10)).toUTCString();
-
-				feed.item({
-					title: 'Reply to ' + topicData.title + ' on ' + dateStamp,
-					description: postData.content,
-					url: nconf.get('url') + '/post/' + postData.pid,
-					author: postData.user ? postData.user.username : '',
-					date: dateStamp,
-				});
+			if (topicData.posts.length > 0) {
+				feed.pubDate = new Date(parseInt(topicData.posts[0].timestamp, 10)).toUTCString();
 			}
-		});
 
-		sendFeed(feed, res);
-	});
+			topicData.posts.forEach(function (postData) {
+				if (!postData.deleted) {
+					dateStamp = new Date(parseInt(parseInt(postData.edited, 10) === 0 ? postData.timestamp : postData.edited, 10)).toUTCString();
+
+					feed.item({
+						title: 'Reply to ' + topicData.title + ' on ' + dateStamp,
+						description: postData.content,
+						url: nconf.get('url') + '/post/' + postData.pid,
+						author: postData.user ? postData.user.username : '',
+						date: dateStamp,
+					});
+				}
+			});
+
+			sendFeed(feed, res);
+		},
+	], callback);
 }
 
 function generateForUserTopics(req, res, callback) {
 	if (parseInt(meta.config['feeds:disableRSS'], 10) === 1) {
-		return callback();
+		return controllers404.send404(req, res);
 	}
 
 	var userslug = req.params.userslug;
@@ -118,24 +112,21 @@ function generateForUserTopics(req, res, callback) {
 			}
 			user.getUserFields(uid, ['uid', 'username'], next);
 		},
-	], function (err, userData) {
-		if (err) {
-			return callback(err);
-		}
-
-		generateForTopics({
-			uid: req.uid,
-			title: 'Topics by ' + userData.username,
-			description: 'A list of topics that are posted by ' + userData.username,
-			feed_url: '/user/' + userslug + '/topics.rss',
-			site_url: '/user/' + userslug + '/topics',
-		}, 'uid:' + userData.uid + ':topics', req, res, callback);
-	});
+		function (userData, next) {
+			generateForTopics({
+				uid: req.uid,
+				title: 'Topics by ' + userData.username,
+				description: 'A list of topics that are posted by ' + userData.username,
+				feed_url: '/user/' + userslug + '/topics.rss',
+				site_url: '/user/' + userslug + '/topics',
+			}, 'uid:' + userData.uid + ':topics', req, res, next);
+		},
+	], callback);
 }
 
 function generateForCategory(req, res, next) {
 	if (parseInt(meta.config['feeds:disableRSS'], 10) === 1) {
-		return next();
+		return controllers404.send404(req, res);
 	}
 	var cid = req.params.category_id;
 
@@ -169,17 +160,15 @@ function generateForCategory(req, res, next) {
 				site_url: '/category/' + results.category.cid,
 			}, results.category.topics, next);
 		},
-	], function (err, feed) {
-		if (err) {
-			return next(err);
-		}
-		sendFeed(feed, res);
-	});
+		function (feed) {
+			sendFeed(feed, res);
+		},
+	], next);
 }
 
 function generateForRecent(req, res, next) {
 	if (parseInt(meta.config['feeds:disableRSS'], 10) === 1) {
-		return next();
+		return controllers404.send404(req, res);
 	}
 	generateForTopics({
 		uid: req.uid,
@@ -192,7 +181,7 @@ function generateForRecent(req, res, next) {
 
 function generateForPopular(req, res, next) {
 	if (parseInt(meta.config['feeds:disableRSS'], 10) === 1) {
-		return next();
+		return controllers404.send404(req, res);
 	}
 	var terms = {
 		daily: 'day',
@@ -215,12 +204,10 @@ function generateForPopular(req, res, next) {
 				site_url: '/popular/' + (req.params.term || 'daily'),
 			}, topics, next);
 		},
-	], function (err, feed) {
-		if (err) {
-			return next(err);
-		}
-		sendFeed(feed, res);
-	});
+		function (feed) {
+			sendFeed(feed, res);
+		},
+	], next);
 }
 
 function generateForTopics(options, set, req, res, next) {
@@ -233,12 +220,10 @@ function generateForTopics(options, set, req, res, next) {
 		function (data, next) {
 			generateTopicsFeed(options, data.topics, next);
 		},
-	], function (err, feed) {
-		if (err) {
-			return next(err);
-		}
-		sendFeed(feed, res);
-	});
+		function (feed) {
+			sendFeed(feed, res);
+		},
+	], next);
 }
 
 function generateTopicsFeed(feedOptions, feedTopics, callback) {
@@ -254,7 +239,7 @@ function generateTopicsFeed(feedOptions, feedTopics, callback) {
 		feed.pubDate = new Date(parseInt(feedTopics[0].lastposttime, 10)).toUTCString();
 	}
 
-	async.map(feedTopics, function (topicData, next) {
+	async.each(feedTopics, function (topicData, next) {
 		var feedItem = {
 			title: topicData.title,
 			url: nconf.get('url') + '/topic/' + topicData.slug,
@@ -272,83 +257,80 @@ function generateTopicsFeed(feedOptions, feedTopics, callback) {
 				return next(err);
 			}
 			if (!mainPost) {
-				return next(null, feedItem);
+				feed.item(feedItem);
+				return next();
 			}
 			feedItem.description = mainPost.content;
 			feedItem.author = mainPost.user.username;
-			next(null, feedItem);
+			feed.item(feedItem);
+			next();
 		});
-	}, function (err, feedItems) {
-		if (err) {
-			return callback(err);
-		}
-		feedItems.forEach(function (feedItem) {
-			if (feedItem) {
-				feed.item(feedItem);
-			}
-		});
-		callback(null, feed);
+	}, function (err) {
+		callback(err, feed);
 	});
 }
 
 function generateForRecentPosts(req, res, next) {
 	if (parseInt(meta.config['feeds:disableRSS'], 10) === 1) {
-		return next();
+		return controllers404.send404(req, res);
 	}
 
-	posts.getRecentPosts(req.uid, 0, 19, 'month', function (err, posts) {
-		if (err) {
-			return next(err);
-		}
+	async.waterfall([
+		function (next) {
+			posts.getRecentPosts(req.uid, 0, 19, 'month', next);
+		},
+		function (posts) {
+			var feed = generateForPostsFeed({
+				title: 'Recent Posts',
+				description: 'A list of recent posts',
+				feed_url: '/recentposts.rss',
+				site_url: '/recentposts',
+			}, posts);
 
-		var feed = generateForPostsFeed({
-			title: 'Recent Posts',
-			description: 'A list of recent posts',
-			feed_url: '/recentposts.rss',
-			site_url: '/recentposts',
-		}, posts);
-
-		sendFeed(feed, res);
-	});
+			sendFeed(feed, res);
+		},
+	], next);
 }
 
 function generateForCategoryRecentPosts(req, res, next) {
 	if (parseInt(meta.config['feeds:disableRSS'], 10) === 1) {
-		return next();
+		return controllers404.send404(req, res);
 	}
 	var cid = req.params.category_id;
 
-	async.parallel({
-		privileges: function (next) {
-			privileges.categories.get(cid, req.uid, next);
+	async.waterfall([
+		function (next) {
+			async.parallel({
+				privileges: function (next) {
+					privileges.categories.get(cid, req.uid, next);
+				},
+				category: function (next) {
+					categories.getCategoryData(cid, next);
+				},
+				posts: function (next) {
+					categories.getRecentReplies(cid, req.uid, 20, next);
+				},
+			}, next);
 		},
-		category: function (next) {
-			categories.getCategoryData(cid, next);
+		function (results, next) {
+			if (!results.category) {
+				return next();
+			}
+
+			if (!results.privileges.read) {
+				return helpers.notAllowed(req, res);
+			}
+
+			var feed = generateForPostsFeed({
+				title: results.category.name + ' Recent Posts',
+				description: 'A list of recent posts from ' + results.category.name,
+				feed_url: '/category/' + cid + '/recentposts.rss',
+				site_url: '/category/' + cid + '/recentposts',
+			}, results.posts);
+
+			sendFeed(feed, res);
 		},
-		posts: function (next) {
-			categories.getRecentReplies(cid, req.uid, 20, next);
-		},
-	}, function (err, results) {
-		if (err) {
-			return next(err);
-		}
-		if (!results.category) {
-			return next();
-		}
-
-		if (!results.privileges.read) {
-			return helpers.notAllowed(req, res);
-		}
-
-		var feed = generateForPostsFeed({
-			title: results.category.name + ' Recent Posts',
-			description: 'A list of recent posts from ' + results.category.name,
-			feed_url: '/category/' + cid + '/recentposts.rss',
-			site_url: '/category/' + cid + '/recentposts',
-		}, results.posts);
-
-		sendFeed(feed, res);
-	});
+	], next);
 }
 
 function generateForPostsFeed(feedOptions, posts) {
@@ -377,7 +359,7 @@ function generateForPostsFeed(feedOptions, posts) {
 
 function generateForTag(req, res, next) {
 	if (parseInt(meta.config['feeds:disableRSS'], 10) === 1) {
-		return next();
+		return controllers404.send404(req, res);
 	}
 	var tag = validator.escape(String(req.params.tag));
 	var page = parseInt(req.query.page, 10) || 1;
diff --git a/test/feeds.js b/test/feeds.js
new file mode 100644
index 0000000000..6e6628c038
--- /dev/null
+++ b/test/feeds.js
@@ -0,0 +1,119 @@
+'use strict';
+
+var assert = require('assert');
+var async = require('async');
+var request = require('request');
+var nconf = require('nconf');
+
+var db = require('./mocks/databasemock');
+var topics = require('../src/topics');
+var categories = require('../src/categories');
+var groups = require('../src/groups');
+var user = require('../src/user');
+var meta = require('../src/meta');
+var privileges = require('../src/privileges');
+
+describe('feeds', function () {
+	var tid;
+	var pid;
+	var fooUid;
+	var cid;
+	before(function (done) {
+		groups.resetCache();
+		meta.config['feeds:disableRSS'] = 1;
+		async.series({
+			category: function (next) {
+				categories.create({
+					name: 'Test Category',
+					description: 'Test category created by testing script',
+				}, next);
+			},
+			user: function (next) {
+				user.create({ username: 'foo', password: 'barbar', email: 'foo@test.com' }, next);
+			},
+		}, function (err, results) {
+			if (err) {
+				return done(err);
+			}
+			cid = results.category.cid;
+			fooUid = results.user;
+
+			topics.post({ uid: results.user, title: 'test topic title', content: 'test topic content', cid: results.category.cid }, function (err, result) {
+				tid = result.topicData.tid;
+				pid = result.postData.pid;
+				done(err);
+			});
+		});
+	});
+
+
+	it('should 404', function (done) {
+		var feedUrls = [
+			nconf.get('url') + '/topic/' + tid + '.rss',
+			nconf.get('url') + '/category/' + cid + '.rss',
+			nconf.get('url') + '/popular.rss',
+			nconf.get('url') + '/popular/day.rss',
+			nconf.get('url') + '/recentposts.rss',
+			nconf.get('url') + '/category/' + cid + '/recentposts.rss',
+			nconf.get('url') + '/user/foo/topics.rss',
+			nconf.get('url') + '/tags/nodebb.rss',
+		];
+		async.eachSeries(feedUrls, function (url, next) {
+			request(url, function (err, res) {
+				assert.ifError(err);
+				assert.equal(res.statusCode, 404);
+				next();
+			});
+		}, function (err) {
+			assert.ifError(err);
+			meta.config['feeds:disableRSS'] = 0;
+			done();
+		});
+	});
+
+	it('should 404 if topic does not exist', function (done) {
+		request(nconf.get('url') + '/topic/' + 1000 + '.rss', function (err, res) {
+			assert.ifError(err);
+			assert.equal(res.statusCode, 404);
+			done();
+		});
+	});
+
+	it('should redirect if we do not have read privilege', function (done) {
+		privileges.categories.rescind(['topics:read'], cid, 'guests', function (err) {
+			assert.ifError(err);
+			request(nconf.get('url') + '/topic/' + tid + '.rss', function (err, res, body) {
+				assert.ifError(err);
+				assert.equal(res.statusCode, 200);
+				assert(body);
+				assert(body.indexOf('Login to your account') !== -1);
+				privileges.categories.give(['topics:read'], cid, 'guests', done);
+			});
+		});
+	});
+
+	it('should 404 if user is not found', function (done) {
+		request(nconf.get('url') + '/user/doesnotexist/topics.rss', function (err, res) {
+			assert.ifError(err);
+			assert.equal(res.statusCode, 404);
+			done();
+		});
+	});
+
+	it('should redirect if we do not have read privilege', function (done) {
+		privileges.categories.rescind(['read'], cid, 'guests', function (err) {
+			assert.ifError(err);
+			request(nconf.get('url') + '/category/' + cid + '.rss', function (err, res, body) {
+				assert.ifError(err);
+				assert.equal(res.statusCode, 200);
+				assert(body);
+				assert(body.indexOf('Login to your account') !== -1);
+				privileges.categories.give(['read'], cid, 'guests', done);
+			});
+		});
+	});
+
+	after(function (done) {
+		db.emptydb(done);
+	});
+});

From 64c7907e6c69396ac808f88804ea558846f00345 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Sun, 21 May 2017 20:14:00 -0400
Subject: [PATCH 30/42] added recent.rss

---
 test/feeds.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/feeds.js b/test/feeds.js
index 6e6628c038..4fd0bbd90e 100644
--- a/test/feeds.js
+++ b/test/feeds.js
@@ -51,6 +51,7 @@ describe('feeds', function () {
 		var feedUrls = [
 			nconf.get('url') + '/topic/' + tid + '.rss',
 			nconf.get('url') + '/category/' + cid + '.rss',
+			nconf.get('url') + '/recent.rss',
 			nconf.get('url') + '/popular.rss',
 			nconf.get('url') + '/popular/day.rss',
 			nconf.get('url') + '/recentposts.rss',

From d988e8a50f13462aff6e4b9e89caf17d68fff8a1 Mon Sep 17 00:00:00 2001
From: Peter Jaszkowiak <p.jaszkow@gmail.com>
Date: Sun, 21 May 2017 18:20:01 -0600
Subject: [PATCH 31/42] Test minifier

---
 .eslintignore        |  1 +
 src/meta/minifier.js |  2 +-
 test/build.js        | 94 ++++++++++++++++++++++++++++++++++++++++++++
 test/files/1.css     |  1 +
 test/files/1.js      |  5 +++
 test/files/2.js      |  3 ++
 test/files/2.less    |  1 +
 7 files changed, 106 insertions(+), 1 deletion(-)
 create mode 100644 test/files/1.css
 create mode 100644 test/files/1.js
 create mode 100644 test/files/2.js
 create mode 100644 test/files/2.less

diff --git a/.eslintignore b/.eslintignore
index 3278600389..11b456699f 100644
--- a/.eslintignore
+++ b/.eslintignore
@@ -17,3 +17,4 @@ logs/
 /coverage
 /build
 .eslintrc
+test/files
diff --git a/src/meta/minifier.js b/src/meta/minifier.js
index da7c570ce7..7c1a83bea4 100644
--- a/src/meta/minifier.js
+++ b/src/meta/minifier.js
@@ -156,7 +156,7 @@ function concat(data, callback) {
 				return callback(err);
 			}
 
-			var output = files.join(os.EOL + ';');
+			var output = files.join('\n;');
 			callback(null, { code: output });
 		});
 
diff --git a/test/build.js b/test/build.js
index 3b6890ebe6..20d43033a9 100644
--- a/test/build.js
+++ b/test/build.js
@@ -1,8 +1,102 @@
 'use strict';
 
+var string = require('string');
+var path = require('path');
+var fs = require('fs');
 var assert = require('assert');
+var mkdirp = require('mkdirp');
 
 var db = require('./mocks/databasemock');
+var file = require('../src/file');
+
+describe('minifier', function () {
+	before(function (done) {
+		mkdirp(path.join(__dirname, '../build/test'), done);
+	});
+
+	var minifier = require('../src/meta/minifier');
+	var scripts = [
+		path.resolve(__dirname, './files/1.js'),
+		path.resolve(__dirname, './files/2.js'),
+	];
+	it('.js.bundle() should concat scripts', function (done) {
+		minifier.js.bundle(scripts, false, false, function (err, bundle) {
+			assert.ifError(err);
+			assert.strictEqual(
+				bundle.code,
+				'(function (window, document) {' +
+				'\n\twindow.doStuff = function () {' +
+				'\n\t\tdocument.body.innerHTML = \'Stuff has been done\';' +
+				'\n\t};' +
+				'\n})(window, document);' +
+				'\n' +
+				'\n;function foo(name, age) {' +
+				'\n\treturn \'The person known as "\' + name + \'" is \' + age + \' years old\';' +
+				'\n}' +
+				'\n'
+			);
+			done();
+		});
+	});
+
+	it('.js.bundle() should minify scripts', function (done) {
+		minifier.js.bundle(scripts, true, false, function (err, bundle) {
+			assert.ifError(err);
+			assert.strictEqual(
+				bundle.code,
+				'(function(n,o){n.doStuff=function(){o.body.innerHTML="Stuff has been done"}})(window,document);function foo(n,o){return\'The person known as "\'+n+\'" is \'+o+" years old"}'
+			);
+			done();
+		});
+	});
+
+	it('.js.minifyBatch() should minify each script', function (done) {
+		var s = scripts.map(function (script) {
+			return {
+				srcPath: script,
+				destPath: path.resolve(__dirname, '../build/test', path.basename(script)),
+			};
+		});
+		minifier.js.minifyBatch(s, false, function (err) {
+			assert.ifError(err);
+
+			assert(file.existsSync(s[0].destPath));
+			assert(file.existsSync(s[1].destPath));
+
+			fs.readFile(s[0].destPath, function (err, buffer) {
+				assert.ifError(err);
+				assert.strictEqual(
+					buffer.toString(),
+					'(function(n,o){n.doStuff=function(){o.body.innerHTML="Stuff has been done"}})(window,document);'
+				);
+				done();
+			});
+		});
+	});
+
+	var styles = [
+		'@import (inline) "./1.css";',
+		'@import "./2.less";',
+	].join('\n');
+	var paths = [
+		path.resolve(__dirname, './files'),
+	];
+	it('.css.bundle() should concat styles', function (done) {
+		minifier.css.bundle(styles, paths, false, false, function (err, bundle) {
+			assert.ifError(err);
+			assert.strictEqual(bundle.code, '.help { margin: 10px; } .yellow { background: yellow; }\n.help {\n  display: block;\n}\n.help .blue {\n  background: blue;\n}\n');
+			done();
+		});
+	});
+
+	it('.css.bundle() should minify styles', function (done) {
+		minifier.css.bundle(styles, paths, true, false, function (err, bundle) {
+			assert.ifError(err);
+			assert.strictEqual(bundle.code, '.help{margin:10px;display:block}.yellow{background:#ff0}.help .blue{background:#00f}');
+			done();
+		});
+	});
+});
 
 describe('Build', function () {
 	it('should build all assets', function (done) {
diff --git a/test/files/1.css b/test/files/1.css
new file mode 100644
index 0000000000..840cf64b36
--- /dev/null
+++ b/test/files/1.css
@@ -0,0 +1 @@
+.help { margin: 10px; } .yellow { background: yellow; }
\ No newline at end of file
diff --git a/test/files/1.js b/test/files/1.js
new file mode 100644
index 0000000000..b20055f8ee
--- /dev/null
+++ b/test/files/1.js
@@ -0,0 +1,5 @@
+(function (window, document) {
+	window.doStuff = function () {
+		document.body.innerHTML = 'Stuff has been done';
+	};
+})(window, document);
diff --git a/test/files/2.js b/test/files/2.js
new file mode 100644
index 0000000000..9369213316
--- /dev/null
+++ b/test/files/2.js
@@ -0,0 +1,3 @@
+function foo(name, age) {
+	return 'The person known as "' + name + '" is ' + age + ' years old';
+}
diff --git a/test/files/2.less b/test/files/2.less
new file mode 100644
index 0000000000..cdd5d5b5f2
--- /dev/null
+++ b/test/files/2.less
@@ -0,0 +1 @@
+.help { display: block; .blue { background: blue; } }
\ No newline at end of file

From 62546bc4fd06210fa9890746f69a6673c3a99ec8 Mon Sep 17 00:00:00 2001
From: Peter Jaszkowiak <p.jaszkow@gmail.com>
Date: Sun, 21 May 2017 19:01:41 -0600
Subject: [PATCH 32/42] Build tests

---
 test/build.js | 96 ++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 91 insertions(+), 5 deletions(-)

diff --git a/test/build.js b/test/build.js
index 20d43033a9..215b823ce2 100644
--- a/test/build.js
+++ b/test/build.js
@@ -5,6 +5,7 @@ var path = require('path');
 var fs = require('fs');
 var assert = require('assert');
 var mkdirp = require('mkdirp');
+var rimraf = require('rimraf');
 
 var db = require('./mocks/databasemock');
 var file = require('../src/file');
@@ -98,12 +99,97 @@ describe('minifier', function () {
 	});
 });
 
-describe('Build', function () {
-	it('should build all assets', function (done) {
-		this.timeout(50000);
-		var build = require('../src/meta/build');
-		build.buildAll(function (err) {
+describe('Build', function (done) {
+	var build = require('../src/meta/build');
+
+	before(function (done) {
+		rimraf(path.join(__dirname, '../build/public'), done);
+	});
+
+	it('should build plugin static dirs', function (done) {
+		build.build(['plugin static dirs'], function (err) {
 			assert.ifError(err);
+			assert(file.existsSync(path.join(__dirname, '../build/public/plugins/nodebb-plugin-dbsearch/dbsearch')));
+			done();
+		});
+	});
+
+	it('should build requirejs modules', function (done) {
+		build.build(['requirejs modules'], function (err) {
+			assert.ifError(err);
+			var filename = path.join(__dirname, '../build/public/src/modules/Chart.js');
+			assert(file.existsSync(filename));
+			assert(fs.readFileSync(filename).toString().startsWith('/*!\n * Chart.js'));
+			done();
+		});
+	});
+
+	it('should build client js bundle', function (done) {
+		build.build(['client js bundle'], function (err) {
+			assert.ifError(err);
+			var filename = path.join(__dirname, '../build/public/nodebb.min.js');
+			assert(file.existsSync(filename));
+			assert(fs.readFileSync(filename).length > 1000);
+			done();
+		});
+	});
+
+	it('should build admin js bundle', function (done) {
+		build.build(['admin js bundle'], function (err) {
+			assert.ifError(err);
+			var filename = path.join(__dirname, '../build/public/acp.min.js');
+			assert(file.existsSync(filename));
+			assert(fs.readFileSync(filename).length > 1000);
+			done();
+		});
+	});
+
+	it('should build client side styles', function (done) {
+		build.build(['client side styles'], function (err) {
+			assert.ifError(err);
+			var filename = path.join(__dirname, '../build/public/stylesheet.css');
+			assert(file.existsSync(filename));
+			assert(fs.readFileSync(filename).toString().startsWith('/*! normalize.css'));
+			done();
+		});
+	});
+
+	it('should build admin control panel styles', function (done) {
+		build.build(['admin control panel styles'], function (err) {
+			assert.ifError(err);
+			var filename = path.join(__dirname, '../build/public/admin.css');
+			assert(file.existsSync(filename));
+			assert(fs.readFileSync(filename).toString().startsWith('@charset "UTF-8";'));
+			done();
+		});
+	});
+
+	it('should build templates', function (done) {
+		build.build(['templates'], function (err) {
+			assert.ifError(err);
+			var filename = path.join(__dirname, '../build/public/templates/admin/header.tpl');
+			assert(file.existsSync(filename));
+			assert(fs.readFileSync(filename).toString().startsWith('<!DOCTYPE html>'));
+			done();
+		});
+	});
+
+	it('should build languages', function (done) {
+		build.build(['languages'], function (err) {
+			assert.ifError(err);
+			var filename = path.join(__dirname, '../build/public/language/en-GB/global.json');
+			assert(file.existsSync(filename));
+			var global = fs.readFileSync(filename).toString();
+			assert.strictEqual(JSON.parse(global).home, 'Home');
+			done();
+		});
+	});
+
+	it('should build sounds', function (done) {
+		build.build(['sounds'], function (err) {
+			assert.ifError(err);
+			var filename = path.join(__dirname, '../build/public/sounds/fileMap.json');
+			assert(file.existsSync(filename));
 			done();
 		});
 	});

From 12e33695226e79bb71ecbde9b8cc6622a8977bf4 Mon Sep 17 00:00:00 2001
From: Julian Lam <julian@nodebb.org>
Date: Tue, 23 May 2017 11:35:40 -0400
Subject: [PATCH 33/42] Tweaked upgrade script instructions

---
 src/upgrade.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/upgrade.js b/src/upgrade.js
index 22c7867eeb..2bba82dd91 100644
--- a/src/upgrade.js
+++ b/src/upgrade.js
@@ -13,9 +13,8 @@ var file = require('../src/file');
  *
  * 1. Copy TEMPLATE to a file name of your choice. Try to be succinct.
  * 2. Open up that file and change the user-friendly name (can be longer/more descriptive than the file name)
- *    and timestamp
+ *    and timestamp (don't forget the timestamp!)
  * 3. Add your script under the "method" property
- * 4. Append your filename to the array below for the next NodeBB version.
  */
 
 var Upgrade = {};

From fa5026c92ee2c606030d885830233e9e9315f747 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Tue, 23 May 2017 13:05:33 -0400
Subject: [PATCH 34/42] clear settings cache on all nodes on save

---
 src/user/settings.js | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/user/settings.js b/src/user/settings.js
index de0da0641d..cf65c37545 100644
--- a/src/user/settings.js
+++ b/src/user/settings.js
@@ -8,6 +8,7 @@ var meta = require('../meta');
 var db = require('../database');
 var plugins = require('../plugins');
 
+var pubsub = require('../pubsub');
 var LRU = require('lru-cache');
 
 var cache = LRU({
@@ -19,6 +20,10 @@ var cache = LRU({
 module.exports = function (User) {
 	User.settingsCache = cache;
 
+	pubsub.on('user:settings:cache:del', function (uid) {
+		cache.del('user:' + uid + ':settings');
+	});
+
 	User.getSettings = function (uid, callback) {
 		if (!parseInt(uid, 10)) {
 			return onSettingsLoaded(0, {}, callback);
@@ -178,6 +183,7 @@ module.exports = function (User) {
 			},
 			function (next) {
 				cache.del('user:' + uid + ':settings');
+				pubsub.publish('user:settings:cache:del', uid);
 				User.getSettings(uid, next);
 			},
 		], callback);

From a12e159f1824912b08a4bbc0f3b0af366fb38dc6 Mon Sep 17 00:00:00 2001
From: pichalite <pichalite.com@gmail.com>
Date: Tue, 23 May 2017 19:11:16 +0000
Subject: [PATCH 35/42] Delete unused file

---
 public/vendor/jquery/js/jquery.js | 9921 -----------------------------
 1 file changed, 9921 deletions(-)
 delete mode 100644 public/vendor/jquery/js/jquery.js

diff --git a/public/vendor/jquery/js/jquery.js b/public/vendor/jquery/js/jquery.js
deleted file mode 100644
index 7554b8b747..0000000000
--- a/public/vendor/jquery/js/jquery.js
+++ /dev/null
@@ -1,9921 +0,0 @@
-/*!
- * jQuery JavaScript Library v1.10.2
- * http://jquery.com/
- *
- * Includes Sizzle.js
- * http://sizzlejs.com/
- *
- * Copyright 2005, 2013 jQuery Foundation, Inc. and other contributors
- * Released under the MIT license
- * http://jquery.org/license
- *
- * Date: 2013-07-03T13:48Z
- */
-(function (window, undefined) {
-
-	// Can't do this because several apps including ASP.NET trace
-	// the stack via arguments.caller.callee and Firefox dies if
-	// you try to trace through "use strict" call chains. (#13335)
-	// Support: Firefox 18+
-	//"use strict";
-	var
-	// The deferred used on DOM ready
-	readyList,
-
-		// A central reference to the root jQuery(document)
-		rootjQuery,
-
-		// Support: IE<10
-		// For `typeof xmlNode.method` instead of `xmlNode.method !== undefined`
-		core_strundefined = typeof undefined,
-
-		// Use the correct document accordingly with window argument (sandbox)
-		location = window.location,
-		document = window.document,
-		docElem = document.documentElement,
-
-		// Map over jQuery in case of overwrite
-		_jQuery = window.jQuery,
-
-		// Map over the $ in case of overwrite
-		_$ = window.$,
-
-		// [[Class]] -> type pairs
-		class2type = {},
-
-		// List of deleted data cache ids, so we can reuse them
-		core_deletedIds = [],
-
-		core_version = "1.10.2",
-
-		// Save a reference to some core methods
-		core_concat = core_deletedIds.concat,
-		core_push = core_deletedIds.push,
-		core_slice = core_deletedIds.slice,
-		core_indexOf = core_deletedIds.indexOf,
-		core_toString = class2type.toString,
-		core_hasOwn = class2type.hasOwnProperty,
-		core_trim = core_version.trim,
-
-		// Define a local copy of jQuery
-		jQuery = function (selector, context) {
-			// The jQuery object is actually just the init constructor 'enhanced'
-			return new jQuery.fn.init(selector, context, rootjQuery);
-		},
-
-		// Used for matching numbers
-		core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,
-
-		// Used for splitting on whitespace
-		core_rnotwhite = /\S+/g,
-
-		// Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
-		rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
-
-		// A simple way to check for HTML strings
-		// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
-		// Strict HTML recognition (#11290: must start with <)
-		rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,
-
-		// Match a standalone tag
-		rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
-
-		// JSON RegExp
-		rvalidchars = /^[\],:{}\s]*$/,
-		rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
-		rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
-		rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g,
-
-		// Matches dashed string for camelizing
-		rmsPrefix = /^-ms-/,
-		rdashAlpha = /-([\da-z])/gi,
-
-		// Used by jQuery.camelCase as callback to replace()
-		fcamelCase = function (all, letter) {
-			return letter.toUpperCase();
-		},
-
-		// The ready event handler
-		completed = function (event) {
-
-			// readyState === "complete" is good enough for us to call the dom ready in oldIE
-			if (document.addEventListener || event.type === "load" || document.readyState === "complete") {
-				detach();
-				jQuery.ready();
-			}
-		},
-		// Clean-up method for dom ready events
-		detach = function () {
-			if (document.addEventListener) {
-				document.removeEventListener("DOMContentLoaded", completed, false);
-				window.removeEventListener("load", completed, false);
-
-			} else {
-				document.detachEvent("onreadystatechange", completed);
-				window.detachEvent("onload", completed);
-			}
-		};
-
-	jQuery.fn = jQuery.prototype = {
-		// The current version of jQuery being used
-		jquery: core_version,
-
-		constructor: jQuery,
-		init: function (selector, context, rootjQuery) {
-			var match, elem;
-
-			// HANDLE: $(""), $(null), $(undefined), $(false)
-			if (!selector) {
-				return this;
-			}
-
-			// Handle HTML strings
-			if (typeof selector === "string") {
-				if (selector.charAt(0) === "<" && selector.charAt(selector.length - 1) === ">" && selector.length >= 3) {
-					// Assume that strings that start and end with <> are HTML and skip the regex check
-					match = [null, selector, null];
-
-				} else {
-					match = rquickExpr.exec(selector);
-				}
-
-				// Match html or make sure no context is specified for #id
-				if (match && (match[1] || !context)) {
-
-					// HANDLE: $(html) -> $(array)
-					if (match[1]) {
-						context = context instanceof jQuery ? context[0] : context;
-
-						// scripts is true for back-compat
-						jQuery.merge(this, jQuery.parseHTML(
-							match[1],
-							context && context.nodeType ? context.ownerDocument || context : document,
-							true
-						));
-
-						// HANDLE: $(html, props)
-						if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) {
-							for (match in context) {
-								// Properties of context are called as methods if possible
-								if (jQuery.isFunction(this[match])) {
-									this[match](context[match]);
-
-									// ...and otherwise set as attributes
-								} else {
-									this.attr(match, context[match]);
-								}
-							}
-						}
-
-						return this;
-
-						// HANDLE: $(#id)
-					} else {
-						elem = document.getElementById(match[2]);
-
-						// Check parentNode to catch when Blackberry 4.6 returns
-						// nodes that are no longer in the document #6963
-						if (elem && elem.parentNode) {
-							// Handle the case where IE and Opera return items
-							// by name instead of ID
-							if (elem.id !== match[2]) {
-								return rootjQuery.find(selector);
-							}
-
-							// Otherwise, we inject the element directly into the jQuery object
-							this.length = 1;
-							this[0] = elem;
-						}
-
-						this.context = document;
-						this.selector = selector;
-						return this;
-					}
-
-					// HANDLE: $(expr, $(...))
-				} else if (!context || context.jquery) {
-					return (context || rootjQuery).find(selector);
-
-					// HANDLE: $(expr, context)
-					// (which is just equivalent to: $(context).find(expr)
-				} else {
-					return this.constructor(context).find(selector);
-				}
-
-				// HANDLE: $(DOMElement)
-			} else if (selector.nodeType) {
-				this.context = this[0] = selector;
-				this.length = 1;
-				return this;
-
-				// HANDLE: $(function)
-				// Shortcut for document ready
-			} else if (jQuery.isFunction(selector)) {
-				return rootjQuery.ready(selector);
-			}
-
-			if (selector.selector !== undefined) {
-				this.selector = selector.selector;
-				this.context = selector.context;
-			}
-
-			return jQuery.makeArray(selector, this);
-		},
-
-		// Start with an empty selector
-		selector: "",
-
-		// The default length of a jQuery object is 0
-		length: 0,
-
-		toArray: function () {
-			return core_slice.call(this);
-		},
-
-		// Get the Nth element in the matched element set OR
-		// Get the whole matched element set as a clean array
-		get: function (num) {
-			return num == null ?
-
-			// Return a 'clean' array
-			this.toArray() :
-
-			// Return just the object
-			(num < 0 ? this[this.length + num] : this[num]);
-		},
-
-		// Take an array of elements and push it onto the stack
-		// (returning the new matched element set)
-		pushStack: function (elems) {
-
-			// Build a new jQuery matched element set
-			var ret = jQuery.merge(this.constructor(), elems);
-
-			// Add the old object onto the stack (as a reference)
-			ret.prevObject = this;
-			ret.context = this.context;
-
-			// Return the newly-formed element set
-			return ret;
-		},
-
-		// Execute a callback for every element in the matched set.
-		// (You can seed the arguments with an array of args, but this is
-		// only used internally.)
-		each: function (callback, args) {
-			return jQuery.each(this, callback, args);
-		},
-
-		ready: function (fn) {
-			// Add the callback
-			jQuery.ready.promise().done(fn);
-
-			return this;
-		},
-
-		slice: function () {
-			return this.pushStack(core_slice.apply(this, arguments));
-		},
-
-		first: function () {
-			return this.eq(0);
-		},
-
-		last: function () {
-			return this.eq(-1);
-		},
-
-		eq: function (i) {
-			var len = this.length,
-				j = +i + (i < 0 ? len : 0);
-			return this.pushStack(j >= 0 && j < len ? [this[j]] : []);
-		},
-
-		map: function (callback) {
-			return this.pushStack(jQuery.map(this, function (elem, i) {
-				return callback.call(elem, i, elem);
-			}));
-		},
-
-		end: function () {
-			return this.prevObject || this.constructor(null);
-		},
-
-		// For internal use only.
-		// Behaves like an Array's method, not like a jQuery method.
-		push: core_push,
-		sort: [].sort,
-		splice: [].splice
-	};
-
-	// Give the init function the jQuery prototype for later instantiation
-	jQuery.fn.init.prototype = jQuery.fn;
-
-	jQuery.extend = jQuery.fn.extend = function () {
-		var src, copyIsArray, copy, name, options, clone,
-			target = arguments[0] || {},
-			i = 1,
-			length = arguments.length,
-			deep = false;
-
-		// Handle a deep copy situation
-		if (typeof target === "boolean") {
-			deep = target;
-			target = arguments[1] || {};
-			// skip the boolean and the target
-			i = 2;
-		}
-
-		// Handle case when target is a string or something (possible in deep copy)
-		if (typeof target !== "object" && !jQuery.isFunction(target)) {
-			target = {};
-		}
-
-		// extend jQuery itself if only one argument is passed
-		if (length === i) {
-			target = this;
-			--i;
-		}
-
-		for (; i < length; i++) {
-			// Only deal with non-null/undefined values
-			if ((options = arguments[i]) != null) {
-				// Extend the base object
-				for (name in options) {
-					src = target[name];
-					copy = options[name];
-
-					// Prevent never-ending loop
-					if (target === copy) {
-						continue;
-					}
-
-					// Recurse if we're merging plain objects or arrays
-					if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)))) {
-						if (copyIsArray) {
-							copyIsArray = false;
-							clone = src && jQuery.isArray(src) ? src : [];
-
-						} else {
-							clone = src && jQuery.isPlainObject(src) ? src : {};
-						}
-
-						// Never move original objects, clone them
-						target[name] = jQuery.extend(deep, clone, copy);
-
-						// Don't bring in undefined values
-					} else if (copy !== undefined) {
-						target[name] = copy;
-					}
-				}
-			}
-		}
-
-		// Return the modified object
-		return target;
-	};
-
-	jQuery.extend({
-		// Unique for each copy of jQuery on the page
-		// Non-digits removed to match rinlinejQuery
-		expando: "jQuery" + (core_version + Math.random()).replace(/\D/g, ""),
-
-		noConflict: function (deep) {
-			if (window.$ === jQuery) {
-				window.$ = _$;
-			}
-
-			if (deep && window.jQuery === jQuery) {
-				window.jQuery = _jQuery;
-			}
-
-			return jQuery;
-		},
-
-		// Is the DOM ready to be used? Set to true once it occurs.
-		isReady: false,
-
-		// A counter to track how many items to wait for before
-		// the ready event fires. See #6781
-		readyWait: 1,
-
-		// Hold (or release) the ready event
-		holdReady: function (hold) {
-			if (hold) {
-				jQuery.readyWait++;
-			} else {
-				jQuery.ready(true);
-			}
-		},
-
-		// Handle when the DOM is ready
-		ready: function (wait) {
-
-			// Abort if there are pending holds or we're already ready
-			if (wait === true ? --jQuery.readyWait : jQuery.isReady) {
-				return;
-			}
-
-			// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
-			if (!document.body) {
-				return setTimeout(jQuery.ready);
-			}
-
-			// Remember that the DOM is ready
-			jQuery.isReady = true;
-
-			// If a normal DOM Ready event fired, decrement, and wait if need be
-			if (wait !== true && --jQuery.readyWait > 0) {
-				return;
-			}
-
-			// If there are functions bound, to execute
-			readyList.resolveWith(document, [jQuery]);
-
-			// Trigger any bound ready events
-			if (jQuery.fn.trigger) {
-				jQuery(document).trigger("ready").off("ready");
-			}
-		},
-
-		// See test/unit/core.js for details concerning isFunction.
-		// Since version 1.3, DOM methods and functions like alert
-		// aren't supported. They return false on IE (#2968).
-		isFunction: function (obj) {
-			return jQuery.type(obj) === "function";
-		},
-
-		isArray: Array.isArray || function (obj) {
-			return jQuery.type(obj) === "array";
-		},
-
-		isWindow: function (obj) {
-			/* jshint eqeqeq: false */
-			return obj != null && obj == obj.window;
-		},
-
-		isNumeric: function (obj) {
-			return !isNaN(parseFloat(obj)) && isFinite(obj);
-		},
-
-		type: function (obj) {
-			if (obj == null) {
-				return String(obj);
-			}
-			return typeof obj === "object" || typeof obj === "function" ?
-				class2type[core_toString.call(obj)] || "object" :
-				typeof obj;
-		},
-
-		isPlainObject: function (obj) {
-			var key;
-
-			// Must be an Object.
-			// Because of IE, we also have to check the presence of the constructor property.
-			// Make sure that DOM nodes and window objects don't pass through, as well
-			if (!obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow(obj)) {
-				return false;
-			}
-
-			try {
-				// Not own constructor property must be Object
-				if (obj.constructor && !core_hasOwn.call(obj, "constructor") && !core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) {
-					return false;
-				}
-			} catch (e) {
-				// IE8,9 Will throw exceptions on certain host objects #9897
-				return false;
-			}
-
-			// Support: IE<9
-			// Handle iteration over inherited properties before own properties.
-			if (jQuery.support.ownLast) {
-				for (key in obj) {
-					return core_hasOwn.call(obj, key);
-				}
-			}
-
-			// Own properties are enumerated firstly, so to speed up,
-			// if last one is own, then all properties are own.
-			for (key in obj) {}
-
-			return key === undefined || core_hasOwn.call(obj, key);
-		},
-
-		isEmptyObject: function (obj) {
-			var name;
-			for (name in obj) {
-				return false;
-			}
-			return true;
-		},
-
-		error: function (msg) {
-			throw new Error(msg);
-		},
-
-		// data: string of html
-		// context (optional): If specified, the fragment will be created in this context, defaults to document
-		// keepScripts (optional): If true, will include scripts passed in the html string
-		parseHTML: function (data, context, keepScripts) {
-			if (!data || typeof data !== "string") {
-				return null;
-			}
-			if (typeof context === "boolean") {
-				keepScripts = context;
-				context = false;
-			}
-			context = context || document;
-
-			var parsed = rsingleTag.exec(data),
-				scripts = !keepScripts && [];
-
-			// Single tag
-			if (parsed) {
-				return [context.createElement(parsed[1])];
-			}
-
-			parsed = jQuery.buildFragment([data], context, scripts);
-			if (scripts) {
-				jQuery(scripts).remove();
-			}
-			return jQuery.merge([], parsed.childNodes);
-		},
-
-		parseJSON: function (data) {
-			// Attempt to parse using the native JSON parser first
-			if (window.JSON && window.JSON.parse) {
-				return window.JSON.parse(data);
-			}
-
-			if (data === null) {
-				return data;
-			}
-
-			if (typeof data === "string") {
-
-				// Make sure leading/trailing whitespace is removed (IE can't handle it)
-				data = jQuery.trim(data);
-
-				if (data) {
-					// Make sure the incoming data is actual JSON
-					// Logic borrowed from http://json.org/json2.js
-					if (rvalidchars.test(data.replace(rvalidescape, "@")
-						.replace(rvalidtokens, "]")
-						.replace(rvalidbraces, ""))) {
-
-						return (new Function("return " + data))();
-					}
-				}
-			}
-
-			jQuery.error("Invalid JSON: " + data);
-		},
-
-		// Cross-browser xml parsing
-		parseXML: function (data) {
-			var xml, tmp;
-			if (!data || typeof data !== "string") {
-				return null;
-			}
-			try {
-				if (window.DOMParser) { // Standard
-					tmp = new DOMParser();
-					xml = tmp.parseFromString(data, "text/xml");
-				} else { // IE
-					xml = new ActiveXObject("Microsoft.XMLDOM");
-					xml.async = "false";
-					xml.loadXML(data);
-				}
-			} catch (e) {
-				xml = undefined;
-			}
-			if (!xml || !xml.documentElement || xml.getElementsByTagName("parsererror").length) {
-				jQuery.error("Invalid XML: " + data);
-			}
-			return xml;
-		},
-
-		noop: function () {},
-
-		// Evaluates a script in a global context
-		// Workarounds based on findings by Jim Driscoll
-		// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
-		globalEval: function (data) {
-			if (data && jQuery.trim(data)) {
-				// We use execScript on Internet Explorer
-				// We use an anonymous function so that context is window
-				// rather than jQuery in Firefox
-				(window.execScript || function (data) {
-					window["eval"].call(window, data);
-				})(data);
-			}
-		},
-
-		// Convert dashed to camelCase; used by the css and data modules
-		// Microsoft forgot to hump their vendor prefix (#9572)
-		camelCase: function (string) {
-			return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase);
-		},
-
-		nodeName: function (elem, name) {
-			return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
-		},
-
-		// args is for internal usage only
-		each: function (obj, callback, args) {
-			var value,
-				i = 0,
-				length = obj.length,
-				isArray = isArraylike(obj);
-
-			if (args) {
-				if (isArray) {
-					for (; i < length; i++) {
-						value = callback.apply(obj[i], args);
-
-						if (value === false) {
-							break;
-						}
-					}
-				} else {
-					for (i in obj) {
-						value = callback.apply(obj[i], args);
-
-						if (value === false) {
-							break;
-						}
-					}
-				}
-
-				// A special, fast, case for the most common use of each
-			} else {
-				if (isArray) {
-					for (; i < length; i++) {
-						value = callback.call(obj[i], i, obj[i]);
-
-						if (value === false) {
-							break;
-						}
-					}
-				} else {
-					for (i in obj) {
-						value = callback.call(obj[i], i, obj[i]);
-
-						if (value === false) {
-							break;
-						}
-					}
-				}
-			}
-
-			return obj;
-		},
-
-		// Use native String.trim function wherever possible
-		trim: core_trim && !core_trim.call("\uFEFF\xA0") ? function (text) {
-			return text == null ?
-				"" :
-				core_trim.call(text);
-		} :
-
-		// Otherwise use our own trimming functionality
-
-		function (text) {
-			return text == null ?
-				"" :
-				(text + "").replace(rtrim, "");
-		},
-
-		// results is for internal usage only
-		makeArray: function (arr, results) {
-			var ret = results || [];
-
-			if (arr != null) {
-				if (isArraylike(Object(arr))) {
-					jQuery.merge(ret,
-						typeof arr === "string" ?
-						[arr] : arr
-					);
-				} else {
-					core_push.call(ret, arr);
-				}
-			}
-
-			return ret;
-		},
-
-		inArray: function (elem, arr, i) {
-			var len;
-
-			if (arr) {
-				if (core_indexOf) {
-					return core_indexOf.call(arr, elem, i);
-				}
-
-				len = arr.length;
-				i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
-
-				for (; i < len; i++) {
-					// Skip accessing in sparse arrays
-					if (i in arr && arr[i] === elem) {
-						return i;
-					}
-				}
-			}
-
-			return -1;
-		},
-
-		merge: function (first, second) {
-			var l = second.length,
-				i = first.length,
-				j = 0;
-
-			if (typeof l === "number") {
-				for (; j < l; j++) {
-					first[i++] = second[j];
-				}
-			} else {
-				while (second[j] !== undefined) {
-					first[i++] = second[j++];
-				}
-			}
-
-			first.length = i;
-
-			return first;
-		},
-
-		grep: function (elems, callback, inv) {
-			var retVal,
-				ret = [],
-				i = 0,
-				length = elems.length;
-			inv = !! inv;
-
-			// Go through the array, only saving the items
-			// that pass the validator function
-			for (; i < length; i++) {
-				retVal = !! callback(elems[i], i);
-				if (inv !== retVal) {
-					ret.push(elems[i]);
-				}
-			}
-
-			return ret;
-		},
-
-		// arg is for internal usage only
-		map: function (elems, callback, arg) {
-			var value,
-				i = 0,
-				length = elems.length,
-				isArray = isArraylike(elems),
-				ret = [];
-
-			// Go through the array, translating each of the items to their
-			if (isArray) {
-				for (; i < length; i++) {
-					value = callback(elems[i], i, arg);
-
-					if (value != null) {
-						ret[ret.length] = value;
-					}
-				}
-
-				// Go through every key on the object,
-			} else {
-				for (i in elems) {
-					value = callback(elems[i], i, arg);
-
-					if (value != null) {
-						ret[ret.length] = value;
-					}
-				}
-			}
-
-			// Flatten any nested arrays
-			return core_concat.apply([], ret);
-		},
-
-		// A global GUID counter for objects
-		guid: 1,
-
-		// Bind a function to a context, optionally partially applying any
-		// arguments.
-		proxy: function (fn, context) {
-			var args, proxy, tmp;
-
-			if (typeof context === "string") {
-				tmp = fn[context];
-				context = fn;
-				fn = tmp;
-			}
-
-			// Quick check to determine if target is callable, in the spec
-			// this throws a TypeError, but we will just return undefined.
-			if (!jQuery.isFunction(fn)) {
-				return undefined;
-			}
-
-			// Simulated bind
-			args = core_slice.call(arguments, 2);
-			proxy = function () {
-				return fn.apply(context || this, args.concat(core_slice.call(arguments)));
-			};
-
-			// Set the guid of unique handler to the same of original handler, so it can be removed
-			proxy.guid = fn.guid = fn.guid || jQuery.guid++;
-
-			return proxy;
-		},
-
-		// Multifunctional method to get and set values of a collection
-		// The value/s can optionally be executed if it's a function
-		access: function (elems, fn, key, value, chainable, emptyGet, raw) {
-			var i = 0,
-				length = elems.length,
-				bulk = key == null;
-
-			// Sets many values
-			if (jQuery.type(key) === "object") {
-				chainable = true;
-				for (i in key) {
-					jQuery.access(elems, fn, i, key[i], true, emptyGet, raw);
-				}
-
-				// Sets one value
-			} else if (value !== undefined) {
-				chainable = true;
-
-				if (!jQuery.isFunction(value)) {
-					raw = true;
-				}
-
-				if (bulk) {
-					// Bulk operations run against the entire set
-					if (raw) {
-						fn.call(elems, value);
-						fn = null;
-
-						// ...except when executing function values
-					} else {
-						bulk = fn;
-						fn = function (elem, key, value) {
-							return bulk.call(jQuery(elem), value);
-						};
-					}
-				}
-
-				if (fn) {
-					for (; i < length; i++) {
-						fn(elems[i], key, raw ? value : value.call(elems[i], i, fn(elems[i], key)));
-					}
-				}
-			}
-
-			return chainable ?
-				elems :
-
-			// Gets
-			bulk ?
-				fn.call(elems) :
-				length ? fn(elems[0], key) : emptyGet;
-		},
-
-		now: function () {
-			return (new Date()).getTime();
-		},
-
-		// A method for quickly swapping in/out CSS properties to get correct calculations.
-		// Note: this method belongs to the css module but it's needed here for the support module.
-		// If support gets modularized, this method should be moved back to the css module.
-		swap: function (elem, options, callback, args) {
-			var ret, name,
-				old = {};
-
-			// Remember the old values, and insert the new ones
-			for (name in options) {
-				old[name] = elem.style[name];
-				elem.style[name] = options[name];
-			}
-
-			ret = callback.apply(elem, args || []);
-
-			// Revert the old values
-			for (name in options) {
-				elem.style[name] = old[name];
-			}
-
-			return ret;
-		}
-	});
-
-	jQuery.ready.promise = function (obj) {
-		if (!readyList) {
-
-			readyList = jQuery.Deferred();
-
-			// Catch cases where $(document).ready() is called after the browser event has already occurred.
-			// we once tried to use readyState "interactive" here, but it caused issues like the one
-			// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
-			if (document.readyState === "complete") {
-				// Handle it asynchronously to allow scripts the opportunity to delay ready
-				setTimeout(jQuery.ready);
-
-				// Standards-based browsers support DOMContentLoaded
-			} else if (document.addEventListener) {
-				// Use the handy event callback
-				document.addEventListener("DOMContentLoaded", completed, false);
-
-				// A fallback to window.onload, that will always work
-				window.addEventListener("load", completed, false);
-
-				// If IE event model is used
-			} else {
-				// Ensure firing before onload, maybe late but safe also for iframes
-				document.attachEvent("onreadystatechange", completed);
-
-				// A fallback to window.onload, that will always work
-				window.attachEvent("onload", completed);
-
-				// If IE and not a frame
-				// continually check to see if the document is ready
-				var top = false;
-
-				try {
-					top = window.frameElement == null && document.documentElement;
-				} catch (e) {}
-
-				if (top && top.doScroll) {
-					(function doScrollCheck() {
-						if (!jQuery.isReady) {
-
-							try {
-								// Use the trick by Diego Perini
-								// http://javascript.nwbox.com/IEContentLoaded/
-								top.doScroll("left");
-							} catch (e) {
-								return setTimeout(doScrollCheck, 50);
-							}
-
-							// detach all dom ready events
-							detach();
-
-							// and execute any waiting functions
-							jQuery.ready();
-						}
-					})();
-				}
-			}
-		}
-		return readyList.promise(obj);
-	};
-
-	// Populate the class2type map
-	jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function (i, name) {
-		class2type["[object " + name + "]"] = name.toLowerCase();
-	});
-
-	function isArraylike(obj) {
-		var length = obj.length,
-			type = jQuery.type(obj);
-
-		if (jQuery.isWindow(obj)) {
-			return false;
-		}
-
-		if (obj.nodeType === 1 && length) {
-			return true;
-		}
-
-		return type === "array" || type !== "function" &&
-			(length === 0 ||
-			typeof length === "number" && length > 0 && (length - 1) in obj);
-	}
-
-	// All jQuery objects should point back to these
-	rootjQuery = jQuery(document);
-	/*!
-	 * Sizzle CSS Selector Engine v1.10.2
-	 * http://sizzlejs.com/
-	 *
-	 * Copyright 2013 jQuery Foundation, Inc. and other contributors
-	 * Released under the MIT license
-	 * http://jquery.org/license
-	 *
-	 * Date: 2013-07-03
-	 */
-	(function (window, undefined) {
-
-		var i,
-			support,
-			cachedruns,
-			Expr,
-			getText,
-			isXML,
-			compile,
-			outermostContext,
-			sortInput,
-
-			// Local document vars
-			setDocument,
-			document,
-			docElem,
-			documentIsHTML,
-			rbuggyQSA,
-			rbuggyMatches,
-			matches,
-			contains,
-
-			// Instance-specific data
-			expando = "sizzle" + -(new Date()),
-			preferredDoc = window.document,
-			dirruns = 0,
-			done = 0,
-			classCache = createCache(),
-			tokenCache = createCache(),
-			compilerCache = createCache(),
-			hasDuplicate = false,
-			sortOrder = function (a, b) {
-				if (a === b) {
-					hasDuplicate = true;
-					return 0;
-				}
-				return 0;
-			},
-
-			// General-purpose constants
-			strundefined = typeof undefined,
-			MAX_NEGATIVE = 1 << 31,
-
-			// Instance methods
-			hasOwn = ({}).hasOwnProperty,
-			arr = [],
-			pop = arr.pop,
-			push_native = arr.push,
-			push = arr.push,
-			slice = arr.slice,
-			// Use a stripped-down indexOf if we can't use a native one
-			indexOf = arr.indexOf || function (elem) {
-				var i = 0,
-					len = this.length;
-				for (; i < len; i++) {
-					if (this[i] === elem) {
-						return i;
-					}
-				}
-				return -1;
-			},
-
-			booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
-
-			// Regular expressions
-
-			// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
-			whitespace = "[\\x20\\t\\r\\n\\f]",
-			// http://www.w3.org/TR/css3-syntax/#characters
-			characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
-
-			// Loosely modeled on CSS identifier characters
-			// An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors
-			// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
-			identifier = characterEncoding.replace("w", "w#"),
-
-			// Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors
-			attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace +
-				"*(?:([*^$|!~]?=)" + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]",
-
-			// Prefer arguments quoted,
-			//   then not containing pseudos/brackets,
-			//   then attribute selectors/non-parenthetical expressions,
-			//   then anything else
-			// These preferences are here to reduce the number of selectors
-			//   needing tokenize in the PSEUDO preFilter
-			pseudos = ":(" + characterEncoding + ")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|" + attributes.replace(3, 8) + ")*)|.*)\\)|)",
-
-			// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
-			rtrim = new RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g"),
-
-			rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"),
-			rcombinators = new RegExp("^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"),
-
-			rsibling = new RegExp(whitespace + "*[+~]"),
-			rattributeQuotes = new RegExp("=" + whitespace + "*([^\\]'\"]*)" + whitespace + "*\\]", "g"),
-
-			rpseudo = new RegExp(pseudos),
-			ridentifier = new RegExp("^" + identifier + "$"),
-
-			matchExpr = {
-				"ID": new RegExp("^#(" + characterEncoding + ")"),
-				"CLASS": new RegExp("^\\.(" + characterEncoding + ")"),
-				"TAG": new RegExp("^(" + characterEncoding.replace("w", "w*") + ")"),
-				"ATTR": new RegExp("^" + attributes),
-				"PSEUDO": new RegExp("^" + pseudos),
-				"CHILD": new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
-					"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
-					"*(\\d+)|))" + whitespace + "*\\)|)", "i"),
-				"bool": new RegExp("^(?:" + booleans + ")$", "i"),
-				// For use in libraries implementing .is()
-				// We use this for POS matching in `select`
-				"needsContext": new RegExp("^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
-					whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i")
-			},
-
-			rnative = /^[^{]+\{\s*\[native \w/,
-
-			// Easily-parseable/retrievable ID or TAG or CLASS selectors
-			rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
-
-			rinputs = /^(?:input|select|textarea|button)$/i,
-			rheader = /^h\d$/i,
-
-			rescape = /'|\\/g,
-
-			// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
-			runescape = new RegExp("\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig"),
-			funescape = function (_, escaped, escapedWhitespace) {
-				var high = "0x" + escaped - 0x10000;
-				// NaN means non-codepoint
-				// Support: Firefox
-				// Workaround erroneous numeric interpretation of +"0x"
-				return high !== high || escapedWhitespace ?
-					escaped :
-				// BMP codepoint
-				high < 0 ?
-					String.fromCharCode(high + 0x10000) :
-				// Supplemental Plane codepoint (surrogate pair)
-				String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00);
-			};
-
-		// Optimize for push.apply( _, NodeList )
-		try {
-			push.apply(
-				(arr = slice.call(preferredDoc.childNodes)),
-				preferredDoc.childNodes
-			);
-			// Support: Android<4.0
-			// Detect silently failing push.apply
-			arr[preferredDoc.childNodes.length].nodeType;
-		} catch (e) {
-			push = {
-				apply: arr.length ?
-
-				// Leverage slice if possible
-
-				function (target, els) {
-					push_native.apply(target, slice.call(els));
-				} :
-
-				// Support: IE<9
-				// Otherwise append directly
-
-				function (target, els) {
-					var j = target.length,
-						i = 0;
-					// Can't trust NodeList.length
-					while ((target[j++] = els[i++])) {}
-					target.length = j - 1;
-				}
-			};
-		}
-
-		function Sizzle(selector, context, results, seed) {
-			var match, elem, m, nodeType,
-				// QSA vars
-				i, groups, old, nid, newContext, newSelector;
-
-			if ((context ? context.ownerDocument || context : preferredDoc) !== document) {
-				setDocument(context);
-			}
-
-			context = context || document;
-			results = results || [];
-
-			if (!selector || typeof selector !== "string") {
-				return results;
-			}
-
-			if ((nodeType = context.nodeType) !== 1 && nodeType !== 9) {
-				return [];
-			}
-
-			if (documentIsHTML && !seed) {
-
-				// Shortcuts
-				if ((match = rquickExpr.exec(selector))) {
-					// Speed-up: Sizzle("#ID")
-					if ((m = match[1])) {
-						if (nodeType === 9) {
-							elem = context.getElementById(m);
-							// Check parentNode to catch when Blackberry 4.6 returns
-							// nodes that are no longer in the document #6963
-							if (elem && elem.parentNode) {
-								// Handle the case where IE, Opera, and Webkit return items
-								// by name instead of ID
-								if (elem.id === m) {
-									results.push(elem);
-									return results;
-								}
-							} else {
-								return results;
-							}
-						} else {
-							// Context is not a document
-							if (context.ownerDocument && (elem = context.ownerDocument.getElementById(m)) &&
-								contains(context, elem) && elem.id === m) {
-								results.push(elem);
-								return results;
-							}
-						}
-
-						// Speed-up: Sizzle("TAG")
-					} else if (match[2]) {
-						push.apply(results, context.getElementsByTagName(selector));
-						return results;
-
-						// Speed-up: Sizzle(".CLASS")
-					} else if ((m = match[3]) && support.getElementsByClassName && context.getElementsByClassName) {
-						push.apply(results, context.getElementsByClassName(m));
-						return results;
-					}
-				}
-
-				// QSA path
-				if (support.qsa && (!rbuggyQSA || !rbuggyQSA.test(selector))) {
-					nid = old = expando;
-					newContext = context;
-					newSelector = nodeType === 9 && selector;
-
-					// qSA works strangely on Element-rooted queries
-					// We can work around this by specifying an extra ID on the root
-					// and working up from there (Thanks to Andrew Dupont for the technique)
-					// IE 8 doesn't work on object elements
-					if (nodeType === 1 && context.nodeName.toLowerCase() !== "object") {
-						groups = tokenize(selector);
-
-						if ((old = context.getAttribute("id"))) {
-							nid = old.replace(rescape, "\\$&");
-						} else {
-							context.setAttribute("id", nid);
-						}
-						nid = "[id='" + nid + "'] ";
-
-						i = groups.length;
-						while (i--) {
-							groups[i] = nid + toSelector(groups[i]);
-						}
-						newContext = rsibling.test(selector) && context.parentNode || context;
-						newSelector = groups.join(",");
-					}
-
-					if (newSelector) {
-						try {
-							push.apply(results,
-								newContext.querySelectorAll(newSelector)
-							);
-							return results;
-						} catch (qsaError) {} finally {
-							if (!old) {
-								context.removeAttribute("id");
-							}
-						}
-					}
-				}
-			}
-
-			// All others
-			return select(selector.replace(rtrim, "$1"), context, results, seed);
-		}
-
-		/**
-		 * Create key-value caches of limited size
-		 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
-		 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
-		 *	deleting the oldest entry
-		 */
-
-		function createCache() {
-			var keys = [];
-
-			function cache(key, value) {
-				// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
-				if (keys.push(key += " ") > Expr.cacheLength) {
-					// Only keep the most recent entries
-					delete cache[keys.shift()];
-				}
-				return (cache[key] = value);
-			}
-			return cache;
-		}
-
-		/**
-		 * Mark a function for special use by Sizzle
-		 * @param {Function} fn The function to mark
-		 */
-
-		function markFunction(fn) {
-			fn[expando] = true;
-			return fn;
-		}
-
-		/**
-		 * Support testing using an element
-		 * @param {Function} fn Passed the created div and expects a boolean result
-		 */
-
-		function assert(fn) {
-			var div = document.createElement("div");
-
-			try {
-				return !!fn(div);
-			} catch (e) {
-				return false;
-			} finally {
-				// Remove from its parent by default
-				if (div.parentNode) {
-					div.parentNode.removeChild(div);
-				}
-				// release memory in IE
-				div = null;
-			}
-		}
-
-		/**
-		 * Adds the same handler for all of the specified attrs
-		 * @param {String} attrs Pipe-separated list of attributes
-		 * @param {Function} handler The method that will be applied
-		 */
-
-		function addHandle(attrs, handler) {
-			var arr = attrs.split("|"),
-				i = attrs.length;
-
-			while (i--) {
-				Expr.attrHandle[arr[i]] = handler;
-			}
-		}
-
-		/**
-		 * Checks document order of two siblings
-		 * @param {Element} a
-		 * @param {Element} b
-		 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
-		 */
-
-		function siblingCheck(a, b) {
-			var cur = b && a,
-				diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
-					(~b.sourceIndex || MAX_NEGATIVE) -
-					(~a.sourceIndex || MAX_NEGATIVE);
-
-			// Use IE sourceIndex if available on both nodes
-			if (diff) {
-				return diff;
-			}
-
-			// Check if b follows a
-			if (cur) {
-				while ((cur = cur.nextSibling)) {
-					if (cur === b) {
-						return -1;
-					}
-				}
-			}
-
-			return a ? 1 : -1;
-		}
-
-		/**
-		 * Returns a function to use in pseudos for input types
-		 * @param {String} type
-		 */
-
-		function createInputPseudo(type) {
-			return function (elem) {
-				var name = elem.nodeName.toLowerCase();
-				return name === "input" && elem.type === type;
-			};
-		}
-
-		/**
-		 * Returns a function to use in pseudos for buttons
-		 * @param {String} type
-		 */
-
-		function createButtonPseudo(type) {
-			return function (elem) {
-				var name = elem.nodeName.toLowerCase();
-				return (name === "input" || name === "button") && elem.type === type;
-			};
-		}
-
-		/**
-		 * Returns a function to use in pseudos for positionals
-		 * @param {Function} fn
-		 */
-
-		function createPositionalPseudo(fn) {
-			return markFunction(function (argument) {
-				argument = +argument;
-				return markFunction(function (seed, matches) {
-					var j,
-						matchIndexes = fn([], seed.length, argument),
-						i = matchIndexes.length;
-
-					// Match elements found at the specified indexes
-					while (i--) {
-						if (seed[(j = matchIndexes[i])]) {
-							seed[j] = !(matches[j] = seed[j]);
-						}
-					}
-				});
-			});
-		}
-
-		/**
-		 * Detect xml
-		 * @param {Element|Object} elem An element or a document
-		 */
-		isXML = Sizzle.isXML = function (elem) {
-			// documentElement is verified for cases where it doesn't yet exist
-			// (such as loading iframes in IE - #4833)
-			var documentElement = elem && (elem.ownerDocument || elem).documentElement;
-			return documentElement ? documentElement.nodeName !== "HTML" : false;
-		};
-
-		// Expose support vars for convenience
-		support = Sizzle.support = {};
-
-		/**
-		 * Sets document-related variables once based on the current document
-		 * @param {Element|Object} [doc] An element or document object to use to set the document
-		 * @returns {Object} Returns the current document
-		 */
-		setDocument = Sizzle.setDocument = function (node) {
-			var doc = node ? node.ownerDocument || node : preferredDoc,
-				parent = doc.defaultView;
-
-			// If no document and documentElement is available, return
-			if (doc === document || doc.nodeType !== 9 || !doc.documentElement) {
-				return document;
-			}
-
-			// Set our document
-			document = doc;
-			docElem = doc.documentElement;
-
-			// Support tests
-			documentIsHTML = !isXML(doc);
-
-			// Support: IE>8
-			// If iframe document is assigned to "document" variable and if iframe has been reloaded,
-			// IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936
-			// IE6-8 do not support the defaultView property so parent will be undefined
-			if (parent && parent.attachEvent && parent !== parent.top) {
-				parent.attachEvent("onbeforeunload", function () {
-					setDocument();
-				});
-			}
-
-			/* Attributes
-	---------------------------------------------------------------------- */
-
-			// Support: IE<8
-			// Verify that getAttribute really returns attributes and not properties (excepting IE8 booleans)
-			support.attributes = assert(function (div) {
-				div.className = "i";
-				return !div.getAttribute("className");
-			});
-
-			/* getElement(s)By*
-	---------------------------------------------------------------------- */
-
-			// Check if getElementsByTagName("*") returns only elements
-			support.getElementsByTagName = assert(function (div) {
-				div.appendChild(doc.createComment(""));
-				return !div.getElementsByTagName("*").length;
-			});
-
-			// Check if getElementsByClassName can be trusted
-			support.getElementsByClassName = assert(function (div) {
-				div.innerHTML = "<div class='a'></div><div class='a i'></div>";
-
-				// Support: Safari<4
-				// Catch class over-caching
-				div.firstChild.className = "i";
-				// Support: Opera<10
-				// Catch gEBCN failure to find non-leading classes
-				return div.getElementsByClassName("i").length === 2;
-			});
-
-			// Support: IE<10
-			// Check if getElementById returns elements by name
-			// The broken getElementById methods don't pick up programatically-set names,
-			// so use a roundabout getElementsByName test
-			support.getById = assert(function (div) {
-				docElem.appendChild(div).id = expando;
-				return !doc.getElementsByName || !doc.getElementsByName(expando).length;
-			});
-
-			// ID find and filter
-			if (support.getById) {
-				Expr.find["ID"] = function (id, context) {
-					if (typeof context.getElementById !== strundefined && documentIsHTML) {
-						var m = context.getElementById(id);
-						// Check parentNode to catch when Blackberry 4.6 returns
-						// nodes that are no longer in the document #6963
-						return m && m.parentNode ? [m] : [];
-					}
-				};
-				Expr.filter["ID"] = function (id) {
-					var attrId = id.replace(runescape, funescape);
-					return function (elem) {
-						return elem.getAttribute("id") === attrId;
-					};
-				};
-			} else {
-				// Support: IE6/7
-				// getElementById is not reliable as a find shortcut
-				delete Expr.find["ID"];
-
-				Expr.filter["ID"] = function (id) {
-					var attrId = id.replace(runescape, funescape);
-					return function (elem) {
-						var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
-						return node && node.value === attrId;
-					};
-				};
-			}
-
-			// Tag
-			Expr.find["TAG"] = support.getElementsByTagName ?
-				function (tag, context) {
-					if (typeof context.getElementsByTagName !== strundefined) {
-						return context.getElementsByTagName(tag);
-					}
-			} :
-				function (tag, context) {
-					var elem,
-						tmp = [],
-						i = 0,
-						results = context.getElementsByTagName(tag);
-
-					// Filter out possible comments
-					if (tag === "*") {
-						while ((elem = results[i++])) {
-							if (elem.nodeType === 1) {
-								tmp.push(elem);
-							}
-						}
-
-						return tmp;
-					}
-					return results;
-			};
-
-			// Class
-			Expr.find["CLASS"] = support.getElementsByClassName && function (className, context) {
-				if (typeof context.getElementsByClassName !== strundefined && documentIsHTML) {
-					return context.getElementsByClassName(className);
-				}
-			};
-
-			/* QSA/matchesSelector
-	---------------------------------------------------------------------- */
-
-			// QSA and matchesSelector support
-
-			// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
-			rbuggyMatches = [];
-
-			// qSa(:focus) reports false when true (Chrome 21)
-			// We allow this because of a bug in IE8/9 that throws an error
-			// whenever `document.activeElement` is accessed on an iframe
-			// So, we allow :focus to pass through QSA all the time to avoid the IE error
-			// See http://bugs.jquery.com/ticket/13378
-			rbuggyQSA = [];
-
-			if ((support.qsa = rnative.test(doc.querySelectorAll))) {
-				// Build QSA regex
-				// Regex strategy adopted from Diego Perini
-				assert(function (div) {
-					// Select is set to empty string on purpose
-					// This is to test IE's treatment of not explicitly
-					// setting a boolean content attribute,
-					// since its presence should be enough
-					// http://bugs.jquery.com/ticket/12359
-					div.innerHTML = "<select><option selected=''></option></select>";
-
-					// Support: IE8
-					// Boolean attributes and "value" are not treated correctly
-					if (!div.querySelectorAll("[selected]").length) {
-						rbuggyQSA.push("\\[" + whitespace + "*(?:value|" + booleans + ")");
-					}
-
-					// Webkit/Opera - :checked should return selected option elements
-					// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
-					// IE8 throws error here and will not see later tests
-					if (!div.querySelectorAll(":checked").length) {
-						rbuggyQSA.push(":checked");
-					}
-				});
-
-				assert(function (div) {
-
-					// Support: Opera 10-12/IE8
-					// ^= $= *= and empty values
-					// Should not select anything
-					// Support: Windows 8 Native Apps
-					// The type attribute is restricted during .innerHTML assignment
-					var input = doc.createElement("input");
-					input.setAttribute("type", "hidden");
-					div.appendChild(input).setAttribute("t", "");
-
-					if (div.querySelectorAll("[t^='']").length) {
-						rbuggyQSA.push("[*^$]=" + whitespace + "*(?:''|\"\")");
-					}
-
-					// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
-					// IE8 throws error here and will not see later tests
-					if (!div.querySelectorAll(":enabled").length) {
-						rbuggyQSA.push(":enabled", ":disabled");
-					}
-
-					// Opera 10-11 does not throw on post-comma invalid pseudos
-					div.querySelectorAll("*,:x");
-					rbuggyQSA.push(",.*:");
-				});
-			}
-
-			if ((support.matchesSelector = rnative.test((matches = docElem.webkitMatchesSelector ||
-				docElem.mozMatchesSelector ||
-				docElem.oMatchesSelector ||
-				docElem.msMatchesSelector)))) {
-
-				assert(function (div) {
-					// Check to see if it's possible to do matchesSelector
-					// on a disconnected node (IE 9)
-					support.disconnectedMatch = matches.call(div, "div");
-
-					// This should fail with an exception
-					// Gecko does not error, returns false instead
-					matches.call(div, "[s!='']:x");
-					rbuggyMatches.push("!=", pseudos);
-				});
-			}
-
-			rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|"));
-			rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join("|"));
-
-			/* Contains
-	---------------------------------------------------------------------- */
-
-			// Element contains another
-			// Purposefully does not implement inclusive descendent
-			// As in, an element does not contain itself
-			contains = rnative.test(docElem.contains) || docElem.compareDocumentPosition ?
-				function (a, b) {
-					var adown = a.nodeType === 9 ? a.documentElement : a,
-						bup = b && b.parentNode;
-					return a === bup || !! (bup && bup.nodeType === 1 && (
-						adown.contains ?
-						adown.contains(bup) :
-						a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16
-					));
-			} :
-				function (a, b) {
-					if (b) {
-						while ((b = b.parentNode)) {
-							if (b === a) {
-								return true;
-							}
-						}
-					}
-					return false;
-			};
-
-			/* Sorting
-	---------------------------------------------------------------------- */
-
-			// Document order sorting
-			sortOrder = docElem.compareDocumentPosition ?
-				function (a, b) {
-
-					// Flag for duplicate removal
-					if (a === b) {
-						hasDuplicate = true;
-						return 0;
-					}
-
-					var compare = b.compareDocumentPosition && a.compareDocumentPosition && a.compareDocumentPosition(b);
-
-					if (compare) {
-						// Disconnected nodes
-						if (compare & 1 ||
-							(!support.sortDetached && b.compareDocumentPosition(a) === compare)) {
-
-							// Choose the first element that is related to our preferred document
-							if (a === doc || contains(preferredDoc, a)) {
-								return -1;
-							}
-							if (b === doc || contains(preferredDoc, b)) {
-								return 1;
-							}
-
-							// Maintain original order
-							return sortInput ?
-								(indexOf.call(sortInput, a) - indexOf.call(sortInput, b)) :
-								0;
-						}
-
-						return compare & 4 ? -1 : 1;
-					}
-
-					// Not directly comparable, sort on existence of method
-					return a.compareDocumentPosition ? -1 : 1;
-			} :
-				function (a, b) {
-					var cur,
-						i = 0,
-						aup = a.parentNode,
-						bup = b.parentNode,
-						ap = [a],
-						bp = [b];
-
-					// Exit early if the nodes are identical
-					if (a === b) {
-						hasDuplicate = true;
-						return 0;
-
-						// Parentless nodes are either documents or disconnected
-					} else if (!aup || !bup) {
-						return a === doc ? -1 :
-							b === doc ? 1 :
-							aup ? -1 :
-							bup ? 1 :
-							sortInput ?
-							(indexOf.call(sortInput, a) - indexOf.call(sortInput, b)) :
-							0;
-
-						// If the nodes are siblings, we can do a quick check
-					} else if (aup === bup) {
-						return siblingCheck(a, b);
-					}
-
-					// Otherwise we need full lists of their ancestors for comparison
-					cur = a;
-					while ((cur = cur.parentNode)) {
-						ap.unshift(cur);
-					}
-					cur = b;
-					while ((cur = cur.parentNode)) {
-						bp.unshift(cur);
-					}
-
-					// Walk down the tree looking for a discrepancy
-					while (ap[i] === bp[i]) {
-						i++;
-					}
-
-					return i ?
-					// Do a sibling check if the nodes have a common ancestor
-					siblingCheck(ap[i], bp[i]) :
-
-					// Otherwise nodes in our document sort first
-					ap[i] === preferredDoc ? -1 :
-						bp[i] === preferredDoc ? 1 :
-						0;
-			};
-
-			return doc;
-		};
-
-		Sizzle.matches = function (expr, elements) {
-			return Sizzle(expr, null, null, elements);
-		};
-
-		Sizzle.matchesSelector = function (elem, expr) {
-			// Set document vars if needed
-			if ((elem.ownerDocument || elem) !== document) {
-				setDocument(elem);
-			}
-
-			// Make sure that attribute selectors are quoted
-			expr = expr.replace(rattributeQuotes, "='$1']");
-
-			if (support.matchesSelector && documentIsHTML &&
-				(!rbuggyMatches || !rbuggyMatches.test(expr)) &&
-				(!rbuggyQSA || !rbuggyQSA.test(expr))) {
-
-				try {
-					var ret = matches.call(elem, expr);
-
-					// IE 9's matchesSelector returns false on disconnected nodes
-					if (ret || support.disconnectedMatch ||
-						// As well, disconnected nodes are said to be in a document
-						// fragment in IE 9
-						elem.document && elem.document.nodeType !== 11) {
-						return ret;
-					}
-				} catch (e) {}
-			}
-
-			return Sizzle(expr, document, null, [elem]).length > 0;
-		};
-
-		Sizzle.contains = function (context, elem) {
-			// Set document vars if needed
-			if ((context.ownerDocument || context) !== document) {
-				setDocument(context);
-			}
-			return contains(context, elem);
-		};
-
-		Sizzle.attr = function (elem, name) {
-			// Set document vars if needed
-			if ((elem.ownerDocument || elem) !== document) {
-				setDocument(elem);
-			}
-
-			var fn = Expr.attrHandle[name.toLowerCase()],
-				// Don't get fooled by Object.prototype properties (jQuery #13807)
-				val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ?
-					fn(elem, name, !documentIsHTML) :
-					undefined;
-
-			return val === undefined ?
-				support.attributes || !documentIsHTML ?
-				elem.getAttribute(name) :
-				(val = elem.getAttributeNode(name)) && val.specified ?
-				val.value :
-				null :
-				val;
-		};
-
-		Sizzle.error = function (msg) {
-			throw new Error("Syntax error, unrecognized expression: " + msg);
-		};
-
-		/**
-		 * Document sorting and removing duplicates
-		 * @param {ArrayLike} results
-		 */
-		Sizzle.uniqueSort = function (results) {
-			var elem,
-				duplicates = [],
-				j = 0,
-				i = 0;
-
-			// Unless we *know* we can detect duplicates, assume their presence
-			hasDuplicate = !support.detectDuplicates;
-			sortInput = !support.sortStable && results.slice(0);
-			results.sort(sortOrder);
-
-			if (hasDuplicate) {
-				while ((elem = results[i++])) {
-					if (elem === results[i]) {
-						j = duplicates.push(i);
-					}
-				}
-				while (j--) {
-					results.splice(duplicates[j], 1);
-				}
-			}
-
-			return results;
-		};
-
-		/**
-		 * Utility function for retrieving the text value of an array of DOM nodes
-		 * @param {Array|Element} elem
-		 */
-		getText = Sizzle.getText = function (elem) {
-			var node,
-				ret = "",
-				i = 0,
-				nodeType = elem.nodeType;
-
-			if (!nodeType) {
-				// If no nodeType, this is expected to be an array
-				for (;
-					(node = elem[i]); i++) {
-					// Do not traverse comment nodes
-					ret += getText(node);
-				}
-			} else if (nodeType === 1 || nodeType === 9 || nodeType === 11) {
-				// Use textContent for elements
-				// innerText usage removed for consistency of new lines (see #11153)
-				if (typeof elem.textContent === "string") {
-					return elem.textContent;
-				} else {
-					// Traverse its children
-					for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
-						ret += getText(elem);
-					}
-				}
-			} else if (nodeType === 3 || nodeType === 4) {
-				return elem.nodeValue;
-			}
-			// Do not include comment or processing instruction nodes
-
-			return ret;
-		};
-
-		Expr = Sizzle.selectors = {
-
-			// Can be adjusted by the user
-			cacheLength: 50,
-
-			createPseudo: markFunction,
-
-			match: matchExpr,
-
-			attrHandle: {},
-
-			find: {},
-
-			relative: {
-				">": {
-					dir: "parentNode",
-					first: true
-				},
-				" ": {
-					dir: "parentNode"
-				},
-				"+": {
-					dir: "previousSibling",
-					first: true
-				},
-				"~": {
-					dir: "previousSibling"
-				}
-			},
-
-			preFilter: {
-				"ATTR": function (match) {
-					match[1] = match[1].replace(runescape, funescape);
-
-					// Move the given value to match[3] whether quoted or unquoted
-					match[3] = (match[4] || match[5] || "").replace(runescape, funescape);
-
-					if (match[2] === "~=") {
-						match[3] = " " + match[3] + " ";
-					}
-
-					return match.slice(0, 4);
-				},
-
-				"CHILD": function (match) {
-					/* matches from matchExpr["CHILD"]
-				1 type (only|nth|...)
-				2 what (child|of-type)
-				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
-				4 xn-component of xn+y argument ([+-]?\d*n|)
-				5 sign of xn-component
-				6 x of xn-component
-				7 sign of y-component
-				8 y of y-component
-			*/
-					match[1] = match[1].toLowerCase();
-
-					if (match[1].slice(0, 3) === "nth") {
-						// nth-* requires argument
-						if (!match[3]) {
-							Sizzle.error(match[0]);
-						}
-
-						// numeric x and y parameters for Expr.filter.CHILD
-						// remember that false/true cast respectively to 0/1
-						match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === "even" || match[3] === "odd"));
-						match[5] = +((match[7] + match[8]) || match[3] === "odd");
-
-						// other types prohibit arguments
-					} else if (match[3]) {
-						Sizzle.error(match[0]);
-					}
-
-					return match;
-				},
-
-				"PSEUDO": function (match) {
-					var excess,
-						unquoted = !match[5] && match[2];
-
-					if (matchExpr["CHILD"].test(match[0])) {
-						return null;
-					}
-
-					// Accept quoted arguments as-is
-					if (match[3] && match[4] !== undefined) {
-						match[2] = match[4];
-
-						// Strip excess characters from unquoted arguments
-					} else if (unquoted && rpseudo.test(unquoted) &&
-						// Get excess from tokenize (recursively)
-						(excess = tokenize(unquoted, true)) &&
-						// advance to the next closing parenthesis
-						(excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)) {
-
-						// excess is a negative index
-						match[0] = match[0].slice(0, excess);
-						match[2] = unquoted.slice(0, excess);
-					}
-
-					// Return only captures needed by the pseudo filter method (type and argument)
-					return match.slice(0, 3);
-				}
-			},
-
-			filter: {
-
-				"TAG": function (nodeNameSelector) {
-					var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();
-					return nodeNameSelector === "*" ?
-						function () {
-							return true;
-					} :
-						function (elem) {
-							return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
-					};
-				},
-
-				"CLASS": function (className) {
-					var pattern = classCache[className + " "];
-
-					return pattern ||
-						(pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)")) &&
-						classCache(className, function (elem) {
-							return pattern.test(typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== strundefined && elem.getAttribute("class") || "");
-						});
-				},
-
-				"ATTR": function (name, operator, check) {
-					return function (elem) {
-						var result = Sizzle.attr(elem, name);
-
-						if (result == null) {
-							return operator === "!=";
-						}
-						if (!operator) {
-							return true;
-						}
-
-						result += "";
-
-						return operator === "=" ? result === check :
-							operator === "!=" ? result !== check :
-							operator === "^=" ? check && result.indexOf(check) === 0 :
-							operator === "*=" ? check && result.indexOf(check) > -1 :
-							operator === "$=" ? check && result.slice(-check.length) === check :
-							operator === "~=" ? (" " + result + " ").indexOf(check) > -1 :
-							operator === "|=" ? result === check || result.slice(0, check.length + 1) === check + "-" :
-							false;
-					};
-				},
-
-				"CHILD": function (type, what, argument, first, last) {
-					var simple = type.slice(0, 3) !== "nth",
-						forward = type.slice(-4) !== "last",
-						ofType = what === "of-type";
-
-					return first === 1 && last === 0 ?
-
-					// Shortcut for :nth-*(n)
-
-					function (elem) {
-						return !!elem.parentNode;
-					} :
-
-					function (elem, context, xml) {
-						var cache, outerCache, node, diff, nodeIndex, start,
-							dir = simple !== forward ? "nextSibling" : "previousSibling",
-							parent = elem.parentNode,
-							name = ofType && elem.nodeName.toLowerCase(),
-							useCache = !xml && !ofType;
-
-						if (parent) {
-
-							// :(first|last|only)-(child|of-type)
-							if (simple) {
-								while (dir) {
-									node = elem;
-									while ((node = node[dir])) {
-										if (ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) {
-											return false;
-										}
-									}
-									// Reverse direction for :only-* (if we haven't yet done so)
-									start = dir = type === "only" && !start && "nextSibling";
-								}
-								return true;
-							}
-
-							start = [forward ? parent.firstChild : parent.lastChild];
-
-							// non-xml :nth-child(...) stores cache data on `parent`
-							if (forward && useCache) {
-								// Seek `elem` from a previously-cached index
-								outerCache = parent[expando] || (parent[expando] = {});
-								cache = outerCache[type] || [];
-								nodeIndex = cache[0] === dirruns && cache[1];
-								diff = cache[0] === dirruns && cache[2];
-								node = nodeIndex && parent.childNodes[nodeIndex];
-
-								while ((node = ++nodeIndex && node && node[dir] ||
-
-									// Fallback to seeking `elem` from the start
-									(diff = nodeIndex = 0) || start.pop())) {
-
-									// When found, cache indexes on `parent` and break
-									if (node.nodeType === 1 && ++diff && node === elem) {
-										outerCache[type] = [dirruns, nodeIndex, diff];
-										break;
-									}
-								}
-
-								// Use previously-cached element index if available
-							} else if (useCache && (cache = (elem[expando] || (elem[expando] = {}))[type]) && cache[0] === dirruns) {
-								diff = cache[1];
-
-								// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
-							} else {
-								// Use the same loop as above to seek `elem` from the start
-								while ((node = ++nodeIndex && node && node[dir] ||
-									(diff = nodeIndex = 0) || start.pop())) {
-
-									if ((ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) && ++diff) {
-										// Cache the index of each encountered element
-										if (useCache) {
-											(node[expando] || (node[expando] = {}))[type] = [dirruns, diff];
-										}
-
-										if (node === elem) {
-											break;
-										}
-									}
-								}
-							}
-
-							// Incorporate the offset, then check against cycle size
-							diff -= last;
-							return diff === first || (diff % first === 0 && diff / first >= 0);
-						}
-					};
-				},
-
-				"PSEUDO": function (pseudo, argument) {
-					// pseudo-class names are case-insensitive
-					// http://www.w3.org/TR/selectors/#pseudo-classes
-					// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
-					// Remember that setFilters inherits from pseudos
-					var args,
-						fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] ||
-							Sizzle.error("unsupported pseudo: " + pseudo);
-
-					// The user may use createPseudo to indicate that
-					// arguments are needed to create the filter function
-					// just as Sizzle does
-					if (fn[expando]) {
-						return fn(argument);
-					}
-
-					// But maintain support for old signatures
-					if (fn.length > 1) {
-						args = [pseudo, pseudo, "", argument];
-						return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ?
-							markFunction(function (seed, matches) {
-								var idx,
-									matched = fn(seed, argument),
-									i = matched.length;
-								while (i--) {
-									idx = indexOf.call(seed, matched[i]);
-									seed[idx] = !(matches[idx] = matched[i]);
-								}
-							}) :
-							function (elem) {
-								return fn(elem, 0, args);
-						};
-					}
-
-					return fn;
-				}
-			},
-
-			pseudos: {
-				// Potentially complex pseudos
-				"not": markFunction(function (selector) {
-					// Trim the selector passed to compile
-					// to avoid treating leading and trailing
-					// spaces as combinators
-					var input = [],
-						results = [],
-						matcher = compile(selector.replace(rtrim, "$1"));
-
-					return matcher[expando] ?
-						markFunction(function (seed, matches, context, xml) {
-							var elem,
-								unmatched = matcher(seed, null, xml, []),
-								i = seed.length;
-
-							// Match elements unmatched by `matcher`
-							while (i--) {
-								if ((elem = unmatched[i])) {
-									seed[i] = !(matches[i] = elem);
-								}
-							}
-						}) :
-						function (elem, context, xml) {
-							input[0] = elem;
-							matcher(input, null, xml, results);
-							return !results.pop();
-					};
-				}),
-
-				"has": markFunction(function (selector) {
-					return function (elem) {
-						return Sizzle(selector, elem).length > 0;
-					};
-				}),
-
-				"contains": markFunction(function (text) {
-					return function (elem) {
-						return (elem.textContent || elem.innerText || getText(elem)).indexOf(text) > -1;
-					};
-				}),
-
-				// "Whether an element is represented by a :lang() selector
-				// is based solely on the element's language value
-				// being equal to the identifier C,
-				// or beginning with the identifier C immediately followed by "-".
-				// The matching of C against the element's language value is performed case-insensitively.
-				// The identifier C does not have to be a valid language name."
-				// http://www.w3.org/TR/selectors/#lang-pseudo
-				"lang": markFunction(function (lang) {
-					// lang value must be a valid identifier
-					if (!ridentifier.test(lang || "")) {
-						Sizzle.error("unsupported lang: " + lang);
-					}
-					lang = lang.replace(runescape, funescape).toLowerCase();
-					return function (elem) {
-						var elemLang;
-						do {
-							if ((elemLang = documentIsHTML ?
-								elem.lang :
-								elem.getAttribute("xml:lang") || elem.getAttribute("lang"))) {
-
-								elemLang = elemLang.toLowerCase();
-								return elemLang === lang || elemLang.indexOf(lang + "-") === 0;
-							}
-						} while ((elem = elem.parentNode) && elem.nodeType === 1);
-						return false;
-					};
-				}),
-
-				// Miscellaneous
-				"target": function (elem) {
-					var hash = window.location && window.location.hash;
-					return hash && hash.slice(1) === elem.id;
-				},
-
-				"root": function (elem) {
-					return elem === docElem;
-				},
-
-				"focus": function (elem) {
-					return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !! (elem.type || elem.href || ~elem.tabIndex);
-				},
-
-				// Boolean properties
-				"enabled": function (elem) {
-					return elem.disabled === false;
-				},
-
-				"disabled": function (elem) {
-					return elem.disabled === true;
-				},
-
-				"checked": function (elem) {
-					// In CSS3, :checked should return both checked and selected elements
-					// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
-					var nodeName = elem.nodeName.toLowerCase();
-					return (nodeName === "input" && !! elem.checked) || (nodeName === "option" && !! elem.selected);
-				},
-
-				"selected": function (elem) {
-					// Accessing this property makes selected-by-default
-					// options in Safari work properly
-					if (elem.parentNode) {
-						elem.parentNode.selectedIndex;
-					}
-
-					return elem.selected === true;
-				},
-
-				// Contents
-				"empty": function (elem) {
-					// http://www.w3.org/TR/selectors/#empty-pseudo
-					// :empty is only affected by element nodes and content nodes(including text(3), cdata(4)),
-					//   not comment, processing instructions, or others
-					// Thanks to Diego Perini for the nodeName shortcut
-					//   Greater than "@" means alpha characters (specifically not starting with "#" or "?")
-					for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
-						if (elem.nodeName > "@" || elem.nodeType === 3 || elem.nodeType === 4) {
-							return false;
-						}
-					}
-					return true;
-				},
-
-				"parent": function (elem) {
-					return !Expr.pseudos["empty"](elem);
-				},
-
-				// Element/input types
-				"header": function (elem) {
-					return rheader.test(elem.nodeName);
-				},
-
-				"input": function (elem) {
-					return rinputs.test(elem.nodeName);
-				},
-
-				"button": function (elem) {
-					var name = elem.nodeName.toLowerCase();
-					return name === "input" && elem.type === "button" || name === "button";
-				},
-
-				"text": function (elem) {
-					var attr;
-					// IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
-					// use getAttribute instead to test this case
-					return elem.nodeName.toLowerCase() === "input" &&
-						elem.type === "text" &&
-						((attr = elem.getAttribute("type")) == null || attr.toLowerCase() === elem.type);
-				},
-
-				// Position-in-collection
-				"first": createPositionalPseudo(function () {
-					return [0];
-				}),
-
-				"last": createPositionalPseudo(function (matchIndexes, length) {
-					return [length - 1];
-				}),
-
-				"eq": createPositionalPseudo(function (matchIndexes, length, argument) {
-					return [argument < 0 ? argument + length : argument];
-				}),
-
-				"even": createPositionalPseudo(function (matchIndexes, length) {
-					var i = 0;
-					for (; i < length; i += 2) {
-						matchIndexes.push(i);
-					}
-					return matchIndexes;
-				}),
-
-				"odd": createPositionalPseudo(function (matchIndexes, length) {
-					var i = 1;
-					for (; i < length; i += 2) {
-						matchIndexes.push(i);
-					}
-					return matchIndexes;
-				}),
-
-				"lt": createPositionalPseudo(function (matchIndexes, length, argument) {
-					var i = argument < 0 ? argument + length : argument;
-					for (; --i >= 0;) {
-						matchIndexes.push(i);
-					}
-					return matchIndexes;
-				}),
-
-				"gt": createPositionalPseudo(function (matchIndexes, length, argument) {
-					var i = argument < 0 ? argument + length : argument;
-					for (; ++i < length;) {
-						matchIndexes.push(i);
-					}
-					return matchIndexes;
-				})
-			}
-		};
-
-		Expr.pseudos["nth"] = Expr.pseudos["eq"];
-
-		// Add button/input type pseudos
-		for (i in {
-			radio: true,
-			checkbox: true,
-			file: true,
-			password: true,
-			image: true
-		}) {
-			Expr.pseudos[i] = createInputPseudo(i);
-		}
-		for (i in {
-			submit: true,
-			reset: true
-		}) {
-			Expr.pseudos[i] = createButtonPseudo(i);
-		}
-
-		// Easy API for creating new setFilters
-
-		function setFilters() {}
-		setFilters.prototype = Expr.filters = Expr.pseudos;
-		Expr.setFilters = new setFilters();
-
-		function tokenize(selector, parseOnly) {
-			var matched, match, tokens, type,
-				soFar, groups, preFilters,
-				cached = tokenCache[selector + " "];
-
-			if (cached) {
-				return parseOnly ? 0 : cached.slice(0);
-			}
-
-			soFar = selector;
-			groups = [];
-			preFilters = Expr.preFilter;
-
-			while (soFar) {
-
-				// Comma and first run
-				if (!matched || (match = rcomma.exec(soFar))) {
-					if (match) {
-						// Don't consume trailing commas as valid
-						soFar = soFar.slice(match[0].length) || soFar;
-					}
-					groups.push(tokens = []);
-				}
-
-				matched = false;
-
-				// Combinators
-				if ((match = rcombinators.exec(soFar))) {
-					matched = match.shift();
-					tokens.push({
-						value: matched,
-						// Cast descendant combinators to space
-						type: match[0].replace(rtrim, " ")
-					});
-					soFar = soFar.slice(matched.length);
-				}
-
-				// Filters
-				for (type in Expr.filter) {
-					if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] ||
-						(match = preFilters[type](match)))) {
-						matched = match.shift();
-						tokens.push({
-							value: matched,
-							type: type,
-							matches: match
-						});
-						soFar = soFar.slice(matched.length);
-					}
-				}
-
-				if (!matched) {
-					break;
-				}
-			}
-
-			// Return the length of the invalid excess
-			// if we're just parsing
-			// Otherwise, throw an error or return tokens
-			return parseOnly ?
-				soFar.length :
-				soFar ?
-				Sizzle.error(selector) :
-			// Cache the tokens
-			tokenCache(selector, groups).slice(0);
-		}
-
-		function toSelector(tokens) {
-			var i = 0,
-				len = tokens.length,
-				selector = "";
-			for (; i < len; i++) {
-				selector += tokens[i].value;
-			}
-			return selector;
-		}
-
-		function addCombinator(matcher, combinator, base) {
-			var dir = combinator.dir,
-				checkNonElements = base && dir === "parentNode",
-				doneName = done++;
-
-			return combinator.first ?
-			// Check against closest ancestor/preceding element
-
-			function (elem, context, xml) {
-				while ((elem = elem[dir])) {
-					if (elem.nodeType === 1 || checkNonElements) {
-						return matcher(elem, context, xml);
-					}
-				}
-			} :
-
-			// Check against all ancestor/preceding elements
-
-			function (elem, context, xml) {
-				var data, cache, outerCache,
-					dirkey = dirruns + " " + doneName;
-
-				// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
-				if (xml) {
-					while ((elem = elem[dir])) {
-						if (elem.nodeType === 1 || checkNonElements) {
-							if (matcher(elem, context, xml)) {
-								return true;
-							}
-						}
-					}
-				} else {
-					while ((elem = elem[dir])) {
-						if (elem.nodeType === 1 || checkNonElements) {
-							outerCache = elem[expando] || (elem[expando] = {});
-							if ((cache = outerCache[dir]) && cache[0] === dirkey) {
-								if ((data = cache[1]) === true || data === cachedruns) {
-									return data === true;
-								}
-							} else {
-								cache = outerCache[dir] = [dirkey];
-								cache[1] = matcher(elem, context, xml) || cachedruns;
-								if (cache[1] === true) {
-									return true;
-								}
-							}
-						}
-					}
-				}
-			};
-		}
-
-		function elementMatcher(matchers) {
-			return matchers.length > 1 ?
-				function (elem, context, xml) {
-					var i = matchers.length;
-					while (i--) {
-						if (!matchers[i](elem, context, xml)) {
-							return false;
-						}
-					}
-					return true;
-			} :
-				matchers[0];
-		}
-
-		function condense(unmatched, map, filter, context, xml) {
-			var elem,
-				newUnmatched = [],
-				i = 0,
-				len = unmatched.length,
-				mapped = map != null;
-
-			for (; i < len; i++) {
-				if ((elem = unmatched[i])) {
-					if (!filter || filter(elem, context, xml)) {
-						newUnmatched.push(elem);
-						if (mapped) {
-							map.push(i);
-						}
-					}
-				}
-			}
-
-			return newUnmatched;
-		}
-
-		function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {
-			if (postFilter && !postFilter[expando]) {
-				postFilter = setMatcher(postFilter);
-			}
-			if (postFinder && !postFinder[expando]) {
-				postFinder = setMatcher(postFinder, postSelector);
-			}
-			return markFunction(function (seed, results, context, xml) {
-				var temp, i, elem,
-					preMap = [],
-					postMap = [],
-					preexisting = results.length,
-
-					// Get initial elements from seed or context
-					elems = seed || multipleContexts(selector || "*", context.nodeType ? [context] : context, []),
-
-					// Prefilter to get matcher input, preserving a map for seed-results synchronization
-					matcherIn = preFilter && (seed || !selector) ?
-						condense(elems, preMap, preFilter, context, xml) :
-						elems,
-
-					matcherOut = matcher ?
-					// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
-					postFinder || (seed ? preFilter : preexisting || postFilter) ?
-
-					// ...intermediate processing is necessary
-					[] :
-
-					// ...otherwise use results directly
-					results :
-						matcherIn;
-
-				// Find primary matches
-				if (matcher) {
-					matcher(matcherIn, matcherOut, context, xml);
-				}
-
-				// Apply postFilter
-				if (postFilter) {
-					temp = condense(matcherOut, postMap);
-					postFilter(temp, [], context, xml);
-
-					// Un-match failing elements by moving them back to matcherIn
-					i = temp.length;
-					while (i--) {
-						if ((elem = temp[i])) {
-							matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem);
-						}
-					}
-				}
-
-				if (seed) {
-					if (postFinder || preFilter) {
-						if (postFinder) {
-							// Get the final matcherOut by condensing this intermediate into postFinder contexts
-							temp = [];
-							i = matcherOut.length;
-							while (i--) {
-								if ((elem = matcherOut[i])) {
-									// Restore matcherIn since elem is not yet a final match
-									temp.push((matcherIn[i] = elem));
-								}
-							}
-							postFinder(null, (matcherOut = []), temp, xml);
-						}
-
-						// Move matched elements from seed to results to keep them synchronized
-						i = matcherOut.length;
-						while (i--) {
-							if ((elem = matcherOut[i]) &&
-								(temp = postFinder ? indexOf.call(seed, elem) : preMap[i]) > -1) {
-
-								seed[temp] = !(results[temp] = elem);
-							}
-						}
-					}
-
-					// Add elements to results, through postFinder if defined
-				} else {
-					matcherOut = condense(
-						matcherOut === results ?
-						matcherOut.splice(preexisting, matcherOut.length) :
-						matcherOut
-					);
-					if (postFinder) {
-						postFinder(null, results, matcherOut, xml);
-					} else {
-						push.apply(results, matcherOut);
-					}
-				}
-			});
-		}
-
-		function matcherFromTokens(tokens) {
-			var checkContext, matcher, j,
-				len = tokens.length,
-				leadingRelative = Expr.relative[tokens[0].type],
-				implicitRelative = leadingRelative || Expr.relative[" "],
-				i = leadingRelative ? 1 : 0,
-
-				// The foundational matcher ensures that elements are reachable from top-level context(s)
-				matchContext = addCombinator(function (elem) {
-					return elem === checkContext;
-				}, implicitRelative, true),
-				matchAnyContext = addCombinator(function (elem) {
-					return indexOf.call(checkContext, elem) > -1;
-				}, implicitRelative, true),
-				matchers = [
-					function (elem, context, xml) {
-						return (!leadingRelative && (xml || context !== outermostContext)) || (
-							(checkContext = context).nodeType ?
-							matchContext(elem, context, xml) :
-							matchAnyContext(elem, context, xml));
-					}
-				];
-
-			for (; i < len; i++) {
-				if ((matcher = Expr.relative[tokens[i].type])) {
-					matchers = [addCombinator(elementMatcher(matchers), matcher)];
-				} else {
-					matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches);
-
-					// Return special upon seeing a positional matcher
-					if (matcher[expando]) {
-						// Find the next relative operator (if any) for proper handling
-						j = ++i;
-						for (; j < len; j++) {
-							if (Expr.relative[tokens[j].type]) {
-								break;
-							}
-						}
-						return setMatcher(
-							i > 1 && elementMatcher(matchers),
-							i > 1 && toSelector(
-								// If the preceding token was a descendant combinator, insert an implicit any-element `*`
-								tokens.slice(0, i - 1).concat({
-									value: tokens[i - 2].type === " " ? "*" : ""
-								})
-							).replace(rtrim, "$1"),
-							matcher,
-							i < j && matcherFromTokens(tokens.slice(i, j)),
-							j < len && matcherFromTokens((tokens = tokens.slice(j))),
-							j < len && toSelector(tokens)
-						);
-					}
-					matchers.push(matcher);
-				}
-			}
-
-			return elementMatcher(matchers);
-		}
-
-		function matcherFromGroupMatchers(elementMatchers, setMatchers) {
-			// A counter to specify which element is currently being matched
-			var matcherCachedRuns = 0,
-				bySet = setMatchers.length > 0,
-				byElement = elementMatchers.length > 0,
-				superMatcher = function (seed, context, xml, results, expandContext) {
-					var elem, j, matcher,
-						setMatched = [],
-						matchedCount = 0,
-						i = "0",
-						unmatched = seed && [],
-						outermost = expandContext != null,
-						contextBackup = outermostContext,
-						// We must always have either seed elements or context
-						elems = seed || byElement && Expr.find["TAG"]("*", expandContext && context.parentNode || context),
-						// Use integer dirruns iff this is the outermost matcher
-						dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1);
-
-					if (outermost) {
-						outermostContext = context !== document && context;
-						cachedruns = matcherCachedRuns;
-					}
-
-					// Add elements passing elementMatchers directly to results
-					// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
-					for (;
-						(elem = elems[i]) != null; i++) {
-						if (byElement && elem) {
-							j = 0;
-							while ((matcher = elementMatchers[j++])) {
-								if (matcher(elem, context, xml)) {
-									results.push(elem);
-									break;
-								}
-							}
-							if (outermost) {
-								dirruns = dirrunsUnique;
-								cachedruns = ++matcherCachedRuns;
-							}
-						}
-
-						// Track unmatched elements for set filters
-						if (bySet) {
-							// They will have gone through all possible matchers
-							if ((elem = !matcher && elem)) {
-								matchedCount--;
-							}
-
-							// Lengthen the array for every element, matched or not
-							if (seed) {
-								unmatched.push(elem);
-							}
-						}
-					}
-
-					// Apply set filters to unmatched elements
-					matchedCount += i;
-					if (bySet && i !== matchedCount) {
-						j = 0;
-						while ((matcher = setMatchers[j++])) {
-							matcher(unmatched, setMatched, context, xml);
-						}
-
-						if (seed) {
-							// Reintegrate element matches to eliminate the need for sorting
-							if (matchedCount > 0) {
-								while (i--) {
-									if (!(unmatched[i] || setMatched[i])) {
-										setMatched[i] = pop.call(results);
-									}
-								}
-							}
-
-							// Discard index placeholder values to get only actual matches
-							setMatched = condense(setMatched);
-						}
-
-						// Add matches to results
-						push.apply(results, setMatched);
-
-						// Seedless set matches succeeding multiple successful matchers stipulate sorting
-						if (outermost && !seed && setMatched.length > 0 &&
-							(matchedCount + setMatchers.length) > 1) {
-
-							Sizzle.uniqueSort(results);
-						}
-					}
-
-					// Override manipulation of globals by nested matchers
-					if (outermost) {
-						dirruns = dirrunsUnique;
-						outermostContext = contextBackup;
-					}
-
-					return unmatched;
-				};
-
-			return bySet ?
-				markFunction(superMatcher) :
-				superMatcher;
-		}
-
-		compile = Sizzle.compile = function (selector, group /* Internal Use Only */ ) {
-			var i,
-				setMatchers = [],
-				elementMatchers = [],
-				cached = compilerCache[selector + " "];
-
-			if (!cached) {
-				// Generate a function of recursive functions that can be used to check each element
-				if (!group) {
-					group = tokenize(selector);
-				}
-				i = group.length;
-				while (i--) {
-					cached = matcherFromTokens(group[i]);
-					if (cached[expando]) {
-						setMatchers.push(cached);
-					} else {
-						elementMatchers.push(cached);
-					}
-				}
-
-				// Cache the compiled function
-				cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers));
-			}
-			return cached;
-		};
-
-		function multipleContexts(selector, contexts, results) {
-			var i = 0,
-				len = contexts.length;
-			for (; i < len; i++) {
-				Sizzle(selector, contexts[i], results);
-			}
-			return results;
-		}
-
-		function select(selector, context, results, seed) {
-			var i, tokens, token, type, find,
-				match = tokenize(selector);
-
-			if (!seed) {
-				// Try to minimize operations if there is only one group
-				if (match.length === 1) {
-
-					// Take a shortcut and set the context if the root selector is an ID
-					tokens = match[0] = match[0].slice(0);
-					if (tokens.length > 2 && (token = tokens[0]).type === "ID" &&
-						support.getById && context.nodeType === 9 && documentIsHTML &&
-						Expr.relative[tokens[1].type]) {
-
-						context = (Expr.find["ID"](token.matches[0].replace(runescape, funescape), context) || [])[0];
-						if (!context) {
-							return results;
-						}
-						selector = selector.slice(tokens.shift().value.length);
-					}
-
-					// Fetch a seed set for right-to-left matching
-					i = matchExpr["needsContext"].test(selector) ? 0 : tokens.length;
-					while (i--) {
-						token = tokens[i];
-
-						// Abort if we hit a combinator
-						if (Expr.relative[(type = token.type)]) {
-							break;
-						}
-						if ((find = Expr.find[type])) {
-							// Search, expanding context for leading sibling combinators
-							if ((seed = find(
-								token.matches[0].replace(runescape, funescape),
-								rsibling.test(tokens[0].type) && context.parentNode || context
-							))) {
-
-								// If seed is empty or no tokens remain, we can return early
-								tokens.splice(i, 1);
-								selector = seed.length && toSelector(tokens);
-								if (!selector) {
-									push.apply(results, seed);
-									return results;
-								}
-
-								break;
-							}
-						}
-					}
-				}
-			}
-
-			// Compile and execute a filtering function
-			// Provide `match` to avoid retokenization if we modified the selector above
-			compile(selector, match)(
-				seed,
-				context, !documentIsHTML,
-				results,
-				rsibling.test(selector)
-			);
-			return results;
-		}
-
-		// One-time assignments
-
-		// Sort stability
-		support.sortStable = expando.split("").sort(sortOrder).join("") === expando;
-
-		// Support: Chrome<14
-		// Always assume duplicates if they aren't passed to the comparison function
-		support.detectDuplicates = hasDuplicate;
-
-		// Initialize against the default document
-		setDocument();
-
-		// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
-		// Detached nodes confoundingly follow *each other*
-		support.sortDetached = assert(function (div1) {
-			// Should return 1, but returns 4 (following)
-			return div1.compareDocumentPosition(document.createElement("div")) & 1;
-		});
-
-		// Support: IE<8
-		// Prevent attribute/property "interpolation"
-		// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
-		if (!assert(function (div) {
-			div.innerHTML = "<a href='#'></a>";
-			return div.firstChild.getAttribute("href") === "#";
-		})) {
-			addHandle("type|href|height|width", function (elem, name, isXML) {
-				if (!isXML) {
-					return elem.getAttribute(name, name.toLowerCase() === "type" ? 1 : 2);
-				}
-			});
-		}
-
-		// Support: IE<9
-		// Use defaultValue in place of getAttribute("value")
-		if (!support.attributes || !assert(function (div) {
-			div.innerHTML = "<input/>";
-			div.firstChild.setAttribute("value", "");
-			return div.firstChild.getAttribute("value") === "";
-		})) {
-			addHandle("value", function (elem, name, isXML) {
-				if (!isXML && elem.nodeName.toLowerCase() === "input") {
-					return elem.defaultValue;
-				}
-			});
-		}
-
-		// Support: IE<9
-		// Use getAttributeNode to fetch booleans when getAttribute lies
-		if (!assert(function (div) {
-			return div.getAttribute("disabled") == null;
-		})) {
-			addHandle(booleans, function (elem, name, isXML) {
-				var val;
-				if (!isXML) {
-					return (val = elem.getAttributeNode(name)) && val.specified ?
-						val.value :
-						elem[name] === true ? name.toLowerCase() : null;
-				}
-			});
-		}
-
-		jQuery.find = Sizzle;
-		jQuery.expr = Sizzle.selectors;
-		jQuery.expr[":"] = jQuery.expr.pseudos;
-		jQuery.unique = Sizzle.uniqueSort;
-		jQuery.text = Sizzle.getText;
-		jQuery.isXMLDoc = Sizzle.isXML;
-		jQuery.contains = Sizzle.contains;
-
-
-	})(window);
-	// String to Object options format cache
-	var optionsCache = {};
-
-	// Convert String-formatted options into Object-formatted ones and store in cache
-
-	function createOptions(options) {
-		var object = optionsCache[options] = {};
-		jQuery.each(options.match(core_rnotwhite) || [], function (_, flag) {
-			object[flag] = true;
-		});
-		return object;
-	}
-
-	/*
-	 * Create a callback list using the following parameters:
-	 *
-	 *	options: an optional list of space-separated options that will change how
-	 *			the callback list behaves or a more traditional option object
-	 *
-	 * By default a callback list will act like an event callback list and can be
-	 * "fired" multiple times.
-	 *
-	 * Possible options:
-	 *
-	 *	once:			will ensure the callback list can only be fired once (like a Deferred)
-	 *
-	 *	memory:			will keep track of previous values and will call any callback added
-	 *					after the list has been fired right away with the latest "memorized"
-	 *					values (like a Deferred)
-	 *
-	 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
-	 *
-	 *	stopOnFalse:	interrupt callings when a callback returns false
-	 *
-	 */
-	jQuery.Callbacks = function (options) {
-
-		// Convert options from String-formatted to Object-formatted if needed
-		// (we check in cache first)
-		options = typeof options === "string" ?
-			(optionsCache[options] || createOptions(options)) :
-			jQuery.extend({}, options);
-
-		var // Flag to know if list is currently firing
-		firing,
-			// Last fire value (for non-forgettable lists)
-			memory,
-			// Flag to know if list was already fired
-			fired,
-			// End of the loop when firing
-			firingLength,
-			// Index of currently firing callback (modified by remove if needed)
-			firingIndex,
-			// First callback to fire (used internally by add and fireWith)
-			firingStart,
-			// Actual callback list
-			list = [],
-			// Stack of fire calls for repeatable lists
-			stack = !options.once && [],
-			// Fire callbacks
-			fire = function (data) {
-				memory = options.memory && data;
-				fired = true;
-				firingIndex = firingStart || 0;
-				firingStart = 0;
-				firingLength = list.length;
-				firing = true;
-				for (; list && firingIndex < firingLength; firingIndex++) {
-					if (list[firingIndex].apply(data[0], data[1]) === false && options.stopOnFalse) {
-						memory = false; // To prevent further calls using add
-						break;
-					}
-				}
-				firing = false;
-				if (list) {
-					if (stack) {
-						if (stack.length) {
-							fire(stack.shift());
-						}
-					} else if (memory) {
-						list = [];
-					} else {
-						self.disable();
-					}
-				}
-			},
-			// Actual Callbacks object
-			self = {
-				// Add a callback or a collection of callbacks to the list
-				add: function () {
-					if (list) {
-						// First, we save the current length
-						var start = list.length;
-						(function add(args) {
-							jQuery.each(args, function (_, arg) {
-								var type = jQuery.type(arg);
-								if (type === "function") {
-									if (!options.unique || !self.has(arg)) {
-										list.push(arg);
-									}
-								} else if (arg && arg.length && type !== "string") {
-									// Inspect recursively
-									add(arg);
-								}
-							});
-						})(arguments);
-						// Do we need to add the callbacks to the
-						// current firing batch?
-						if (firing) {
-							firingLength = list.length;
-							// With memory, if we're not firing then
-							// we should call right away
-						} else if (memory) {
-							firingStart = start;
-							fire(memory);
-						}
-					}
-					return this;
-				},
-				// Remove a callback from the list
-				remove: function () {
-					if (list) {
-						jQuery.each(arguments, function (_, arg) {
-							var index;
-							while ((index = jQuery.inArray(arg, list, index)) > -1) {
-								list.splice(index, 1);
-								// Handle firing indexes
-								if (firing) {
-									if (index <= firingLength) {
-										firingLength--;
-									}
-									if (index <= firingIndex) {
-										firingIndex--;
-									}
-								}
-							}
-						});
-					}
-					return this;
-				},
-				// Check if a given callback is in the list.
-				// If no argument is given, return whether or not list has callbacks attached.
-				has: function (fn) {
-					return fn ? jQuery.inArray(fn, list) > -1 : !! (list && list.length);
-				},
-				// Remove all callbacks from the list
-				empty: function () {
-					list = [];
-					firingLength = 0;
-					return this;
-				},
-				// Have the list do nothing anymore
-				disable: function () {
-					list = stack = memory = undefined;
-					return this;
-				},
-				// Is it disabled?
-				disabled: function () {
-					return !list;
-				},
-				// Lock the list in its current state
-				lock: function () {
-					stack = undefined;
-					if (!memory) {
-						self.disable();
-					}
-					return this;
-				},
-				// Is it locked?
-				locked: function () {
-					return !stack;
-				},
-				// Call all callbacks with the given context and arguments
-				fireWith: function (context, args) {
-					if (list && (!fired || stack)) {
-						args = args || [];
-						args = [context, args.slice ? args.slice() : args];
-						if (firing) {
-							stack.push(args);
-						} else {
-							fire(args);
-						}
-					}
-					return this;
-				},
-				// Call all the callbacks with the given arguments
-				fire: function () {
-					self.fireWith(this, arguments);
-					return this;
-				},
-				// To know if the callbacks have already been called at least once
-				fired: function () {
-					return !!fired;
-				}
-			};
-
-		return self;
-	};
-	jQuery.extend({
-
-		Deferred: function (func) {
-			var tuples = [
-				// action, add listener, listener list, final state
-				["resolve", "done", jQuery.Callbacks("once memory"), "resolved"],
-				["reject", "fail", jQuery.Callbacks("once memory"), "rejected"],
-				["notify", "progress", jQuery.Callbacks("memory")]
-			],
-				state = "pending",
-				promise = {
-					state: function () {
-						return state;
-					},
-					always: function () {
-						deferred.done(arguments).fail(arguments);
-						return this;
-					},
-					then: function ( /* fnDone, fnFail, fnProgress */ ) {
-						var fns = arguments;
-						return jQuery.Deferred(function (newDefer) {
-							jQuery.each(tuples, function (i, tuple) {
-								var action = tuple[0],
-									fn = jQuery.isFunction(fns[i]) && fns[i];
-								// deferred[ done | fail | progress ] for forwarding actions to newDefer
-								deferred[tuple[1]](function () {
-									var returned = fn && fn.apply(this, arguments);
-									if (returned && jQuery.isFunction(returned.promise)) {
-										returned.promise()
-											.done(newDefer.resolve)
-											.fail(newDefer.reject)
-											.progress(newDefer.notify);
-									} else {
-										newDefer[action + "With"](this === promise ? newDefer.promise() : this, fn ? [returned] : arguments);
-									}
-								});
-							});
-							fns = null;
-						}).promise();
-					},
-					// Get a promise for this deferred
-					// If obj is provided, the promise aspect is added to the object
-					promise: function (obj) {
-						return obj != null ? jQuery.extend(obj, promise) : promise;
-					}
-				},
-				deferred = {};
-
-			// Keep pipe for back-compat
-			promise.pipe = promise.then;
-
-			// Add list-specific methods
-			jQuery.each(tuples, function (i, tuple) {
-				var list = tuple[2],
-					stateString = tuple[3];
-
-				// promise[ done | fail | progress ] = list.add
-				promise[tuple[1]] = list.add;
-
-				// Handle state
-				if (stateString) {
-					list.add(function () {
-						// state = [ resolved | rejected ]
-						state = stateString;
-
-						// [ reject_list | resolve_list ].disable; progress_list.lock
-					}, tuples[i ^ 1][2].disable, tuples[2][2].lock);
-				}
-
-				// deferred[ resolve | reject | notify ]
-				deferred[tuple[0]] = function () {
-					deferred[tuple[0] + "With"](this === deferred ? promise : this, arguments);
-					return this;
-				};
-				deferred[tuple[0] + "With"] = list.fireWith;
-			});
-
-			// Make the deferred a promise
-			promise.promise(deferred);
-
-			// Call given func if any
-			if (func) {
-				func.call(deferred, deferred);
-			}
-
-			// All done!
-			return deferred;
-		},
-
-		// Deferred helper
-		when: function (subordinate /* , ..., subordinateN */ ) {
-			var i = 0,
-				resolveValues = core_slice.call(arguments),
-				length = resolveValues.length,
-
-				// the count of uncompleted subordinates
-				remaining = length !== 1 || (subordinate && jQuery.isFunction(subordinate.promise)) ? length : 0,
-
-				// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
-				deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
-
-				// Update function for both resolve and progress values
-				updateFunc = function (i, contexts, values) {
-					return function (value) {
-						contexts[i] = this;
-						values[i] = arguments.length > 1 ? core_slice.call(arguments) : value;
-						if (values === progressValues) {
-							deferred.notifyWith(contexts, values);
-						} else if (!(--remaining)) {
-							deferred.resolveWith(contexts, values);
-						}
-					};
-				},
-
-				progressValues, progressContexts, resolveContexts;
-
-			// add listeners to Deferred subordinates; treat others as resolved
-			if (length > 1) {
-				progressValues = new Array(length);
-				progressContexts = new Array(length);
-				resolveContexts = new Array(length);
-				for (; i < length; i++) {
-					if (resolveValues[i] && jQuery.isFunction(resolveValues[i].promise)) {
-						resolveValues[i].promise()
-							.done(updateFunc(i, resolveContexts, resolveValues))
-							.fail(deferred.reject)
-							.progress(updateFunc(i, progressContexts, progressValues));
-					} else {
-						--remaining;
-					}
-				}
-			}
-
-			// if we're not waiting on anything, resolve the master
-			if (!remaining) {
-				deferred.resolveWith(resolveContexts, resolveValues);
-			}
-
-			return deferred.promise();
-		}
-	});
-	jQuery.support = (function (support) {
-
-		var all, a, input, select, fragment, opt, eventName, isSupported, i,
-			div = document.createElement("div");
-
-		// Setup
-		div.setAttribute("className", "t");
-		div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
-
-		// Finish early in limited (non-browser) environments
-		all = div.getElementsByTagName("*") || [];
-		a = div.getElementsByTagName("a")[0];
-		if (!a || !a.style || !all.length) {
-			return support;
-		}
-
-		// First batch of tests
-		select = document.createElement("select");
-		opt = select.appendChild(document.createElement("option"));
-		input = div.getElementsByTagName("input")[0];
-
-		a.style.cssText = "top:1px;float:left;opacity:.5";
-
-		// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
-		support.getSetAttribute = div.className !== "t";
-
-		// IE strips leading whitespace when .innerHTML is used
-		support.leadingWhitespace = div.firstChild.nodeType === 3;
-
-		// Make sure that tbody elements aren't automatically inserted
-		// IE will insert them into empty tables
-		support.tbody = !div.getElementsByTagName("tbody").length;
-
-		// Make sure that link elements get serialized correctly by innerHTML
-		// This requires a wrapper element in IE
-		support.htmlSerialize = !! div.getElementsByTagName("link").length;
-
-		// Get the style information from getAttribute
-		// (IE uses .cssText instead)
-		support.style = /top/.test(a.getAttribute("style"));
-
-		// Make sure that URLs aren't manipulated
-		// (IE normalizes it by default)
-		support.hrefNormalized = a.getAttribute("href") === "/a";
-
-		// Make sure that element opacity exists
-		// (IE uses filter instead)
-		// Use a regex to work around a WebKit issue. See #5145
-		support.opacity = /^0.5/.test(a.style.opacity);
-
-		// Verify style float existence
-		// (IE uses styleFloat instead of cssFloat)
-		support.cssFloat = !! a.style.cssFloat;
-
-		// Check the default checkbox/radio value ("" on WebKit; "on" elsewhere)
-		support.checkOn = !! input.value;
-
-		// Make sure that a selected-by-default option has a working selected property.
-		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
-		support.optSelected = opt.selected;
-
-		// Tests for enctype support on a form (#6743)
-		support.enctype = !! document.createElement("form").enctype;
-
-		// Makes sure cloning an html5 element does not cause problems
-		// Where outerHTML is undefined, this still works
-		support.html5Clone = document.createElement("nav").cloneNode(true).outerHTML !== "<:nav></:nav>";
-
-		// Will be defined later
-		support.inlineBlockNeedsLayout = false;
-		support.shrinkWrapBlocks = false;
-		support.pixelPosition = false;
-		support.deleteExpando = true;
-		support.noCloneEvent = true;
-		support.reliableMarginRight = true;
-		support.boxSizingReliable = true;
-
-		// Make sure checked status is properly cloned
-		input.checked = true;
-		support.noCloneChecked = input.cloneNode(true).checked;
-
-		// Make sure that the options inside disabled selects aren't marked as disabled
-		// (WebKit marks them as disabled)
-		select.disabled = true;
-		support.optDisabled = !opt.disabled;
-
-		// Support: IE<9
-		try {
-			delete div.test;
-		} catch (e) {
-			support.deleteExpando = false;
-		}
-
-		// Check if we can trust getAttribute("value")
-		input = document.createElement("input");
-		input.setAttribute("value", "");
-		support.input = input.getAttribute("value") === "";
-
-		// Check if an input maintains its value after becoming a radio
-		input.value = "t";
-		input.setAttribute("type", "radio");
-		support.radioValue = input.value === "t";
-
-		// #11217 - WebKit loses check when the name is after the checked attribute
-		input.setAttribute("checked", "t");
-		input.setAttribute("name", "t");
-
-		fragment = document.createDocumentFragment();
-		fragment.appendChild(input);
-
-		// Check if a disconnected checkbox will retain its checked
-		// value of true after appended to the DOM (IE6/7)
-		support.appendChecked = input.checked;
-
-		// WebKit doesn't clone checked state correctly in fragments
-		support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked;
-
-		// Support: IE<9
-		// Opera does not clone events (and typeof div.attachEvent === undefined).
-		// IE9-10 clones events bound via attachEvent, but they don't trigger with .click()
-		if (div.attachEvent) {
-			div.attachEvent("onclick", function () {
-				support.noCloneEvent = false;
-			});
-
-			div.cloneNode(true).click();
-		}
-
-		// Support: IE<9 (lack submit/change bubble), Firefox 17+ (lack focusin event)
-		// Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP)
-		for (i in {
-			submit: true,
-			change: true,
-			focusin: true
-		}) {
-			div.setAttribute(eventName = "on" + i, "t");
-
-			support[i + "Bubbles"] = eventName in window || div.attributes[eventName].expando === false;
-		}
-
-		div.style.backgroundClip = "content-box";
-		div.cloneNode(true).style.backgroundClip = "";
-		support.clearCloneStyle = div.style.backgroundClip === "content-box";
-
-		// Support: IE<9
-		// Iteration over object's inherited properties before its own.
-		for (i in jQuery(support)) {
-			break;
-		}
-		support.ownLast = i !== "0";
-
-		// Run tests that need a body at doc ready
-		jQuery(function () {
-			var container, marginDiv, tds,
-				divReset = "padding:0;margin:0;border:0;display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;",
-				body = document.getElementsByTagName("body")[0];
-
-			if (!body) {
-				// Return for frameset docs that don't have a body
-				return;
-			}
-
-			container = document.createElement("div");
-			container.style.cssText = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px";
-
-			body.appendChild(container).appendChild(div);
-
-			// Support: IE8
-			// Check if table cells still have offsetWidth/Height when they are set
-			// to display:none and there are still other visible table cells in a
-			// table row; if so, offsetWidth/Height are not reliable for use when
-			// determining if an element has been hidden directly using
-			// display:none (it is still safe to use offsets if a parent element is
-			// hidden; don safety goggles and see bug #4512 for more information).
-			div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
-			tds = div.getElementsByTagName("td");
-			tds[0].style.cssText = "padding:0;margin:0;border:0;display:none";
-			isSupported = (tds[0].offsetHeight === 0);
-
-			tds[0].style.display = "";
-			tds[1].style.display = "none";
-
-			// Support: IE8
-			// Check if empty table cells still have offsetWidth/Height
-			support.reliableHiddenOffsets = isSupported && (tds[0].offsetHeight === 0);
-
-			// Check box-sizing and margin behavior.
-			div.innerHTML = "";
-			div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;";
-
-			// Workaround failing boxSizing test due to offsetWidth returning wrong value
-			// with some non-1 values of body zoom, ticket #13543
-			jQuery.swap(body, body.style.zoom != null ? {
-				zoom: 1
-			} : {}, function () {
-				support.boxSizing = div.offsetWidth === 4;
-			});
-
-			// Use window.getComputedStyle because jsdom on node.js will break without it.
-			if (window.getComputedStyle) {
-				support.pixelPosition = (window.getComputedStyle(div, null) || {}).top !== "1%";
-				support.boxSizingReliable = (window.getComputedStyle(div, null) || {
-					width: "4px"
-				}).width === "4px";
-
-				// Check if div with explicit width and no margin-right incorrectly
-				// gets computed margin-right based on width of container. (#3333)
-				// Fails in WebKit before Feb 2011 nightlies
-				// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
-				marginDiv = div.appendChild(document.createElement("div"));
-				marginDiv.style.cssText = div.style.cssText = divReset;
-				marginDiv.style.marginRight = marginDiv.style.width = "0";
-				div.style.width = "1px";
-
-				support.reliableMarginRight = !parseFloat((window.getComputedStyle(marginDiv, null) || {}).marginRight);
-			}
-
-			if (typeof div.style.zoom !== core_strundefined) {
-				// Support: IE<8
-				// Check if natively block-level elements act like inline-block
-				// elements when setting their display to 'inline' and giving
-				// them layout
-				div.innerHTML = "";
-				div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1";
-				support.inlineBlockNeedsLayout = (div.offsetWidth === 3);
-
-				// Support: IE6
-				// Check if elements with layout shrink-wrap their children
-				div.style.display = "block";
-				div.innerHTML = "<div></div>";
-				div.firstChild.style.width = "5px";
-				support.shrinkWrapBlocks = (div.offsetWidth !== 3);
-
-				if (support.inlineBlockNeedsLayout) {
-					// Prevent IE 6 from affecting layout for positioned elements #11048
-					// Prevent IE from shrinking the body in IE 7 mode #12869
-					// Support: IE<8
-					body.style.zoom = 1;
-				}
-			}
-
-			body.removeChild(container);
-
-			// Null elements to avoid leaks in IE
-			container = div = tds = marginDiv = null;
-		});
-
-		// Null elements to avoid leaks in IE
-		all = select = fragment = opt = a = input = null;
-
-		return support;
-	})({});
-
-	var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
-		rmultiDash = /([A-Z])/g;
-
-	function internalData(elem, name, data, pvt /* Internal Use Only */ ) {
-		if (!jQuery.acceptData(elem)) {
-			return;
-		}
-
-		var ret, thisCache,
-			internalKey = jQuery.expando,
-
-			// We have to handle DOM nodes and JS objects differently because IE6-7
-			// can't GC object references properly across the DOM-JS boundary
-			isNode = elem.nodeType,
-
-			// Only DOM nodes need the global jQuery cache; JS object data is
-			// attached directly to the object so GC can occur automatically
-			cache = isNode ? jQuery.cache : elem,
-
-			// Only defining an ID for JS objects if its cache already exists allows
-			// the code to shortcut on the same path as a DOM node with no cache
-			id = isNode ? elem[internalKey] : elem[internalKey] && internalKey;
-
-		// Avoid doing any more work than we need to when trying to get data on an
-		// object that has no data at all
-		if ((!id || !cache[id] || (!pvt && !cache[id].data)) && data === undefined && typeof name === "string") {
-			return;
-		}
-
-		if (!id) {
-			// Only DOM nodes need a new unique ID for each element since their data
-			// ends up in the global cache
-			if (isNode) {
-				id = elem[internalKey] = core_deletedIds.pop() || jQuery.guid++;
-			} else {
-				id = internalKey;
-			}
-		}
-
-		if (!cache[id]) {
-			// Avoid exposing jQuery metadata on plain JS objects when the object
-			// is serialized using JSON.stringify
-			cache[id] = isNode ? {} : {
-				toJSON: jQuery.noop
-			};
-		}
-
-		// An object can be passed to jQuery.data instead of a key/value pair; this gets
-		// shallow copied over onto the existing cache
-		if (typeof name === "object" || typeof name === "function") {
-			if (pvt) {
-				cache[id] = jQuery.extend(cache[id], name);
-			} else {
-				cache[id].data = jQuery.extend(cache[id].data, name);
-			}
-		}
-
-		thisCache = cache[id];
-
-		// jQuery data() is stored in a separate object inside the object's internal data
-		// cache in order to avoid key collisions between internal data and user-defined
-		// data.
-		if (!pvt) {
-			if (!thisCache.data) {
-				thisCache.data = {};
-			}
-
-			thisCache = thisCache.data;
-		}
-
-		if (data !== undefined) {
-			thisCache[jQuery.camelCase(name)] = data;
-		}
-
-		// Check for both converted-to-camel and non-converted data property names
-		// If a data property was specified
-		if (typeof name === "string") {
-
-			// First Try to find as-is property data
-			ret = thisCache[name];
-
-			// Test for null|undefined property data
-			if (ret == null) {
-
-				// Try to find the camelCased property
-				ret = thisCache[jQuery.camelCase(name)];
-			}
-		} else {
-			ret = thisCache;
-		}
-
-		return ret;
-	}
-
-	function internalRemoveData(elem, name, pvt) {
-		if (!jQuery.acceptData(elem)) {
-			return;
-		}
-
-		var thisCache, i,
-			isNode = elem.nodeType,
-
-			// See jQuery.data for more information
-			cache = isNode ? jQuery.cache : elem,
-			id = isNode ? elem[jQuery.expando] : jQuery.expando;
-
-		// If there is already no cache entry for this object, there is no
-		// purpose in continuing
-		if (!cache[id]) {
-			return;
-		}
-
-		if (name) {
-
-			thisCache = pvt ? cache[id] : cache[id].data;
-
-			if (thisCache) {
-
-				// Support array or space separated string names for data keys
-				if (!jQuery.isArray(name)) {
-
-					// try the string as a key before any manipulation
-					if (name in thisCache) {
-						name = [name];
-					} else {
-
-						// split the camel cased version by spaces unless a key with the spaces exists
-						name = jQuery.camelCase(name);
-						if (name in thisCache) {
-							name = [name];
-						} else {
-							name = name.split(" ");
-						}
-					}
-				} else {
-					// If "name" is an array of keys...
-					// When data is initially created, via ("key", "val") signature,
-					// keys will be converted to camelCase.
-					// Since there is no way to tell _how_ a key was added, remove
-					// both plain key and camelCase key. #12786
-					// This will only penalize the array argument path.
-					name = name.concat(jQuery.map(name, jQuery.camelCase));
-				}
-
-				i = name.length;
-				while (i--) {
-					delete thisCache[name[i]];
-				}
-
-				// If there is no data left in the cache, we want to continue
-				// and let the cache object itself get destroyed
-				if (pvt ? !isEmptyDataObject(thisCache) : !jQuery.isEmptyObject(thisCache)) {
-					return;
-				}
-			}
-		}
-
-		// See jQuery.data for more information
-		if (!pvt) {
-			delete cache[id].data;
-
-			// Don't destroy the parent cache unless the internal data object
-			// had been the only thing left in it
-			if (!isEmptyDataObject(cache[id])) {
-				return;
-			}
-		}
-
-		// Destroy the cache
-		if (isNode) {
-			jQuery.cleanData([elem], true);
-
-			// Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
-			/* jshint eqeqeq: false */
-		} else if (jQuery.support.deleteExpando || cache != cache.window) {
-			/* jshint eqeqeq: true */
-			delete cache[id];
-
-			// When all else fails, null
-		} else {
-			cache[id] = null;
-		}
-	}
-
-	jQuery.extend({
-		cache: {},
-
-		// The following elements throw uncatchable exceptions if you
-		// attempt to add expando properties to them.
-		noData: {
-			"applet": true,
-			"embed": true,
-			// Ban all objects except for Flash (which handle expandos)
-			"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"
-		},
-
-		hasData: function (elem) {
-			elem = elem.nodeType ? jQuery.cache[elem[jQuery.expando]] : elem[jQuery.expando];
-			return !!elem && !isEmptyDataObject(elem);
-		},
-
-		data: function (elem, name, data) {
-			return internalData(elem, name, data);
-		},
-
-		removeData: function (elem, name) {
-			return internalRemoveData(elem, name);
-		},
-
-		// For internal use only.
-		_data: function (elem, name, data) {
-			return internalData(elem, name, data, true);
-		},
-
-		_removeData: function (elem, name) {
-			return internalRemoveData(elem, name, true);
-		},
-
-		// A method for determining if a DOM node can handle the data expando
-		acceptData: function (elem) {
-			// Do not set data on non-element because it will not be cleared (#8335).
-			if (elem.nodeType && elem.nodeType !== 1 && elem.nodeType !== 9) {
-				return false;
-			}
-
-			var noData = elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()];
-
-			// nodes accept data unless otherwise specified; rejection can be conditional
-			return !noData || noData !== true && elem.getAttribute("classid") === noData;
-		}
-	});
-
-	jQuery.fn.extend({
-		data: function (key, value) {
-			var attrs, name,
-				data = null,
-				i = 0,
-				elem = this[0];
-
-			// Special expections of .data basically thwart jQuery.access,
-			// so implement the relevant behavior ourselves
-
-			// Gets all values
-			if (key === undefined) {
-				if (this.length) {
-					data = jQuery.data(elem);
-
-					if (elem.nodeType === 1 && !jQuery._data(elem, "parsedAttrs")) {
-						attrs = elem.attributes;
-						for (; i < attrs.length; i++) {
-							name = attrs[i].name;
-
-							if (name.indexOf("data-") === 0) {
-								name = jQuery.camelCase(name.slice(5));
-
-								dataAttr(elem, name, data[name]);
-							}
-						}
-						jQuery._data(elem, "parsedAttrs", true);
-					}
-				}
-
-				return data;
-			}
-
-			// Sets multiple values
-			if (typeof key === "object") {
-				return this.each(function () {
-					jQuery.data(this, key);
-				});
-			}
-
-			return arguments.length > 1 ?
-
-			// Sets one value
-			this.each(function () {
-				jQuery.data(this, key, value);
-			}) :
-
-			// Gets one value
-			// Try to fetch any internally stored data first
-			elem ? dataAttr(elem, key, jQuery.data(elem, key)) : null;
-		},
-
-		removeData: function (key) {
-			return this.each(function () {
-				jQuery.removeData(this, key);
-			});
-		}
-	});
-
-	function dataAttr(elem, key, data) {
-		// If nothing was found internally, try to fetch any
-		// data from the HTML5 data-* attribute
-		if (data === undefined && elem.nodeType === 1) {
-
-			var name = "data-" + key.replace(rmultiDash, "-$1").toLowerCase();
-
-			data = elem.getAttribute(name);
-
-			if (typeof data === "string") {
-				try {
-					data = data === "true" ? true :
-						data === "false" ? false :
-						data === "null" ? null :
-					// Only convert to a number if it doesn't change the string
-					+data + "" === data ? +data :
-						rbrace.test(data) ? jQuery.parseJSON(data) :
-						data;
-				} catch (e) {}
-
-				// Make sure we set the data so it isn't changed later
-				jQuery.data(elem, key, data);
-
-			} else {
-				data = undefined;
-			}
-		}
-
-		return data;
-	}
-
-	// checks a cache object for emptiness
-
-	function isEmptyDataObject(obj) {
-		var name;
-		for (name in obj) {
-
-			// if the public data object is empty, the private is still empty
-			if (name === "data" && jQuery.isEmptyObject(obj[name])) {
-				continue;
-			}
-			if (name !== "toJSON") {
-				return false;
-			}
-		}
-
-		return true;
-	}
-	jQuery.extend({
-		queue: function (elem, type, data) {
-			var queue;
-
-			if (elem) {
-				type = (type || "fx") + "queue";
-				queue = jQuery._data(elem, type);
-
-				// Speed up dequeue by getting out quickly if this is just a lookup
-				if (data) {
-					if (!queue || jQuery.isArray(data)) {
-						queue = jQuery._data(elem, type, jQuery.makeArray(data));
-					} else {
-						queue.push(data);
-					}
-				}
-				return queue || [];
-			}
-		},
-
-		dequeue: function (elem, type) {
-			type = type || "fx";
-
-			var queue = jQuery.queue(elem, type),
-				startLength = queue.length,
-				fn = queue.shift(),
-				hooks = jQuery._queueHooks(elem, type),
-				next = function () {
-					jQuery.dequeue(elem, type);
-				};
-
-			// If the fx queue is dequeued, always remove the progress sentinel
-			if (fn === "inprogress") {
-				fn = queue.shift();
-				startLength--;
-			}
-
-			if (fn) {
-
-				// Add a progress sentinel to prevent the fx queue from being
-				// automatically dequeued
-				if (type === "fx") {
-					queue.unshift("inprogress");
-				}
-
-				// clear up the last queue stop function
-				delete hooks.stop;
-				fn.call(elem, next, hooks);
-			}
-
-			if (!startLength && hooks) {
-				hooks.empty.fire();
-			}
-		},
-
-		// not intended for public consumption - generates a queueHooks object, or returns the current one
-		_queueHooks: function (elem, type) {
-			var key = type + "queueHooks";
-			return jQuery._data(elem, key) || jQuery._data(elem, key, {
-				empty: jQuery.Callbacks("once memory").add(function () {
-					jQuery._removeData(elem, type + "queue");
-					jQuery._removeData(elem, key);
-				})
-			});
-		}
-	});
-
-	jQuery.fn.extend({
-		queue: function (type, data) {
-			var setter = 2;
-
-			if (typeof type !== "string") {
-				data = type;
-				type = "fx";
-				setter--;
-			}
-
-			if (arguments.length < setter) {
-				return jQuery.queue(this[0], type);
-			}
-
-			return data === undefined ?
-				this :
-				this.each(function () {
-					var queue = jQuery.queue(this, type, data);
-
-					// ensure a hooks for this queue
-					jQuery._queueHooks(this, type);
-
-					if (type === "fx" && queue[0] !== "inprogress") {
-						jQuery.dequeue(this, type);
-					}
-				});
-		},
-		dequeue: function (type) {
-			return this.each(function () {
-				jQuery.dequeue(this, type);
-			});
-		},
-		// Based off of the plugin by Clint Helfers, with permission.
-		// http://blindsignals.com/index.php/2009/07/jquery-delay/
-		delay: function (time, type) {
-			time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
-			type = type || "fx";
-
-			return this.queue(type, function (next, hooks) {
-				var timeout = setTimeout(next, time);
-				hooks.stop = function () {
-					clearTimeout(timeout);
-				};
-			});
-		},
-		clearQueue: function (type) {
-			return this.queue(type || "fx", []);
-		},
-		// Get a promise resolved when queues of a certain type
-		// are emptied (fx is the type by default)
-		promise: function (type, obj) {
-			var tmp,
-				count = 1,
-				defer = jQuery.Deferred(),
-				elements = this,
-				i = this.length,
-				resolve = function () {
-					if (!(--count)) {
-						defer.resolveWith(elements, [elements]);
-					}
-				};
-
-			if (typeof type !== "string") {
-				obj = type;
-				type = undefined;
-			}
-			type = type || "fx";
-
-			while (i--) {
-				tmp = jQuery._data(elements[i], type + "queueHooks");
-				if (tmp && tmp.empty) {
-					count++;
-					tmp.empty.add(resolve);
-				}
-			}
-			resolve();
-			return defer.promise(obj);
-		}
-	});
-	var nodeHook, boolHook,
-		rclass = /[\t\r\n\f]/g,
-		rreturn = /\r/g,
-		rfocusable = /^(?:input|select|textarea|button|object)$/i,
-		rclickable = /^(?:a|area)$/i,
-		ruseDefault = /^(?:checked|selected)$/i,
-		getSetAttribute = jQuery.support.getSetAttribute,
-		getSetInput = jQuery.support.input;
-
-	jQuery.fn.extend({
-		attr: function (name, value) {
-			return jQuery.access(this, jQuery.attr, name, value, arguments.length > 1);
-		},
-
-		removeAttr: function (name) {
-			return this.each(function () {
-				jQuery.removeAttr(this, name);
-			});
-		},
-
-		prop: function (name, value) {
-			return jQuery.access(this, jQuery.prop, name, value, arguments.length > 1);
-		},
-
-		removeProp: function (name) {
-			name = jQuery.propFix[name] || name;
-			return this.each(function () {
-				// try/catch handles cases where IE balks (such as removing a property on window)
-				try {
-					this[name] = undefined;
-					delete this[name];
-				} catch (e) {}
-			});
-		},
-
-		addClass: function (value) {
-			var classes, elem, cur, clazz, j,
-				i = 0,
-				len = this.length,
-				proceed = typeof value === "string" && value;
-
-			if (jQuery.isFunction(value)) {
-				return this.each(function (j) {
-					jQuery(this).addClass(value.call(this, j, this.className));
-				});
-			}
-
-			if (proceed) {
-				// The disjunction here is for better compressibility (see removeClass)
-				classes = (value || "").match(core_rnotwhite) || [];
-
-				for (; i < len; i++) {
-					elem = this[i];
-					cur = elem.nodeType === 1 && (elem.className ?
-						(" " + elem.className + " ").replace(rclass, " ") :
-						" "
-					);
-
-					if (cur) {
-						j = 0;
-						while ((clazz = classes[j++])) {
-							if (cur.indexOf(" " + clazz + " ") < 0) {
-								cur += clazz + " ";
-							}
-						}
-						elem.className = jQuery.trim(cur);
-
-					}
-				}
-			}
-
-			return this;
-		},
-
-		removeClass: function (value) {
-			var classes, elem, cur, clazz, j,
-				i = 0,
-				len = this.length,
-				proceed = arguments.length === 0 || typeof value === "string" && value;
-
-			if (jQuery.isFunction(value)) {
-				return this.each(function (j) {
-					jQuery(this).removeClass(value.call(this, j, this.className));
-				});
-			}
-			if (proceed) {
-				classes = (value || "").match(core_rnotwhite) || [];
-
-				for (; i < len; i++) {
-					elem = this[i];
-					// This expression is here for better compressibility (see addClass)
-					cur = elem.nodeType === 1 && (elem.className ?
-						(" " + elem.className + " ").replace(rclass, " ") :
-						""
-					);
-
-					if (cur) {
-						j = 0;
-						while ((clazz = classes[j++])) {
-							// Remove *all* instances
-							while (cur.indexOf(" " + clazz + " ") >= 0) {
-								cur = cur.replace(" " + clazz + " ", " ");
-							}
-						}
-						elem.className = value ? jQuery.trim(cur) : "";
-					}
-				}
-			}
-
-			return this;
-		},
-
-		toggleClass: function (value, stateVal) {
-			var type = typeof value;
-
-			if (typeof stateVal === "boolean" && type === "string") {
-				return stateVal ? this.addClass(value) : this.removeClass(value);
-			}
-
-			if (jQuery.isFunction(value)) {
-				return this.each(function (i) {
-					jQuery(this).toggleClass(value.call(this, i, this.className, stateVal), stateVal);
-				});
-			}
-
-			return this.each(function () {
-				if (type === "string") {
-					// toggle individual class names
-					var className,
-						i = 0,
-						self = jQuery(this),
-						classNames = value.match(core_rnotwhite) || [];
-
-					while ((className = classNames[i++])) {
-						// check each className given, space separated list
-						if (self.hasClass(className)) {
-							self.removeClass(className);
-						} else {
-							self.addClass(className);
-						}
-					}
-
-					// Toggle whole class name
-				} else if (type === core_strundefined || type === "boolean") {
-					if (this.className) {
-						// store className if set
-						jQuery._data(this, "__className__", this.className);
-					}
-
-					// If the element has a class name or if we're passed "false",
-					// then remove the whole classname (if there was one, the above saved it).
-					// Otherwise bring back whatever was previously saved (if anything),
-					// falling back to the empty string if nothing was stored.
-					this.className = this.className || value === false ? "" : jQuery._data(this, "__className__") || "";
-				}
-			});
-		},
-
-		hasClass: function (selector) {
-			var className = " " + selector + " ",
-				i = 0,
-				l = this.length;
-			for (; i < l; i++) {
-				if (this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf(className) >= 0) {
-					return true;
-				}
-			}
-
-			return false;
-		},
-
-		val: function (value) {
-			var ret, hooks, isFunction,
-				elem = this[0];
-
-			if (!arguments.length) {
-				if (elem) {
-					hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()];
-
-					if (hooks && "get" in hooks && (ret = hooks.get(elem, "value")) !== undefined) {
-						return ret;
-					}
-
-					ret = elem.value;
-
-					return typeof ret === "string" ?
-					// handle most common string cases
-					ret.replace(rreturn, "") :
-					// handle cases where value is null/undef or number
-					ret == null ? "" : ret;
-				}
-
-				return;
-			}
-
-			isFunction = jQuery.isFunction(value);
-
-			return this.each(function (i) {
-				var val;
-
-				if (this.nodeType !== 1) {
-					return;
-				}
-
-				if (isFunction) {
-					val = value.call(this, i, jQuery(this).val());
-				} else {
-					val = value;
-				}
-
-				// Treat null/undefined as ""; convert numbers to string
-				if (val == null) {
-					val = "";
-				} else if (typeof val === "number") {
-					val += "";
-				} else if (jQuery.isArray(val)) {
-					val = jQuery.map(val, function (value) {
-						return value == null ? "" : value + "";
-					});
-				}
-
-				hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()];
-
-				// If set returns undefined, fall back to normal setting
-				if (!hooks || !("set" in hooks) || hooks.set(this, val, "value") === undefined) {
-					this.value = val;
-				}
-			});
-		}
-	});
-
-	jQuery.extend({
-		valHooks: {
-			option: {
-				get: function (elem) {
-					// Use proper attribute retrieval(#6932, #12072)
-					var val = jQuery.find.attr(elem, "value");
-					return val != null ?
-						val :
-						elem.text;
-				}
-			},
-			select: {
-				get: function (elem) {
-					var value, option,
-						options = elem.options,
-						index = elem.selectedIndex,
-						one = elem.type === "select-one" || index < 0,
-						values = one ? null : [],
-						max = one ? index + 1 : options.length,
-						i = index < 0 ?
-							max :
-							one ? index : 0;
-
-					// Loop through all the selected options
-					for (; i < max; i++) {
-						option = options[i];
-
-						// oldIE doesn't update selected after form reset (#2551)
-						if ((option.selected || i === index) &&
-							// Don't return options that are disabled or in a disabled optgroup
-							(jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
-							(!option.parentNode.disabled || !jQuery.nodeName(option.parentNode, "optgroup"))) {
-
-							// Get the specific value for the option
-							value = jQuery(option).val();
-
-							// We don't need an array for one selects
-							if (one) {
-								return value;
-							}
-
-							// Multi-Selects return an array
-							values.push(value);
-						}
-					}
-
-					return values;
-				},
-
-				set: function (elem, value) {
-					var optionSet, option,
-						options = elem.options,
-						values = jQuery.makeArray(value),
-						i = options.length;
-
-					while (i--) {
-						option = options[i];
-						if ((option.selected = jQuery.inArray(jQuery(option).val(), values) >= 0)) {
-							optionSet = true;
-						}
-					}
-
-					// force browsers to behave consistently when non-matching value is set
-					if (!optionSet) {
-						elem.selectedIndex = -1;
-					}
-					return values;
-				}
-			}
-		},
-
-		attr: function (elem, name, value) {
-			var hooks, ret,
-				nType = elem.nodeType;
-
-			// don't get/set attributes on text, comment and attribute nodes
-			if (!elem || nType === 3 || nType === 8 || nType === 2) {
-				return;
-			}
-
-			// Fallback to prop when attributes are not supported
-			if (typeof elem.getAttribute === core_strundefined) {
-				return jQuery.prop(elem, name, value);
-			}
-
-			// All attributes are lowercase
-			// Grab necessary hook if one is defined
-			if (nType !== 1 || !jQuery.isXMLDoc(elem)) {
-				name = name.toLowerCase();
-				hooks = jQuery.attrHooks[name] ||
-					(jQuery.expr.match.bool.test(name) ? boolHook : nodeHook);
-			}
-
-			if (value !== undefined) {
-
-				if (value === null) {
-					jQuery.removeAttr(elem, name);
-
-				} else if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {
-					return ret;
-
-				} else {
-					elem.setAttribute(name, value + "");
-					return value;
-				}
-
-			} else if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) {
-				return ret;
-
-			} else {
-				ret = jQuery.find.attr(elem, name);
-
-				// Non-existent attributes return null, we normalize to undefined
-				return ret == null ?
-					undefined :
-					ret;
-			}
-		},
-
-		removeAttr: function (elem, value) {
-			var name, propName,
-				i = 0,
-				attrNames = value && value.match(core_rnotwhite);
-
-			if (attrNames && elem.nodeType === 1) {
-				while ((name = attrNames[i++])) {
-					propName = jQuery.propFix[name] || name;
-
-					// Boolean attributes get special treatment (#10870)
-					if (jQuery.expr.match.bool.test(name)) {
-						// Set corresponding property to false
-						if (getSetInput && getSetAttribute || !ruseDefault.test(name)) {
-							elem[propName] = false;
-							// Support: IE<9
-							// Also clear defaultChecked/defaultSelected (if appropriate)
-						} else {
-							elem[jQuery.camelCase("default-" + name)] =
-								elem[propName] = false;
-						}
-
-						// See #9699 for explanation of this approach (setting first, then removal)
-					} else {
-						jQuery.attr(elem, name, "");
-					}
-
-					elem.removeAttribute(getSetAttribute ? name : propName);
-				}
-			}
-		},
-
-		attrHooks: {
-			type: {
-				set: function (elem, value) {
-					if (!jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input")) {
-						// Setting the type on a radio button after the value resets the value in IE6-9
-						// Reset value to default in case type is set after value during creation
-						var val = elem.value;
-						elem.setAttribute("type", value);
-						if (val) {
-							elem.value = val;
-						}
-						return value;
-					}
-				}
-			}
-		},
-
-		propFix: {
-			"for": "htmlFor",
-			"class": "className"
-		},
-
-		prop: function (elem, name, value) {
-			var ret, hooks, notxml,
-				nType = elem.nodeType;
-
-			// don't get/set properties on text, comment and attribute nodes
-			if (!elem || nType === 3 || nType === 8 || nType === 2) {
-				return;
-			}
-
-			notxml = nType !== 1 || !jQuery.isXMLDoc(elem);
-
-			if (notxml) {
-				// Fix name and attach hooks
-				name = jQuery.propFix[name] || name;
-				hooks = jQuery.propHooks[name];
-			}
-
-			if (value !== undefined) {
-				return hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== undefined ?
-					ret :
-					(elem[name] = value);
-
-			} else {
-				return hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null ?
-					ret :
-					elem[name];
-			}
-		},
-
-		propHooks: {
-			tabIndex: {
-				get: function (elem) {
-					// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
-					// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
-					// Use proper attribute retrieval(#12072)
-					var tabindex = jQuery.find.attr(elem, "tabindex");
-
-					return tabindex ?
-						parseInt(tabindex, 10) :
-						rfocusable.test(elem.nodeName) || rclickable.test(elem.nodeName) && elem.href ?
-						0 : -1;
-				}
-			}
-		}
-	});
-
-	// Hooks for boolean attributes
-	boolHook = {
-		set: function (elem, value, name) {
-			if (value === false) {
-				// Remove boolean attributes when set to false
-				jQuery.removeAttr(elem, name);
-			} else if (getSetInput && getSetAttribute || !ruseDefault.test(name)) {
-				// IE<8 needs the *property* name
-				elem.setAttribute(!getSetAttribute && jQuery.propFix[name] || name, name);
-
-				// Use defaultChecked and defaultSelected for oldIE
-			} else {
-				elem[jQuery.camelCase("default-" + name)] = elem[name] = true;
-			}
-
-			return name;
-		}
-	};
-	jQuery.each(jQuery.expr.match.bool.source.match(/\w+/g), function (i, name) {
-		var getter = jQuery.expr.attrHandle[name] || jQuery.find.attr;
-
-		jQuery.expr.attrHandle[name] = getSetInput && getSetAttribute || !ruseDefault.test(name) ?
-			function (elem, name, isXML) {
-				var fn = jQuery.expr.attrHandle[name],
-					ret = isXML ?
-						undefined :
-					/* jshint eqeqeq: false */
-					(jQuery.expr.attrHandle[name] = undefined) !=
-						getter(elem, name, isXML) ?
-
-					name.toLowerCase() :
-						null;
-				jQuery.expr.attrHandle[name] = fn;
-				return ret;
-		} :
-			function (elem, name, isXML) {
-				return isXML ?
-					undefined :
-					elem[jQuery.camelCase("default-" + name)] ?
-					name.toLowerCase() :
-					null;
-		};
-	});
-
-	// fix oldIE attroperties
-	if (!getSetInput || !getSetAttribute) {
-		jQuery.attrHooks.value = {
-			set: function (elem, value, name) {
-				if (jQuery.nodeName(elem, "input")) {
-					// Does not return so that setAttribute is also used
-					elem.defaultValue = value;
-				} else {
-					// Use nodeHook if defined (#1954); otherwise setAttribute is fine
-					return nodeHook && nodeHook.set(elem, value, name);
-				}
-			}
-		};
-	}
-
-	// IE6/7 do not support getting/setting some attributes with get/setAttribute
-	if (!getSetAttribute) {
-
-		// Use this for any attribute in IE6/7
-		// This fixes almost every IE6/7 issue
-		nodeHook = {
-			set: function (elem, value, name) {
-				// Set the existing or create a new attribute node
-				var ret = elem.getAttributeNode(name);
-				if (!ret) {
-					elem.setAttributeNode(
-						(ret = elem.ownerDocument.createAttribute(name))
-					);
-				}
-
-				ret.value = value += "";
-
-				// Break association with cloned elements by also using setAttribute (#9646)
-				return name === "value" || value === elem.getAttribute(name) ?
-					value :
-					undefined;
-			}
-		};
-		jQuery.expr.attrHandle.id = jQuery.expr.attrHandle.name = jQuery.expr.attrHandle.coords =
-		// Some attributes are constructed with empty-string values when not defined
-
-		function (elem, name, isXML) {
-			var ret;
-			return isXML ?
-				undefined :
-				(ret = elem.getAttributeNode(name)) && ret.value !== "" ?
-				ret.value :
-				null;
-		};
-		jQuery.valHooks.button = {
-			get: function (elem, name) {
-				var ret = elem.getAttributeNode(name);
-				return ret && ret.specified ?
-					ret.value :
-					undefined;
-			},
-			set: nodeHook.set
-		};
-
-		// Set contenteditable to false on removals(#10429)
-		// Setting to empty string throws an error as an invalid value
-		jQuery.attrHooks.contenteditable = {
-			set: function (elem, value, name) {
-				nodeHook.set(elem, value === "" ? false : value, name);
-			}
-		};
-
-		// Set width and height to auto instead of 0 on empty string( Bug #8150 )
-		// This is for removals
-		jQuery.each(["width", "height"], function (i, name) {
-			jQuery.attrHooks[name] = {
-				set: function (elem, value) {
-					if (value === "") {
-						elem.setAttribute(name, "auto");
-						return value;
-					}
-				}
-			};
-		});
-	}
-
-
-	// Some attributes require a special call on IE
-	// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
-	if (!jQuery.support.hrefNormalized) {
-		// href/src property should get the full normalized URL (#10299/#12915)
-		jQuery.each(["href", "src"], function (i, name) {
-			jQuery.propHooks[name] = {
-				get: function (elem) {
-					return elem.getAttribute(name, 4);
-				}
-			};
-		});
-	}
-
-	if (!jQuery.support.style) {
-		jQuery.attrHooks.style = {
-			get: function (elem) {
-				// Return undefined in the case of empty string
-				// Note: IE uppercases css property names, but if we were to .toLowerCase()
-				// .cssText, that would destroy case senstitivity in URL's, like in "background"
-				return elem.style.cssText || undefined;
-			},
-			set: function (elem, value) {
-				return (elem.style.cssText = value + "");
-			}
-		};
-	}
-
-	// Safari mis-reports the default selected property of an option
-	// Accessing the parent's selectedIndex property fixes it
-	if (!jQuery.support.optSelected) {
-		jQuery.propHooks.selected = {
-			get: function (elem) {
-				var parent = elem.parentNode;
-
-				if (parent) {
-					parent.selectedIndex;
-
-					// Make sure that it also works with optgroups, see #5701
-					if (parent.parentNode) {
-						parent.parentNode.selectedIndex;
-					}
-				}
-				return null;
-			}
-		};
-	}
-
-	jQuery.each([
-		"tabIndex",
-		"readOnly",
-		"maxLength",
-		"cellSpacing",
-		"cellPadding",
-		"rowSpan",
-		"colSpan",
-		"useMap",
-		"frameBorder",
-		"contentEditable"
-	], function () {
-		jQuery.propFix[this.toLowerCase()] = this;
-	});
-
-	// IE6/7 call enctype encoding
-	if (!jQuery.support.enctype) {
-		jQuery.propFix.enctype = "encoding";
-	}
-
-	// Radios and checkboxes getter/setter
-	jQuery.each(["radio", "checkbox"], function () {
-		jQuery.valHooks[this] = {
-			set: function (elem, value) {
-				if (jQuery.isArray(value)) {
-					return (elem.checked = jQuery.inArray(jQuery(elem).val(), value) >= 0);
-				}
-			}
-		};
-		if (!jQuery.support.checkOn) {
-			jQuery.valHooks[this].get = function (elem) {
-				// Support: Webkit
-				// "" is returned instead of "on" if a value isn't specified
-				return elem.getAttribute("value") === null ? "on" : elem.value;
-			};
-		}
-	});
-	var rformElems = /^(?:input|select|textarea)$/i,
-		rkeyEvent = /^key/,
-		rmouseEvent = /^(?:mouse|contextmenu)|click/,
-		rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
-		rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;
-
-	function returnTrue() {
-		return true;
-	}
-
-	function returnFalse() {
-		return false;
-	}
-
-	function safeActiveElement() {
-		try {
-			return document.activeElement;
-		} catch (err) {}
-	}
-
-	/*
-	 * Helper functions for managing events -- not part of the public interface.
-	 * Props to Dean Edwards' addEvent library for many of the ideas.
-	 */
-	jQuery.event = {
-
-		global: {},
-
-		add: function (elem, types, handler, data, selector) {
-			var tmp, events, t, handleObjIn,
-				special, eventHandle, handleObj,
-				handlers, type, namespaces, origType,
-				elemData = jQuery._data(elem);
-
-			// Don't attach events to noData or text/comment nodes (but allow plain objects)
-			if (!elemData) {
-				return;
-			}
-
-			// Caller can pass in an object of custom data in lieu of the handler
-			if (handler.handler) {
-				handleObjIn = handler;
-				handler = handleObjIn.handler;
-				selector = handleObjIn.selector;
-			}
-
-			// Make sure that the handler has a unique ID, used to find/remove it later
-			if (!handler.guid) {
-				handler.guid = jQuery.guid++;
-			}
-
-			// Init the element's event structure and main handler, if this is the first
-			if (!(events = elemData.events)) {
-				events = elemData.events = {};
-			}
-			if (!(eventHandle = elemData.handle)) {
-				eventHandle = elemData.handle = function (e) {
-					// Discard the second event of a jQuery.event.trigger() and
-					// when an event is called after a page has unloaded
-					return typeof jQuery !== core_strundefined && (!e || jQuery.event.triggered !== e.type) ?
-						jQuery.event.dispatch.apply(eventHandle.elem, arguments) :
-						undefined;
-				};
-				// Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
-				eventHandle.elem = elem;
-			}
-
-			// Handle multiple events separated by a space
-			types = (types || "").match(core_rnotwhite) || [""];
-			t = types.length;
-			while (t--) {
-				tmp = rtypenamespace.exec(types[t]) || [];
-				type = origType = tmp[1];
-				namespaces = (tmp[2] || "").split(".").sort();
-
-				// There *must* be a type, no attaching namespace-only handlers
-				if (!type) {
-					continue;
-				}
-
-				// If event changes its type, use the special event handlers for the changed type
-				special = jQuery.event.special[type] || {};
-
-				// If selector defined, determine special event api type, otherwise given type
-				type = (selector ? special.delegateType : special.bindType) || type;
-
-				// Update special based on newly reset type
-				special = jQuery.event.special[type] || {};
-
-				// handleObj is passed to all event handlers
-				handleObj = jQuery.extend({
-					type: type,
-					origType: origType,
-					data: data,
-					handler: handler,
-					guid: handler.guid,
-					selector: selector,
-					needsContext: selector && jQuery.expr.match.needsContext.test(selector),
-					namespace: namespaces.join(".")
-				}, handleObjIn);
-
-				// Init the event handler queue if we're the first
-				if (!(handlers = events[type])) {
-					handlers = events[type] = [];
-					handlers.delegateCount = 0;
-
-					// Only use addEventListener/attachEvent if the special events handler returns false
-					if (!special.setup || special.setup.call(elem, data, namespaces, eventHandle) === false) {
-						// Bind the global event handler to the element
-						if (elem.addEventListener) {
-							elem.addEventListener(type, eventHandle, false);
-
-						} else if (elem.attachEvent) {
-							elem.attachEvent("on" + type, eventHandle);
-						}
-					}
-				}
-
-				if (special.add) {
-					special.add.call(elem, handleObj);
-
-					if (!handleObj.handler.guid) {
-						handleObj.handler.guid = handler.guid;
-					}
-				}
-
-				// Add to the element's handler list, delegates in front
-				if (selector) {
-					handlers.splice(handlers.delegateCount++, 0, handleObj);
-				} else {
-					handlers.push(handleObj);
-				}
-
-				// Keep track of which events have ever been used, for event optimization
-				jQuery.event.global[type] = true;
-			}
-
-			// Nullify elem to prevent memory leaks in IE
-			elem = null;
-		},
-
-		// Detach an event or set of events from an element
-		remove: function (elem, types, handler, selector, mappedTypes) {
-			var j, handleObj, tmp,
-				origCount, t, events,
-				special, handlers, type,
-				namespaces, origType,
-				elemData = jQuery.hasData(elem) && jQuery._data(elem);
-
-			if (!elemData || !(events = elemData.events)) {
-				return;
-			}
-
-			// Once for each type.namespace in types; type may be omitted
-			types = (types || "").match(core_rnotwhite) || [""];
-			t = types.length;
-			while (t--) {
-				tmp = rtypenamespace.exec(types[t]) || [];
-				type = origType = tmp[1];
-				namespaces = (tmp[2] || "").split(".").sort();
-
-				// Unbind all events (on this namespace, if provided) for the element
-				if (!type) {
-					for (type in events) {
-						jQuery.event.remove(elem, type + types[t], handler, selector, true);
-					}
-					continue;
-				}
-
-				special = jQuery.event.special[type] || {};
-				type = (selector ? special.delegateType : special.bindType) || type;
-				handlers = events[type] || [];
-				tmp = tmp[2] && new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)");
-
-				// Remove matching events
-				origCount = j = handlers.length;
-				while (j--) {
-					handleObj = handlers[j];
-
-					if ((mappedTypes || origType === handleObj.origType) &&
-						(!handler || handler.guid === handleObj.guid) &&
-						(!tmp || tmp.test(handleObj.namespace)) &&
-						(!selector || selector === handleObj.selector || selector === "**" && handleObj.selector)) {
-						handlers.splice(j, 1);
-
-						if (handleObj.selector) {
-							handlers.delegateCount--;
-						}
-						if (special.remove) {
-							special.remove.call(elem, handleObj);
-						}
-					}
-				}
-
-				// Remove generic event handler if we removed something and no more handlers exist
-				// (avoids potential for endless recursion during removal of special event handlers)
-				if (origCount && !handlers.length) {
-					if (!special.teardown || special.teardown.call(elem, namespaces, elemData.handle) === false) {
-						jQuery.removeEvent(elem, type, elemData.handle);
-					}
-
-					delete events[type];
-				}
-			}
-
-			// Remove the expando if it's no longer used
-			if (jQuery.isEmptyObject(events)) {
-				delete elemData.handle;
-
-				// removeData also checks for emptiness and clears the expando if empty
-				// so use it instead of delete
-				jQuery._removeData(elem, "events");
-			}
-		},
-
-		trigger: function (event, data, elem, onlyHandlers) {
-			var handle, ontype, cur,
-				bubbleType, special, tmp, i,
-				eventPath = [elem || document],
-				type = core_hasOwn.call(event, "type") ? event.type : event,
-				namespaces = core_hasOwn.call(event, "namespace") ? event.namespace.split(".") : [];
-
-			cur = tmp = elem = elem || document;
-
-			// Don't do events on text and comment nodes
-			if (elem.nodeType === 3 || elem.nodeType === 8) {
-				return;
-			}
-
-			// focus/blur morphs to focusin/out; ensure we're not firing them right now
-			if (rfocusMorph.test(type + jQuery.event.triggered)) {
-				return;
-			}
-
-			if (type.indexOf(".") >= 0) {
-				// Namespaced trigger; create a regexp to match event type in handle()
-				namespaces = type.split(".");
-				type = namespaces.shift();
-				namespaces.sort();
-			}
-			ontype = type.indexOf(":") < 0 && "on" + type;
-
-			// Caller can pass in a jQuery.Event object, Object, or just an event type string
-			event = event[jQuery.expando] ?
-				event :
-				new jQuery.Event(type, typeof event === "object" && event);
-
-			// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
-			event.isTrigger = onlyHandlers ? 2 : 3;
-			event.namespace = namespaces.join(".");
-			event.namespace_re = event.namespace ?
-				new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") :
-				null;
-
-			// Clean up the event in case it is being reused
-			event.result = undefined;
-			if (!event.target) {
-				event.target = elem;
-			}
-
-			// Clone any incoming data and prepend the event, creating the handler arg list
-			data = data == null ?
-				[event] :
-				jQuery.makeArray(data, [event]);
-
-			// Allow special events to draw outside the lines
-			special = jQuery.event.special[type] || {};
-			if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) {
-				return;
-			}
-
-			// Determine event propagation path in advance, per W3C events spec (#9951)
-			// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
-			if (!onlyHandlers && !special.noBubble && !jQuery.isWindow(elem)) {
-
-				bubbleType = special.delegateType || type;
-				if (!rfocusMorph.test(bubbleType + type)) {
-					cur = cur.parentNode;
-				}
-				for (; cur; cur = cur.parentNode) {
-					eventPath.push(cur);
-					tmp = cur;
-				}
-
-				// Only add window if we got to document (e.g., not plain obj or detached DOM)
-				if (tmp === (elem.ownerDocument || document)) {
-					eventPath.push(tmp.defaultView || tmp.parentWindow || window);
-				}
-			}
-
-			// Fire handlers on the event path
-			i = 0;
-			while ((cur = eventPath[i++]) && !event.isPropagationStopped()) {
-
-				event.type = i > 1 ?
-					bubbleType :
-					special.bindType || type;
-
-				// jQuery handler
-				handle = (jQuery._data(cur, "events") || {})[event.type] && jQuery._data(cur, "handle");
-				if (handle) {
-					handle.apply(cur, data);
-				}
-
-				// Native handler
-				handle = ontype && cur[ontype];
-				if (handle && jQuery.acceptData(cur) && handle.apply && handle.apply(cur, data) === false) {
-					event.preventDefault();
-				}
-			}
-			event.type = type;
-
-			// If nobody prevented the default action, do it now
-			if (!onlyHandlers && !event.isDefaultPrevented()) {
-
-				if ((!special._default || special._default.apply(eventPath.pop(), data) === false) &&
-					jQuery.acceptData(elem)) {
-
-					// Call a native DOM method on the target with the same name name as the event.
-					// Can't use an .isFunction() check here because IE6/7 fails that test.
-					// Don't do default actions on window, that's where global variables be (#6170)
-					if (ontype && elem[type] && !jQuery.isWindow(elem)) {
-
-						// Don't re-trigger an onFOO event when we call its FOO() method
-						tmp = elem[ontype];
-
-						if (tmp) {
-							elem[ontype] = null;
-						}
-
-						// Prevent re-triggering of the same event, since we already bubbled it above
-						jQuery.event.triggered = type;
-						try {
-							elem[type]();
-						} catch (e) {
-							// IE<9 dies on focus/blur to hidden element (#1486,#12518)
-							// only reproducible on winXP IE8 native, not IE9 in IE8 mode
-						}
-						jQuery.event.triggered = undefined;
-
-						if (tmp) {
-							elem[ontype] = tmp;
-						}
-					}
-				}
-			}
-
-			return event.result;
-		},
-
-		dispatch: function (event) {
-
-			// Make a writable jQuery.Event from the native event object
-			event = jQuery.event.fix(event);
-
-			var i, ret, handleObj, matched, j,
-				handlerQueue = [],
-				args = core_slice.call(arguments),
-				handlers = (jQuery._data(this, "events") || {})[event.type] || [],
-				special = jQuery.event.special[event.type] || {};
-
-			// Use the fix-ed jQuery.Event rather than the (read-only) native event
-			args[0] = event;
-			event.delegateTarget = this;
-
-			// Call the preDispatch hook for the mapped type, and let it bail if desired
-			if (special.preDispatch && special.preDispatch.call(this, event) === false) {
-				return;
-			}
-
-			// Determine handlers
-			handlerQueue = jQuery.event.handlers.call(this, event, handlers);
-
-			// Run delegates first; they may want to stop propagation beneath us
-			i = 0;
-			while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) {
-				event.currentTarget = matched.elem;
-
-				j = 0;
-				while ((handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped()) {
-
-					// Triggered event must either 1) have no namespace, or
-					// 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
-					if (!event.namespace_re || event.namespace_re.test(handleObj.namespace)) {
-
-						event.handleObj = handleObj;
-						event.data = handleObj.data;
-
-						ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler)
-							.apply(matched.elem, args);
-
-						if (ret !== undefined) {
-							if ((event.result = ret) === false) {
-								event.preventDefault();
-								event.stopPropagation();
-							}
-						}
-					}
-				}
-			}
-
-			// Call the postDispatch hook for the mapped type
-			if (special.postDispatch) {
-				special.postDispatch.call(this, event);
-			}
-
-			return event.result;
-		},
-
-		handlers: function (event, handlers) {
-			var sel, handleObj, matches, i,
-				handlerQueue = [],
-				delegateCount = handlers.delegateCount,
-				cur = event.target;
-
-			// Find delegate handlers
-			// Black-hole SVG <use> instance trees (#13180)
-			// Avoid non-left-click bubbling in Firefox (#3861)
-			if (delegateCount && cur.nodeType && (!event.button || event.type !== "click")) {
-
-				/* jshint eqeqeq: false */
-				for (; cur != this; cur = cur.parentNode || this) {
-					/* jshint eqeqeq: true */
-
-					// Don't check non-elements (#13208)
-					// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
-					if (cur.nodeType === 1 && (cur.disabled !== true || event.type !== "click")) {
-						matches = [];
-						for (i = 0; i < delegateCount; i++) {
-							handleObj = handlers[i];
-
-							// Don't conflict with Object.prototype properties (#13203)
-							sel = handleObj.selector + " ";
-
-							if (matches[sel] === undefined) {
-								matches[sel] = handleObj.needsContext ?
-									jQuery(sel, this).index(cur) >= 0 :
-									jQuery.find(sel, this, null, [cur]).length;
-							}
-							if (matches[sel]) {
-								matches.push(handleObj);
-							}
-						}
-						if (matches.length) {
-							handlerQueue.push({
-								elem: cur,
-								handlers: matches
-							});
-						}
-					}
-				}
-			}
-
-			// Add the remaining (directly-bound) handlers
-			if (delegateCount < handlers.length) {
-				handlerQueue.push({
-					elem: this,
-					handlers: handlers.slice(delegateCount)
-				});
-			}
-
-			return handlerQueue;
-		},
-
-		fix: function (event) {
-			if (event[jQuery.expando]) {
-				return event;
-			}
-
-			// Create a writable copy of the event object and normalize some properties
-			var i, prop, copy,
-				type = event.type,
-				originalEvent = event,
-				fixHook = this.fixHooks[type];
-
-			if (!fixHook) {
-				this.fixHooks[type] = fixHook =
-					rmouseEvent.test(type) ? this.mouseHooks :
-					rkeyEvent.test(type) ? this.keyHooks : {};
-			}
-			copy = fixHook.props ? this.props.concat(fixHook.props) : this.props;
-
-			event = new jQuery.Event(originalEvent);
-
-			i = copy.length;
-			while (i--) {
-				prop = copy[i];
-				event[prop] = originalEvent[prop];
-			}
-
-			// Support: IE<9
-			// Fix target property (#1925)
-			if (!event.target) {
-				event.target = originalEvent.srcElement || document;
-			}
-
-			// Support: Chrome 23+, Safari?
-			// Target should not be a text node (#504, #13143)
-			if (event.target.nodeType === 3) {
-				event.target = event.target.parentNode;
-			}
-
-			// Support: IE<9
-			// For mouse/key events, metaKey==false if it's undefined (#3368, #11328)
-			event.metaKey = !! event.metaKey;
-
-			return fixHook.filter ? fixHook.filter(event, originalEvent) : event;
-		},
-
-		// Includes some event props shared by KeyEvent and MouseEvent
-		props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
-
-		fixHooks: {},
-
-		keyHooks: {
-			props: "char charCode key keyCode".split(" "),
-			filter: function (event, original) {
-
-				// Add which for key events
-				if (event.which == null) {
-					event.which = original.charCode != null ? original.charCode : original.keyCode;
-				}
-
-				return event;
-			}
-		},
-
-		mouseHooks: {
-			props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
-			filter: function (event, original) {
-				var body, eventDoc, doc,
-					button = original.button,
-					fromElement = original.fromElement;
-
-				// Calculate pageX/Y if missing and clientX/Y available
-				if (event.pageX == null && original.clientX != null) {
-					eventDoc = event.target.ownerDocument || document;
-					doc = eventDoc.documentElement;
-					body = eventDoc.body;
-
-					event.pageX = original.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
-					event.pageY = original.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
-				}
-
-				// Add relatedTarget, if necessary
-				if (!event.relatedTarget && fromElement) {
-					event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
-				}
-
-				// Add which for click: 1 === left; 2 === middle; 3 === right
-				// Note: button is not normalized, so don't use it
-				if (!event.which && button !== undefined) {
-					event.which = (button & 1 ? 1 : (button & 2 ? 3 : (button & 4 ? 2 : 0)));
-				}
-
-				return event;
-			}
-		},
-
-		special: {
-			load: {
-				// Prevent triggered image.load events from bubbling to window.load
-				noBubble: true
-			},
-			focus: {
-				// Fire native event if possible so blur/focus sequence is correct
-				trigger: function () {
-					if (this !== safeActiveElement() && this.focus) {
-						try {
-							this.focus();
-							return false;
-						} catch (e) {
-							// Support: IE<9
-							// If we error on focus to hidden element (#1486, #12518),
-							// let .trigger() run the handlers
-						}
-					}
-				},
-				delegateType: "focusin"
-			},
-			blur: {
-				trigger: function () {
-					if (this === safeActiveElement() && this.blur) {
-						this.blur();
-						return false;
-					}
-				},
-				delegateType: "focusout"
-			},
-			click: {
-				// For checkbox, fire native event so checked state will be right
-				trigger: function () {
-					if (jQuery.nodeName(this, "input") && this.type === "checkbox" && this.click) {
-						this.click();
-						return false;
-					}
-				},
-
-				// For cross-browser consistency, don't fire native .click() on links
-				_default: function (event) {
-					return jQuery.nodeName(event.target, "a");
-				}
-			},
-
-			beforeunload: {
-				postDispatch: function (event) {
-
-					// Even when returnValue equals to undefined Firefox will still show alert
-					if (event.result !== undefined) {
-						event.originalEvent.returnValue = event.result;
-					}
-				}
-			}
-		},
-
-		simulate: function (type, elem, event, bubble) {
-			// Piggyback on a donor event to simulate a different one.
-			// Fake originalEvent to avoid donor's stopPropagation, but if the
-			// simulated event prevents default then we do the same on the donor.
-			var e = jQuery.extend(
-				new jQuery.Event(),
-				event, {
-					type: type,
-					isSimulated: true,
-					originalEvent: {}
-				}
-			);
-			if (bubble) {
-				jQuery.event.trigger(e, null, elem);
-			} else {
-				jQuery.event.dispatch.call(elem, e);
-			}
-			if (e.isDefaultPrevented()) {
-				event.preventDefault();
-			}
-		}
-	};
-
-	jQuery.removeEvent = document.removeEventListener ?
-		function (elem, type, handle) {
-			if (elem.removeEventListener) {
-				elem.removeEventListener(type, handle, false);
-			}
-	} :
-		function (elem, type, handle) {
-			var name = "on" + type;
-
-			if (elem.detachEvent) {
-
-				// #8545, #7054, preventing memory leaks for custom events in IE6-8
-				// detachEvent needed property on element, by name of that event, to properly expose it to GC
-				if (typeof elem[name] === core_strundefined) {
-					elem[name] = null;
-				}
-
-				elem.detachEvent(name, handle);
-			}
-	};
-
-	jQuery.Event = function (src, props) {
-		// Allow instantiation without the 'new' keyword
-		if (!(this instanceof jQuery.Event)) {
-			return new jQuery.Event(src, props);
-		}
-
-		// Event object
-		if (src && src.type) {
-			this.originalEvent = src;
-			this.type = src.type;
-
-			// Events bubbling up the document may have been marked as prevented
-			// by a handler lower down the tree; reflect the correct value.
-			this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false ||
-				src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;
-
-			// Event type
-		} else {
-			this.type = src;
-		}
-
-		// Put explicitly provided properties onto the event object
-		if (props) {
-			jQuery.extend(this, props);
-		}
-
-		// Create a timestamp if incoming event doesn't have one
-		this.timeStamp = src && src.timeStamp || jQuery.now();
-
-		// Mark it as fixed
-		this[jQuery.expando] = true;
-	};
-
-	// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
-	// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
-	jQuery.Event.prototype = {
-		isDefaultPrevented: returnFalse,
-		isPropagationStopped: returnFalse,
-		isImmediatePropagationStopped: returnFalse,
-
-		preventDefault: function () {
-			var e = this.originalEvent;
-
-			this.isDefaultPrevented = returnTrue;
-			if (!e) {
-				return;
-			}
-
-			// If preventDefault exists, run it on the original event
-			if (e.preventDefault) {
-				e.preventDefault();
-
-				// Support: IE
-				// Otherwise set the returnValue property of the original event to false
-			} else {
-				e.returnValue = false;
-			}
-		},
-		stopPropagation: function () {
-			var e = this.originalEvent;
-
-			this.isPropagationStopped = returnTrue;
-			if (!e) {
-				return;
-			}
-			// If stopPropagation exists, run it on the original event
-			if (e.stopPropagation) {
-				e.stopPropagation();
-			}
-
-			// Support: IE
-			// Set the cancelBubble property of the original event to true
-			e.cancelBubble = true;
-		},
-		stopImmediatePropagation: function () {
-			this.isImmediatePropagationStopped = returnTrue;
-			this.stopPropagation();
-		}
-	};
-
-	// Create mouseenter/leave events using mouseover/out and event-time checks
-	jQuery.each({
-		mouseenter: "mouseover",
-		mouseleave: "mouseout"
-	}, function (orig, fix) {
-		jQuery.event.special[orig] = {
-			delegateType: fix,
-			bindType: fix,
-
-			handle: function (event) {
-				var ret,
-					target = this,
-					related = event.relatedTarget,
-					handleObj = event.handleObj;
-
-				// For mousenter/leave call the handler if related is outside the target.
-				// NB: No relatedTarget if the mouse left/entered the browser window
-				if (!related || (related !== target && !jQuery.contains(target, related))) {
-					event.type = handleObj.origType;
-					ret = handleObj.handler.apply(this, arguments);
-					event.type = fix;
-				}
-				return ret;
-			}
-		};
-	});
-
-	// IE submit delegation
-	if (!jQuery.support.submitBubbles) {
-
-		jQuery.event.special.submit = {
-			setup: function () {
-				// Only need this for delegated form submit events
-				if (jQuery.nodeName(this, "form")) {
-					return false;
-				}
-
-				// Lazy-add a submit handler when a descendant form may potentially be submitted
-				jQuery.event.add(this, "click._submit keypress._submit", function (e) {
-					// Node name check avoids a VML-related crash in IE (#9807)
-					var elem = e.target,
-						form = jQuery.nodeName(elem, "input") || jQuery.nodeName(elem, "button") ? elem.form : undefined;
-					if (form && !jQuery._data(form, "submitBubbles")) {
-						jQuery.event.add(form, "submit._submit", function (event) {
-							event._submit_bubble = true;
-						});
-						jQuery._data(form, "submitBubbles", true);
-					}
-				});
-				// return undefined since we don't need an event listener
-			},
-
-			postDispatch: function (event) {
-				// If form was submitted by the user, bubble the event up the tree
-				if (event._submit_bubble) {
-					delete event._submit_bubble;
-					if (this.parentNode && !event.isTrigger) {
-						jQuery.event.simulate("submit", this.parentNode, event, true);
-					}
-				}
-			},
-
-			teardown: function () {
-				// Only need this for delegated form submit events
-				if (jQuery.nodeName(this, "form")) {
-					return false;
-				}
-
-				// Remove delegated handlers; cleanData eventually reaps submit handlers attached above
-				jQuery.event.remove(this, "._submit");
-			}
-		};
-	}
-
-	// IE change delegation and checkbox/radio fix
-	if (!jQuery.support.changeBubbles) {
-
-		jQuery.event.special.change = {
-
-			setup: function () {
-
-				if (rformElems.test(this.nodeName)) {
-					// IE doesn't fire change on a check/radio until blur; trigger it on click
-					// after a propertychange. Eat the blur-change in special.change.handle.
-					// This still fires onchange a second time for check/radio after blur.
-					if (this.type === "checkbox" || this.type === "radio") {
-						jQuery.event.add(this, "propertychange._change", function (event) {
-							if (event.originalEvent.propertyName === "checked") {
-								this._just_changed = true;
-							}
-						});
-						jQuery.event.add(this, "click._change", function (event) {
-							if (this._just_changed && !event.isTrigger) {
-								this._just_changed = false;
-							}
-							// Allow triggered, simulated change events (#11500)
-							jQuery.event.simulate("change", this, event, true);
-						});
-					}
-					return false;
-				}
-				// Delegated event; lazy-add a change handler on descendant inputs
-				jQuery.event.add(this, "beforeactivate._change", function (e) {
-					var elem = e.target;
-
-					if (rformElems.test(elem.nodeName) && !jQuery._data(elem, "changeBubbles")) {
-						jQuery.event.add(elem, "change._change", function (event) {
-							if (this.parentNode && !event.isSimulated && !event.isTrigger) {
-								jQuery.event.simulate("change", this.parentNode, event, true);
-							}
-						});
-						jQuery._data(elem, "changeBubbles", true);
-					}
-				});
-			},
-
-			handle: function (event) {
-				var elem = event.target;
-
-				// Swallow native change events from checkbox/radio, we already triggered them above
-				if (this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox")) {
-					return event.handleObj.handler.apply(this, arguments);
-				}
-			},
-
-			teardown: function () {
-				jQuery.event.remove(this, "._change");
-
-				return !rformElems.test(this.nodeName);
-			}
-		};
-	}
-
-	// Create "bubbling" focus and blur events
-	if (!jQuery.support.focusinBubbles) {
-		jQuery.each({
-			focus: "focusin",
-			blur: "focusout"
-		}, function (orig, fix) {
-
-			// Attach a single capturing handler while someone wants focusin/focusout
-			var attaches = 0,
-				handler = function (event) {
-					jQuery.event.simulate(fix, event.target, jQuery.event.fix(event), true);
-				};
-
-			jQuery.event.special[fix] = {
-				setup: function () {
-					if (attaches++ === 0) {
-						document.addEventListener(orig, handler, true);
-					}
-				},
-				teardown: function () {
-					if (--attaches === 0) {
-						document.removeEventListener(orig, handler, true);
-					}
-				}
-			};
-		});
-	}
-
-	jQuery.fn.extend({
-
-		on: function (types, selector, data, fn, /*INTERNAL*/ one) {
-			var type, origFn;
-
-			// Types can be a map of types/handlers
-			if (typeof types === "object") {
-				// ( types-Object, selector, data )
-				if (typeof selector !== "string") {
-					// ( types-Object, data )
-					data = data || selector;
-					selector = undefined;
-				}
-				for (type in types) {
-					this.on(type, selector, data, types[type], one);
-				}
-				return this;
-			}
-
-			if (data == null && fn == null) {
-				// ( types, fn )
-				fn = selector;
-				data = selector = undefined;
-			} else if (fn == null) {
-				if (typeof selector === "string") {
-					// ( types, selector, fn )
-					fn = data;
-					data = undefined;
-				} else {
-					// ( types, data, fn )
-					fn = data;
-					data = selector;
-					selector = undefined;
-				}
-			}
-			if (fn === false) {
-				fn = returnFalse;
-			} else if (!fn) {
-				return this;
-			}
-
-			if (one === 1) {
-				origFn = fn;
-				fn = function (event) {
-					// Can use an empty set, since event contains the info
-					jQuery().off(event);
-					return origFn.apply(this, arguments);
-				};
-				// Use same guid so caller can remove using origFn
-				fn.guid = origFn.guid || (origFn.guid = jQuery.guid++);
-			}
-			return this.each(function () {
-				jQuery.event.add(this, types, fn, data, selector);
-			});
-		},
-		one: function (types, selector, data, fn) {
-			return this.on(types, selector, data, fn, 1);
-		},
-		off: function (types, selector, fn) {
-			var handleObj, type;
-			if (types && types.preventDefault && types.handleObj) {
-				// ( event )  dispatched jQuery.Event
-				handleObj = types.handleObj;
-				jQuery(types.delegateTarget).off(
-					handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType,
-					handleObj.selector,
-					handleObj.handler
-				);
-				return this;
-			}
-			if (typeof types === "object") {
-				// ( types-object [, selector] )
-				for (type in types) {
-					this.off(type, selector, types[type]);
-				}
-				return this;
-			}
-			if (selector === false || typeof selector === "function") {
-				// ( types [, fn] )
-				fn = selector;
-				selector = undefined;
-			}
-			if (fn === false) {
-				fn = returnFalse;
-			}
-			return this.each(function () {
-				jQuery.event.remove(this, types, fn, selector);
-			});
-		},
-
-		trigger: function (type, data) {
-			return this.each(function () {
-				jQuery.event.trigger(type, data, this);
-			});
-		},
-		triggerHandler: function (type, data) {
-			var elem = this[0];
-			if (elem) {
-				return jQuery.event.trigger(type, data, elem, true);
-			}
-		}
-	});
-	var isSimple = /^.[^:#\[\.,]*$/,
-		rparentsprev = /^(?:parents|prev(?:Until|All))/,
-		rneedsContext = jQuery.expr.match.needsContext,
-		// methods guaranteed to produce a unique set when starting from a unique set
-		guaranteedUnique = {
-			children: true,
-			contents: true,
-			next: true,
-			prev: true
-		};
-
-	jQuery.fn.extend({
-		find: function (selector) {
-			var i,
-				ret = [],
-				self = this,
-				len = self.length;
-
-			if (typeof selector !== "string") {
-				return this.pushStack(jQuery(selector).filter(function () {
-					for (i = 0; i < len; i++) {
-						if (jQuery.contains(self[i], this)) {
-							return true;
-						}
-					}
-				}));
-			}
-
-			for (i = 0; i < len; i++) {
-				jQuery.find(selector, self[i], ret);
-			}
-
-			// Needed because $( selector, context ) becomes $( context ).find( selector )
-			ret = this.pushStack(len > 1 ? jQuery.unique(ret) : ret);
-			ret.selector = this.selector ? this.selector + " " + selector : selector;
-			return ret;
-		},
-
-		has: function (target) {
-			var i,
-				targets = jQuery(target, this),
-				len = targets.length;
-
-			return this.filter(function () {
-				for (i = 0; i < len; i++) {
-					if (jQuery.contains(this, targets[i])) {
-						return true;
-					}
-				}
-			});
-		},
-
-		not: function (selector) {
-			return this.pushStack(winnow(this, selector || [], true));
-		},
-
-		filter: function (selector) {
-			return this.pushStack(winnow(this, selector || [], false));
-		},
-
-		is: function (selector) {
-			return !!winnow(
-				this,
-
-				// If this is a positional/relative selector, check membership in the returned set
-				// so $("p:first").is("p:last") won't return true for a doc with two "p".
-				typeof selector === "string" && rneedsContext.test(selector) ?
-				jQuery(selector) :
-				selector || [],
-				false
-			).length;
-		},
-
-		closest: function (selectors, context) {
-			var cur,
-				i = 0,
-				l = this.length,
-				ret = [],
-				pos = rneedsContext.test(selectors) || typeof selectors !== "string" ?
-					jQuery(selectors, context || this.context) :
-					0;
-
-			for (; i < l; i++) {
-				for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) {
-					// Always skip document fragments
-					if (cur.nodeType < 11 && (pos ?
-						pos.index(cur) > -1 :
-
-						// Don't pass non-elements to Sizzle
-						cur.nodeType === 1 &&
-						jQuery.find.matchesSelector(cur, selectors))) {
-
-						cur = ret.push(cur);
-						break;
-					}
-				}
-			}
-
-			return this.pushStack(ret.length > 1 ? jQuery.unique(ret) : ret);
-		},
-
-		// Determine the position of an element within
-		// the matched set of elements
-		index: function (elem) {
-
-			// No argument, return index in parent
-			if (!elem) {
-				return (this[0] && this[0].parentNode) ? this.first().prevAll().length : -1;
-			}
-
-			// index in selector
-			if (typeof elem === "string") {
-				return jQuery.inArray(this[0], jQuery(elem));
-			}
-
-			// Locate the position of the desired element
-			return jQuery.inArray(
-				// If it receives a jQuery object, the first element is used
-				elem.jquery ? elem[0] : elem, this);
-		},
-
-		add: function (selector, context) {
-			var set = typeof selector === "string" ?
-				jQuery(selector, context) :
-				jQuery.makeArray(selector && selector.nodeType ? [selector] : selector),
-				all = jQuery.merge(this.get(), set);
-
-			return this.pushStack(jQuery.unique(all));
-		},
-
-		addBack: function (selector) {
-			return this.add(selector == null ?
-				this.prevObject : this.prevObject.filter(selector)
-			);
-		}
-	});
-
-	function sibling(cur, dir) {
-		do {
-			cur = cur[dir];
-		} while (cur && cur.nodeType !== 1);
-
-		return cur;
-	}
-
-	jQuery.each({
-		parent: function (elem) {
-			var parent = elem.parentNode;
-			return parent && parent.nodeType !== 11 ? parent : null;
-		},
-		parents: function (elem) {
-			return jQuery.dir(elem, "parentNode");
-		},
-		parentsUntil: function (elem, i, until) {
-			return jQuery.dir(elem, "parentNode", until);
-		},
-		next: function (elem) {
-			return sibling(elem, "nextSibling");
-		},
-		prev: function (elem) {
-			return sibling(elem, "previousSibling");
-		},
-		nextAll: function (elem) {
-			return jQuery.dir(elem, "nextSibling");
-		},
-		prevAll: function (elem) {
-			return jQuery.dir(elem, "previousSibling");
-		},
-		nextUntil: function (elem, i, until) {
-			return jQuery.dir(elem, "nextSibling", until);
-		},
-		prevUntil: function (elem, i, until) {
-			return jQuery.dir(elem, "previousSibling", until);
-		},
-		siblings: function (elem) {
-			return jQuery.sibling((elem.parentNode || {}).firstChild, elem);
-		},
-		children: function (elem) {
-			return jQuery.sibling(elem.firstChild);
-		},
-		contents: function (elem) {
-			return jQuery.nodeName(elem, "iframe") ?
-				elem.contentDocument || elem.contentWindow.document :
-				jQuery.merge([], elem.childNodes);
-		}
-	}, function (name, fn) {
-		jQuery.fn[name] = function (until, selector) {
-			var ret = jQuery.map(this, fn, until);
-
-			if (name.slice(-5) !== "Until") {
-				selector = until;
-			}
-
-			if (selector && typeof selector === "string") {
-				ret = jQuery.filter(selector, ret);
-			}
-
-			if (this.length > 1) {
-				// Remove duplicates
-				if (!guaranteedUnique[name]) {
-					ret = jQuery.unique(ret);
-				}
-
-				// Reverse order for parents* and prev-derivatives
-				if (rparentsprev.test(name)) {
-					ret = ret.reverse();
-				}
-			}
-
-			return this.pushStack(ret);
-		};
-	});
-
-	jQuery.extend({
-		filter: function (expr, elems, not) {
-			var elem = elems[0];
-
-			if (not) {
-				expr = ":not(" + expr + ")";
-			}
-
-			return elems.length === 1 && elem.nodeType === 1 ?
-				jQuery.find.matchesSelector(elem, expr) ? [elem] : [] :
-				jQuery.find.matches(expr, jQuery.grep(elems, function (elem) {
-					return elem.nodeType === 1;
-				}));
-		},
-
-		dir: function (elem, dir, until) {
-			var matched = [],
-				cur = elem[dir];
-
-			while (cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery(cur).is(until))) {
-				if (cur.nodeType === 1) {
-					matched.push(cur);
-				}
-				cur = cur[dir];
-			}
-			return matched;
-		},
-
-		sibling: function (n, elem) {
-			var r = [];
-
-			for (; n; n = n.nextSibling) {
-				if (n.nodeType === 1 && n !== elem) {
-					r.push(n);
-				}
-			}
-
-			return r;
-		}
-	});
-
-	// Implement the identical functionality for filter and not
-
-	function winnow(elements, qualifier, not) {
-		if (jQuery.isFunction(qualifier)) {
-			return jQuery.grep(elements, function (elem, i) {
-				/* jshint -W018 */
-				return !!qualifier.call(elem, i, elem) !== not;
-			});
-
-		}
-
-		if (qualifier.nodeType) {
-			return jQuery.grep(elements, function (elem) {
-				return (elem === qualifier) !== not;
-			});
-
-		}
-
-		if (typeof qualifier === "string") {
-			if (isSimple.test(qualifier)) {
-				return jQuery.filter(qualifier, elements, not);
-			}
-
-			qualifier = jQuery.filter(qualifier, elements);
-		}
-
-		return jQuery.grep(elements, function (elem) {
-			return (jQuery.inArray(elem, qualifier) >= 0) !== not;
-		});
-	}
-
-	function createSafeFragment(document) {
-		var list = nodeNames.split("|"),
-			safeFrag = document.createDocumentFragment();
-
-		if (safeFrag.createElement) {
-			while (list.length) {
-				safeFrag.createElement(
-					list.pop()
-				);
-			}
-		}
-		return safeFrag;
-	}
-
-	var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|" +
-		"header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",
-		rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g,
-		rnoshimcache = new RegExp("<(?:" + nodeNames + ")[\\s/>]", "i"),
-		rleadingWhitespace = /^\s+/,
-		rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,
-		rtagName = /<([\w:]+)/,
-		rtbody = /<tbody/i,
-		rhtml = /<|&#?\w+;/,
-		rnoInnerhtml = /<(?:script|style|link)/i,
-		manipulation_rcheckableType = /^(?:checkbox|radio)$/i,
-		// checked="checked" or checked
-		rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
-		rscriptType = /^$|\/(?:java|ecma)script/i,
-		rscriptTypeMasked = /^true\/(.*)/,
-		rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,
-
-		// We have to close these tags to support XHTML (#13200)
-		wrapMap = {
-			option: [1, "<select multiple='multiple'>", "</select>"],
-			legend: [1, "<fieldset>", "</fieldset>"],
-			area: [1, "<map>", "</map>"],
-			param: [1, "<object>", "</object>"],
-			thead: [1, "<table>", "</table>"],
-			tr: [2, "<table><tbody>", "</tbody></table>"],
-			col: [2, "<table><tbody></tbody><colgroup>", "</colgroup></table>"],
-			td: [3, "<table><tbody><tr>", "</tr></tbody></table>"],
-
-			// IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,
-			// unless wrapped in a div with non-breaking characters in front of it.
-			_default: jQuery.support.htmlSerialize ? [0, "", ""] : [1, "X<div>", "</div>"]
-		},
-		safeFragment = createSafeFragment(document),
-		fragmentDiv = safeFragment.appendChild(document.createElement("div"));
-
-	wrapMap.optgroup = wrapMap.option;
-	wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
-	wrapMap.th = wrapMap.td;
-
-	jQuery.fn.extend({
-		text: function (value) {
-			return jQuery.access(this, function (value) {
-				return value === undefined ?
-					jQuery.text(this) :
-					this.empty().append((this[0] && this[0].ownerDocument || document).createTextNode(value));
-			}, null, value, arguments.length);
-		},
-
-		append: function () {
-			return this.domManip(arguments, function (elem) {
-				if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
-					var target = manipulationTarget(this, elem);
-					target.appendChild(elem);
-				}
-			});
-		},
-
-		prepend: function () {
-			return this.domManip(arguments, function (elem) {
-				if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
-					var target = manipulationTarget(this, elem);
-					target.insertBefore(elem, target.firstChild);
-				}
-			});
-		},
-
-		before: function () {
-			return this.domManip(arguments, function (elem) {
-				if (this.parentNode) {
-					this.parentNode.insertBefore(elem, this);
-				}
-			});
-		},
-
-		after: function () {
-			return this.domManip(arguments, function (elem) {
-				if (this.parentNode) {
-					this.parentNode.insertBefore(elem, this.nextSibling);
-				}
-			});
-		},
-
-		// keepData is for internal use only--do not document
-		remove: function (selector, keepData) {
-			var elem,
-				elems = selector ? jQuery.filter(selector, this) : this,
-				i = 0;
-
-			for (;
-				(elem = elems[i]) != null; i++) {
-
-				if (!keepData && elem.nodeType === 1) {
-					jQuery.cleanData(getAll(elem));
-				}
-
-				if (elem.parentNode) {
-					if (keepData && jQuery.contains(elem.ownerDocument, elem)) {
-						setGlobalEval(getAll(elem, "script"));
-					}
-					elem.parentNode.removeChild(elem);
-				}
-			}
-
-			return this;
-		},
-
-		empty: function () {
-			var elem,
-				i = 0;
-
-			for (;
-				(elem = this[i]) != null; i++) {
-				// Remove element nodes and prevent memory leaks
-				if (elem.nodeType === 1) {
-					jQuery.cleanData(getAll(elem, false));
-				}
-
-				// Remove any remaining nodes
-				while (elem.firstChild) {
-					elem.removeChild(elem.firstChild);
-				}
-
-				// If this is a select, ensure that it displays empty (#12336)
-				// Support: IE<9
-				if (elem.options && jQuery.nodeName(elem, "select")) {
-					elem.options.length = 0;
-				}
-			}
-
-			return this;
-		},
-
-		clone: function (dataAndEvents, deepDataAndEvents) {
-			dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
-			deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
-
-			return this.map(function () {
-				return jQuery.clone(this, dataAndEvents, deepDataAndEvents);
-			});
-		},
-
-		html: function (value) {
-			return jQuery.access(this, function (value) {
-				var elem = this[0] || {},
-					i = 0,
-					l = this.length;
-
-				if (value === undefined) {
-					return elem.nodeType === 1 ?
-						elem.innerHTML.replace(rinlinejQuery, "") :
-						undefined;
-				}
-
-				// See if we can take a shortcut and just use innerHTML
-				if (typeof value === "string" && !rnoInnerhtml.test(value) &&
-					(jQuery.support.htmlSerialize || !rnoshimcache.test(value)) &&
-					(jQuery.support.leadingWhitespace || !rleadingWhitespace.test(value)) && !wrapMap[(rtagName.exec(value) || ["", ""])[1].toLowerCase()]) {
-
-					value = value.replace(rxhtmlTag, "<$1></$2>");
-
-					try {
-						for (; i < l; i++) {
-							// Remove element nodes and prevent memory leaks
-							elem = this[i] || {};
-							if (elem.nodeType === 1) {
-								jQuery.cleanData(getAll(elem, false));
-								elem.innerHTML = value;
-							}
-						}
-
-						elem = 0;
-
-						// If using innerHTML throws an exception, use the fallback method
-					} catch (e) {}
-				}
-
-				if (elem) {
-					this.empty().append(value);
-				}
-			}, null, value, arguments.length);
-		},
-
-		replaceWith: function () {
-			var
-			// Snapshot the DOM in case .domManip sweeps something relevant into its fragment
-			args = jQuery.map(this, function (elem) {
-				return [elem.nextSibling, elem.parentNode];
-			}),
-				i = 0;
-
-			// Make the changes, replacing each context element with the new content
-			this.domManip(arguments, function (elem) {
-				var next = args[i++],
-					parent = args[i++];
-
-				if (parent) {
-					// Don't use the snapshot next if it has moved (#13810)
-					if (next && next.parentNode !== parent) {
-						next = this.nextSibling;
-					}
-					jQuery(this).remove();
-					parent.insertBefore(elem, next);
-				}
-				// Allow new content to include elements from the context set
-			}, true);
-
-			// Force removal if there was no new content (e.g., from empty arguments)
-			return i ? this : this.remove();
-		},
-
-		detach: function (selector) {
-			return this.remove(selector, true);
-		},
-
-		domManip: function (args, callback, allowIntersection) {
-
-			// Flatten any nested arrays
-			args = core_concat.apply([], args);
-
-			var first, node, hasScripts,
-				scripts, doc, fragment,
-				i = 0,
-				l = this.length,
-				set = this,
-				iNoClone = l - 1,
-				value = args[0],
-				isFunction = jQuery.isFunction(value);
-
-			// We can't cloneNode fragments that contain checked, in WebKit
-			if (isFunction || !(l <= 1 || typeof value !== "string" || jQuery.support.checkClone || !rchecked.test(value))) {
-				return this.each(function (index) {
-					var self = set.eq(index);
-					if (isFunction) {
-						args[0] = value.call(this, index, self.html());
-					}
-					self.domManip(args, callback, allowIntersection);
-				});
-			}
-
-			if (l) {
-				fragment = jQuery.buildFragment(args, this[0].ownerDocument, false, !allowIntersection && this);
-				first = fragment.firstChild;
-
-				if (fragment.childNodes.length === 1) {
-					fragment = first;
-				}
-
-				if (first) {
-					scripts = jQuery.map(getAll(fragment, "script"), disableScript);
-					hasScripts = scripts.length;
-
-					// Use the original fragment for the last item instead of the first because it can end up
-					// being emptied incorrectly in certain situations (#8070).
-					for (; i < l; i++) {
-						node = fragment;
-
-						if (i !== iNoClone) {
-							node = jQuery.clone(node, true, true);
-
-							// Keep references to cloned scripts for later restoration
-							if (hasScripts) {
-								jQuery.merge(scripts, getAll(node, "script"));
-							}
-						}
-
-						callback.call(this[i], node, i);
-					}
-
-					if (hasScripts) {
-						doc = scripts[scripts.length - 1].ownerDocument;
-
-						// Reenable scripts
-						jQuery.map(scripts, restoreScript);
-
-						// Evaluate executable scripts on first document insertion
-						for (i = 0; i < hasScripts; i++) {
-							node = scripts[i];
-							if (rscriptType.test(node.type || "") && !jQuery._data(node, "globalEval") && jQuery.contains(doc, node)) {
-
-								if (node.src) {
-									// Hope ajax is available...
-									jQuery._evalUrl(node.src);
-								} else {
-									jQuery.globalEval((node.text || node.textContent || node.innerHTML || "").replace(rcleanScript, ""));
-								}
-							}
-						}
-					}
-
-					// Fix #11809: Avoid leaking memory
-					fragment = first = null;
-				}
-			}
-
-			return this;
-		}
-	});
-
-	// Support: IE<8
-	// Manipulating tables requires a tbody
-
-	function manipulationTarget(elem, content) {
-		return jQuery.nodeName(elem, "table") &&
-			jQuery.nodeName(content.nodeType === 1 ? content : content.firstChild, "tr") ?
-
-		elem.getElementsByTagName("tbody")[0] ||
-			elem.appendChild(elem.ownerDocument.createElement("tbody")) :
-			elem;
-	}
-
-	// Replace/restore the type attribute of script elements for safe DOM manipulation
-
-	function disableScript(elem) {
-		elem.type = (jQuery.find.attr(elem, "type") !== null) + "/" + elem.type;
-		return elem;
-	}
-
-	function restoreScript(elem) {
-		var match = rscriptTypeMasked.exec(elem.type);
-		if (match) {
-			elem.type = match[1];
-		} else {
-			elem.removeAttribute("type");
-		}
-		return elem;
-	}
-
-	// Mark scripts as having already been evaluated
-
-	function setGlobalEval(elems, refElements) {
-		var elem,
-			i = 0;
-		for (;
-			(elem = elems[i]) != null; i++) {
-			jQuery._data(elem, "globalEval", !refElements || jQuery._data(refElements[i], "globalEval"));
-		}
-	}
-
-	function cloneCopyEvent(src, dest) {
-
-		if (dest.nodeType !== 1 || !jQuery.hasData(src)) {
-			return;
-		}
-
-		var type, i, l,
-			oldData = jQuery._data(src),
-			curData = jQuery._data(dest, oldData),
-			events = oldData.events;
-
-		if (events) {
-			delete curData.handle;
-			curData.events = {};
-
-			for (type in events) {
-				for (i = 0, l = events[type].length; i < l; i++) {
-					jQuery.event.add(dest, type, events[type][i]);
-				}
-			}
-		}
-
-		// make the cloned public data object a copy from the original
-		if (curData.data) {
-			curData.data = jQuery.extend({}, curData.data);
-		}
-	}
-
-	function fixCloneNodeIssues(src, dest) {
-		var nodeName, e, data;
-
-		// We do not need to do anything for non-Elements
-		if (dest.nodeType !== 1) {
-			return;
-		}
-
-		nodeName = dest.nodeName.toLowerCase();
-
-		// IE6-8 copies events bound via attachEvent when using cloneNode.
-		if (!jQuery.support.noCloneEvent && dest[jQuery.expando]) {
-			data = jQuery._data(dest);
-
-			for (e in data.events) {
-				jQuery.removeEvent(dest, e, data.handle);
-			}
-
-			// Event data gets referenced instead of copied if the expando gets copied too
-			dest.removeAttribute(jQuery.expando);
-		}
-
-		// IE blanks contents when cloning scripts, and tries to evaluate newly-set text
-		if (nodeName === "script" && dest.text !== src.text) {
-			disableScript(dest).text = src.text;
-			restoreScript(dest);
-
-			// IE6-10 improperly clones children of object elements using classid.
-			// IE10 throws NoModificationAllowedError if parent is null, #12132.
-		} else if (nodeName === "object") {
-			if (dest.parentNode) {
-				dest.outerHTML = src.outerHTML;
-			}
-
-			// This path appears unavoidable for IE9. When cloning an object
-			// element in IE9, the outerHTML strategy above is not sufficient.
-			// If the src has innerHTML and the destination does not,
-			// copy the src.innerHTML into the dest.innerHTML. #10324
-			if (jQuery.support.html5Clone && (src.innerHTML && !jQuery.trim(dest.innerHTML))) {
-				dest.innerHTML = src.innerHTML;
-			}
-
-		} else if (nodeName === "input" && manipulation_rcheckableType.test(src.type)) {
-			// IE6-8 fails to persist the checked state of a cloned checkbox
-			// or radio button. Worse, IE6-7 fail to give the cloned element
-			// a checked appearance if the defaultChecked value isn't also set
-
-			dest.defaultChecked = dest.checked = src.checked;
-
-			// IE6-7 get confused and end up setting the value of a cloned
-			// checkbox/radio button to an empty string instead of "on"
-			if (dest.value !== src.value) {
-				dest.value = src.value;
-			}
-
-			// IE6-8 fails to return the selected option to the default selected
-			// state when cloning options
-		} else if (nodeName === "option") {
-			dest.defaultSelected = dest.selected = src.defaultSelected;
-
-			// IE6-8 fails to set the defaultValue to the correct value when
-			// cloning other types of input fields
-		} else if (nodeName === "input" || nodeName === "textarea") {
-			dest.defaultValue = src.defaultValue;
-		}
-	}
-
-	jQuery.each({
-		appendTo: "append",
-		prependTo: "prepend",
-		insertBefore: "before",
-		insertAfter: "after",
-		replaceAll: "replaceWith"
-	}, function (name, original) {
-		jQuery.fn[name] = function (selector) {
-			var elems,
-				i = 0,
-				ret = [],
-				insert = jQuery(selector),
-				last = insert.length - 1;
-
-			for (; i <= last; i++) {
-				elems = i === last ? this : this.clone(true);
-				jQuery(insert[i])[original](elems);
-
-				// Modern browsers can apply jQuery collections as arrays, but oldIE needs a .get()
-				core_push.apply(ret, elems.get());
-			}
-
-			return this.pushStack(ret);
-		};
-	});
-
-	function getAll(context, tag) {
-		var elems, elem,
-			i = 0,
-			found = typeof context.getElementsByTagName !== core_strundefined ? context.getElementsByTagName(tag || "*") :
-				typeof context.querySelectorAll !== core_strundefined ? context.querySelectorAll(tag || "*") :
-				undefined;
-
-		if (!found) {
-			for (found = [], elems = context.childNodes || context;
-				(elem = elems[i]) != null; i++) {
-				if (!tag || jQuery.nodeName(elem, tag)) {
-					found.push(elem);
-				} else {
-					jQuery.merge(found, getAll(elem, tag));
-				}
-			}
-		}
-
-		return tag === undefined || tag && jQuery.nodeName(context, tag) ?
-			jQuery.merge([context], found) :
-			found;
-	}
-
-	// Used in buildFragment, fixes the defaultChecked property
-
-	function fixDefaultChecked(elem) {
-		if (manipulation_rcheckableType.test(elem.type)) {
-			elem.defaultChecked = elem.checked;
-		}
-	}
-
-	jQuery.extend({
-		clone: function (elem, dataAndEvents, deepDataAndEvents) {
-			var destElements, node, clone, i, srcElements,
-				inPage = jQuery.contains(elem.ownerDocument, elem);
-
-			if (jQuery.support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test("<" + elem.nodeName + ">")) {
-				clone = elem.cloneNode(true);
-
-				// IE<=8 does not properly clone detached, unknown element nodes
-			} else {
-				fragmentDiv.innerHTML = elem.outerHTML;
-				fragmentDiv.removeChild(clone = fragmentDiv.firstChild);
-			}
-
-			if ((!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
-				(elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem)) {
-
-				// We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
-				destElements = getAll(clone);
-				srcElements = getAll(elem);
-
-				// Fix all IE cloning issues
-				for (i = 0;
-					(node = srcElements[i]) != null; ++i) {
-					// Ensure that the destination node is not null; Fixes #9587
-					if (destElements[i]) {
-						fixCloneNodeIssues(node, destElements[i]);
-					}
-				}
-			}
-
-			// Copy the events from the original to the clone
-			if (dataAndEvents) {
-				if (deepDataAndEvents) {
-					srcElements = srcElements || getAll(elem);
-					destElements = destElements || getAll(clone);
-
-					for (i = 0;
-						(node = srcElements[i]) != null; i++) {
-						cloneCopyEvent(node, destElements[i]);
-					}
-				} else {
-					cloneCopyEvent(elem, clone);
-				}
-			}
-
-			// Preserve script evaluation history
-			destElements = getAll(clone, "script");
-			if (destElements.length > 0) {
-				setGlobalEval(destElements, !inPage && getAll(elem, "script"));
-			}
-
-			destElements = srcElements = node = null;
-
-			// Return the cloned set
-			return clone;
-		},
-
-		buildFragment: function (elems, context, scripts, selection) {
-			var j, elem, contains,
-				tmp, tag, tbody, wrap,
-				l = elems.length,
-
-				// Ensure a safe fragment
-				safe = createSafeFragment(context),
-
-				nodes = [],
-				i = 0;
-
-			for (; i < l; i++) {
-				elem = elems[i];
-
-				if (elem || elem === 0) {
-
-					// Add nodes directly
-					if (jQuery.type(elem) === "object") {
-						jQuery.merge(nodes, elem.nodeType ? [elem] : elem);
-
-						// Convert non-html into a text node
-					} else if (!rhtml.test(elem)) {
-						nodes.push(context.createTextNode(elem));
-
-						// Convert html into DOM nodes
-					} else {
-						tmp = tmp || safe.appendChild(context.createElement("div"));
-
-						// Deserialize a standard representation
-						tag = (rtagName.exec(elem) || ["", ""])[1].toLowerCase();
-						wrap = wrapMap[tag] || wrapMap._default;
-
-						tmp.innerHTML = wrap[1] + elem.replace(rxhtmlTag, "<$1></$2>") + wrap[2];
-
-						// Descend through wrappers to the right content
-						j = wrap[0];
-						while (j--) {
-							tmp = tmp.lastChild;
-						}
-
-						// Manually add leading whitespace removed by IE
-						if (!jQuery.support.leadingWhitespace && rleadingWhitespace.test(elem)) {
-							nodes.push(context.createTextNode(rleadingWhitespace.exec(elem)[0]));
-						}
-
-						// Remove IE's autoinserted <tbody> from table fragments
-						if (!jQuery.support.tbody) {
-
-							// String was a <table>, *may* have spurious <tbody>
-							elem = tag === "table" && !rtbody.test(elem) ?
-								tmp.firstChild :
-
-							// String was a bare <thead> or <tfoot>
-							wrap[1] === "<table>" && !rtbody.test(elem) ?
-								tmp :
-								0;
-
-							j = elem && elem.childNodes.length;
-							while (j--) {
-								if (jQuery.nodeName((tbody = elem.childNodes[j]), "tbody") && !tbody.childNodes.length) {
-									elem.removeChild(tbody);
-								}
-							}
-						}
-
-						jQuery.merge(nodes, tmp.childNodes);
-
-						// Fix #12392 for WebKit and IE > 9
-						tmp.textContent = "";
-
-						// Fix #12392 for oldIE
-						while (tmp.firstChild) {
-							tmp.removeChild(tmp.firstChild);
-						}
-
-						// Remember the top-level container for proper cleanup
-						tmp = safe.lastChild;
-					}
-				}
-			}
-
-			// Fix #11356: Clear elements from fragment
-			if (tmp) {
-				safe.removeChild(tmp);
-			}
-
-			// Reset defaultChecked for any radios and checkboxes
-			// about to be appended to the DOM in IE 6/7 (#8060)
-			if (!jQuery.support.appendChecked) {
-				jQuery.grep(getAll(nodes, "input"), fixDefaultChecked);
-			}
-
-			i = 0;
-			while ((elem = nodes[i++])) {
-
-				// #4087 - If origin and destination elements are the same, and this is
-				// that element, do not do anything
-				if (selection && jQuery.inArray(elem, selection) !== -1) {
-					continue;
-				}
-
-				contains = jQuery.contains(elem.ownerDocument, elem);
-
-				// Append to fragment
-				tmp = getAll(safe.appendChild(elem), "script");
-
-				// Preserve script evaluation history
-				if (contains) {
-					setGlobalEval(tmp);
-				}
-
-				// Capture executables
-				if (scripts) {
-					j = 0;
-					while ((elem = tmp[j++])) {
-						if (rscriptType.test(elem.type || "")) {
-							scripts.push(elem);
-						}
-					}
-				}
-			}
-
-			tmp = null;
-
-			return safe;
-		},
-
-		cleanData: function (elems, /* internal */ acceptData) {
-			var elem, type, id, data,
-				i = 0,
-				internalKey = jQuery.expando,
-				cache = jQuery.cache,
-				deleteExpando = jQuery.support.deleteExpando,
-				special = jQuery.event.special;
-
-			for (;
-				(elem = elems[i]) != null; i++) {
-
-				if (acceptData || jQuery.acceptData(elem)) {
-
-					id = elem[internalKey];
-					data = id && cache[id];
-
-					if (data) {
-						if (data.events) {
-							for (type in data.events) {
-								if (special[type]) {
-									jQuery.event.remove(elem, type);
-
-									// This is a shortcut to avoid jQuery.event.remove's overhead
-								} else {
-									jQuery.removeEvent(elem, type, data.handle);
-								}
-							}
-						}
-
-						// Remove cache only if it was not already removed by jQuery.event.remove
-						if (cache[id]) {
-
-							delete cache[id];
-
-							// IE does not allow us to delete expando properties from nodes,
-							// nor does it have a removeAttribute function on Document nodes;
-							// we must handle all of these cases
-							if (deleteExpando) {
-								delete elem[internalKey];
-
-							} else if (typeof elem.removeAttribute !== core_strundefined) {
-								elem.removeAttribute(internalKey);
-
-							} else {
-								elem[internalKey] = null;
-							}
-
-							core_deletedIds.push(id);
-						}
-					}
-				}
-			}
-		},
-
-		_evalUrl: function (url) {
-			return jQuery.ajax({
-				url: url,
-				type: "GET",
-				dataType: "script",
-				async: false,
-				global: false,
-				"throws": true
-			});
-		}
-	});
-	jQuery.fn.extend({
-		wrapAll: function (html) {
-			if (jQuery.isFunction(html)) {
-				return this.each(function (i) {
-					jQuery(this).wrapAll(html.call(this, i));
-				});
-			}
-
-			if (this[0]) {
-				// The elements to wrap the target around
-				var wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(true);
-
-				if (this[0].parentNode) {
-					wrap.insertBefore(this[0]);
-				}
-
-				wrap.map(function () {
-					var elem = this;
-
-					while (elem.firstChild && elem.firstChild.nodeType === 1) {
-						elem = elem.firstChild;
-					}
-
-					return elem;
-				}).append(this);
-			}
-
-			return this;
-		},
-
-		wrapInner: function (html) {
-			if (jQuery.isFunction(html)) {
-				return this.each(function (i) {
-					jQuery(this).wrapInner(html.call(this, i));
-				});
-			}
-
-			return this.each(function () {
-				var self = jQuery(this),
-					contents = self.contents();
-
-				if (contents.length) {
-					contents.wrapAll(html);
-
-				} else {
-					self.append(html);
-				}
-			});
-		},
-
-		wrap: function (html) {
-			var isFunction = jQuery.isFunction(html);
-
-			return this.each(function (i) {
-				jQuery(this).wrapAll(isFunction ? html.call(this, i) : html);
-			});
-		},
-
-		unwrap: function () {
-			return this.parent().each(function () {
-				if (!jQuery.nodeName(this, "body")) {
-					jQuery(this).replaceWith(this.childNodes);
-				}
-			}).end();
-		}
-	});
-	var iframe, getStyles, curCSS,
-		ralpha = /alpha\([^)]*\)/i,
-		ropacity = /opacity\s*=\s*([^)]*)/,
-		rposition = /^(top|right|bottom|left)$/,
-		// swappable if display is none or starts with table except "table", "table-cell", or "table-caption"
-		// see here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
-		rdisplayswap = /^(none|table(?!-c[ea]).+)/,
-		rmargin = /^margin/,
-		rnumsplit = new RegExp("^(" + core_pnum + ")(.*)$", "i"),
-		rnumnonpx = new RegExp("^(" + core_pnum + ")(?!px)[a-z%]+$", "i"),
-		rrelNum = new RegExp("^([+-])=(" + core_pnum + ")", "i"),
-		elemdisplay = {
-			BODY: "block"
-		},
-
-		cssShow = {
-			position: "absolute",
-			visibility: "hidden",
-			display: "block"
-		},
-		cssNormalTransform = {
-			letterSpacing: 0,
-			fontWeight: 400
-		},
-
-		cssExpand = ["Top", "Right", "Bottom", "Left"],
-		cssPrefixes = ["Webkit", "O", "Moz", "ms"];
-
-	// return a css property mapped to a potentially vendor prefixed property
-
-	function vendorPropName(style, name) {
-
-		// shortcut for names that are not vendor prefixed
-		if (name in style) {
-			return name;
-		}
-
-		// check for vendor prefixed names
-		var capName = name.charAt(0).toUpperCase() + name.slice(1),
-			origName = name,
-			i = cssPrefixes.length;
-
-		while (i--) {
-			name = cssPrefixes[i] + capName;
-			if (name in style) {
-				return name;
-			}
-		}
-
-		return origName;
-	}
-
-	function isHidden(elem, el) {
-		// isHidden might be called from jQuery#filter function;
-		// in that case, element will be second argument
-		elem = el || elem;
-		return jQuery.css(elem, "display") === "none" || !jQuery.contains(elem.ownerDocument, elem);
-	}
-
-	function showHide(elements, show) {
-		var display, elem, hidden,
-			values = [],
-			index = 0,
-			length = elements.length;
-
-		for (; index < length; index++) {
-			elem = elements[index];
-			if (!elem.style) {
-				continue;
-			}
-
-			values[index] = jQuery._data(elem, "olddisplay");
-			display = elem.style.display;
-			if (show) {
-				// Reset the inline display of this element to learn if it is
-				// being hidden by cascaded rules or not
-				if (!values[index] && display === "none") {
-					elem.style.display = "";
-				}
-
-				// Set elements which have been overridden with display: none
-				// in a stylesheet to whatever the default browser style is
-				// for such an element
-				if (elem.style.display === "" && isHidden(elem)) {
-					values[index] = jQuery._data(elem, "olddisplay", css_defaultDisplay(elem.nodeName));
-				}
-			} else {
-
-				if (!values[index]) {
-					hidden = isHidden(elem);
-
-					if (display && display !== "none" || !hidden) {
-						jQuery._data(elem, "olddisplay", hidden ? display : jQuery.css(elem, "display"));
-					}
-				}
-			}
-		}
-
-		// Set the display of most of the elements in a second loop
-		// to avoid the constant reflow
-		for (index = 0; index < length; index++) {
-			elem = elements[index];
-			if (!elem.style) {
-				continue;
-			}
-			if (!show || elem.style.display === "none" || elem.style.display === "") {
-				elem.style.display = show ? values[index] || "" : "none";
-			}
-		}
-
-		return elements;
-	}
-
-	jQuery.fn.extend({
-		css: function (name, value) {
-			return jQuery.access(this, function (elem, name, value) {
-				var len, styles,
-					map = {},
-					i = 0;
-
-				if (jQuery.isArray(name)) {
-					styles = getStyles(elem);
-					len = name.length;
-
-					for (; i < len; i++) {
-						map[name[i]] = jQuery.css(elem, name[i], false, styles);
-					}
-
-					return map;
-				}
-
-				return value !== undefined ?
-					jQuery.style(elem, name, value) :
-					jQuery.css(elem, name);
-			}, name, value, arguments.length > 1);
-		},
-		show: function () {
-			return showHide(this, true);
-		},
-		hide: function () {
-			return showHide(this);
-		},
-		toggle: function (state) {
-			if (typeof state === "boolean") {
-				return state ? this.show() : this.hide();
-			}
-
-			return this.each(function () {
-				if (isHidden(this)) {
-					jQuery(this).show();
-				} else {
-					jQuery(this).hide();
-				}
-			});
-		}
-	});
-
-	jQuery.extend({
-		// Add in style property hooks for overriding the default
-		// behavior of getting and setting a style property
-		cssHooks: {
-			opacity: {
-				get: function (elem, computed) {
-					if (computed) {
-						// We should always get a number back from opacity
-						var ret = curCSS(elem, "opacity");
-						return ret === "" ? "1" : ret;
-					}
-				}
-			}
-		},
-
-		// Don't automatically add "px" to these possibly-unitless properties
-		cssNumber: {
-			"columnCount": true,
-			"fillOpacity": true,
-			"fontWeight": true,
-			"lineHeight": true,
-			"opacity": true,
-			"order": true,
-			"orphans": true,
-			"widows": true,
-			"zIndex": true,
-			"zoom": true
-		},
-
-		// Add in properties whose names you wish to fix before
-		// setting or getting the value
-		cssProps: {
-			// normalize float css property
-			"float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
-		},
-
-		// Get and set the style property on a DOM Node
-		style: function (elem, name, value, extra) {
-			// Don't set styles on text and comment nodes
-			if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) {
-				return;
-			}
-
-			// Make sure that we're working with the right name
-			var ret, type, hooks,
-				origName = jQuery.camelCase(name),
-				style = elem.style;
-
-			name = jQuery.cssProps[origName] || (jQuery.cssProps[origName] = vendorPropName(style, origName));
-
-			// gets hook for the prefixed version
-			// followed by the unprefixed version
-			hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];
-
-			// Check if we're setting a value
-			if (value !== undefined) {
-				type = typeof value;
-
-				// convert relative number strings (+= or -=) to relative numbers. #7345
-				if (type === "string" && (ret = rrelNum.exec(value))) {
-					value = (ret[1] + 1) * ret[2] + parseFloat(jQuery.css(elem, name));
-					// Fixes bug #9237
-					type = "number";
-				}
-
-				// Make sure that NaN and null values aren't set. See: #7116
-				if (value == null || type === "number" && isNaN(value)) {
-					return;
-				}
-
-				// If a number was passed in, add 'px' to the (except for certain CSS properties)
-				if (type === "number" && !jQuery.cssNumber[origName]) {
-					value += "px";
-				}
-
-				// Fixes #8908, it can be done more correctly by specifing setters in cssHooks,
-				// but it would mean to define eight (for every problematic property) identical functions
-				if (!jQuery.support.clearCloneStyle && value === "" && name.indexOf("background") === 0) {
-					style[name] = "inherit";
-				}
-
-				// If a hook was provided, use that value, otherwise just set the specified value
-				if (!hooks || !("set" in hooks) || (value = hooks.set(elem, value, extra)) !== undefined) {
-
-					// Wrapped to prevent IE from throwing errors when 'invalid' values are provided
-					// Fixes bug #5509
-					try {
-						style[name] = value;
-					} catch (e) {}
-				}
-
-			} else {
-				// If a hook was provided get the non-computed value from there
-				if (hooks && "get" in hooks && (ret = hooks.get(elem, false, extra)) !== undefined) {
-					return ret;
-				}
-
-				// Otherwise just get the value from the style object
-				return style[name];
-			}
-		},
-
-		css: function (elem, name, extra, styles) {
-			var num, val, hooks,
-				origName = jQuery.camelCase(name);
-
-			// Make sure that we're working with the right name
-			name = jQuery.cssProps[origName] || (jQuery.cssProps[origName] = vendorPropName(elem.style, origName));
-
-			// gets hook for the prefixed version
-			// followed by the unprefixed version
-			hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];
-
-			// If a hook was provided get the computed value from there
-			if (hooks && "get" in hooks) {
-				val = hooks.get(elem, true, extra);
-			}
-
-			// Otherwise, if a way to get the computed value exists, use that
-			if (val === undefined) {
-				val = curCSS(elem, name, styles);
-			}
-
-			//convert "normal" to computed value
-			if (val === "normal" && name in cssNormalTransform) {
-				val = cssNormalTransform[name];
-			}
-
-			// Return, converting to number if forced or a qualifier was provided and val looks numeric
-			if (extra === "" || extra) {
-				num = parseFloat(val);
-				return extra === true || jQuery.isNumeric(num) ? num || 0 : val;
-			}
-			return val;
-		}
-	});
-
-	// NOTE: we've included the "window" in window.getComputedStyle
-	// because jsdom on node.js will break without it.
-	if (window.getComputedStyle) {
-		getStyles = function (elem) {
-			return window.getComputedStyle(elem, null);
-		};
-
-		curCSS = function (elem, name, _computed) {
-			var width, minWidth, maxWidth,
-				computed = _computed || getStyles(elem),
-
-				// getPropertyValue is only needed for .css('filter') in IE9, see #12537
-				ret = computed ? computed.getPropertyValue(name) || computed[name] : undefined,
-				style = elem.style;
-
-			if (computed) {
-
-				if (ret === "" && !jQuery.contains(elem.ownerDocument, elem)) {
-					ret = jQuery.style(elem, name);
-				}
-
-				// A tribute to the "awesome hack by Dean Edwards"
-				// Chrome < 17 and Safari 5.0 uses "computed value" instead of "used value" for margin-right
-				// Safari 5.1.7 (at least) returns percentage for a larger set of values, but width seems to be reliably pixels
-				// this is against the CSSOM draft spec: http://dev.w3.org/csswg/cssom/#resolved-values
-				if (rnumnonpx.test(ret) && rmargin.test(name)) {
-
-					// Remember the original values
-					width = style.width;
-					minWidth = style.minWidth;
-					maxWidth = style.maxWidth;
-
-					// Put in the new values to get a computed value out
-					style.minWidth = style.maxWidth = style.width = ret;
-					ret = computed.width;
-
-					// Revert the changed values
-					style.width = width;
-					style.minWidth = minWidth;
-					style.maxWidth = maxWidth;
-				}
-			}
-
-			return ret;
-		};
-	} else if (document.documentElement.currentStyle) {
-		getStyles = function (elem) {
-			return elem.currentStyle;
-		};
-
-		curCSS = function (elem, name, _computed) {
-			var left, rs, rsLeft,
-				computed = _computed || getStyles(elem),
-				ret = computed ? computed[name] : undefined,
-				style = elem.style;
-
-			// Avoid setting ret to empty string here
-			// so we don't default to auto
-			if (ret == null && style && style[name]) {
-				ret = style[name];
-			}
-
-			// From the awesome hack by Dean Edwards
-			// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
-
-			// If we're not dealing with a regular pixel number
-			// but a number that has a weird ending, we need to convert it to pixels
-			// but not position css attributes, as those are proportional to the parent element instead
-			// and we can't measure the parent instead because it might trigger a "stacking dolls" problem
-			if (rnumnonpx.test(ret) && !rposition.test(name)) {
-
-				// Remember the original values
-				left = style.left;
-				rs = elem.runtimeStyle;
-				rsLeft = rs && rs.left;
-
-				// Put in the new values to get a computed value out
-				if (rsLeft) {
-					rs.left = elem.currentStyle.left;
-				}
-				style.left = name === "fontSize" ? "1em" : ret;
-				ret = style.pixelLeft + "px";
-
-				// Revert the changed values
-				style.left = left;
-				if (rsLeft) {
-					rs.left = rsLeft;
-				}
-			}
-
-			return ret === "" ? "auto" : ret;
-		};
-	}
-
-	function setPositiveNumber(elem, value, subtract) {
-		var matches = rnumsplit.exec(value);
-		return matches ?
-		// Guard against undefined "subtract", e.g., when used as in cssHooks
-		Math.max(0, matches[1] - (subtract || 0)) + (matches[2] || "px") :
-			value;
-	}
-
-	function augmentWidthOrHeight(elem, name, extra, isBorderBox, styles) {
-		var i = extra === (isBorderBox ? "border" : "content") ?
-		// If we already have the right measurement, avoid augmentation
-		4 :
-		// Otherwise initialize for horizontal or vertical properties
-		name === "width" ? 1 : 0,
-
-			val = 0;
-
-		for (; i < 4; i += 2) {
-			// both box models exclude margin, so add it if we want it
-			if (extra === "margin") {
-				val += jQuery.css(elem, extra + cssExpand[i], true, styles);
-			}
-
-			if (isBorderBox) {
-				// border-box includes padding, so remove it if we want content
-				if (extra === "content") {
-					val -= jQuery.css(elem, "padding" + cssExpand[i], true, styles);
-				}
-
-				// at this point, extra isn't border nor margin, so remove border
-				if (extra !== "margin") {
-					val -= jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
-				}
-			} else {
-				// at this point, extra isn't content, so add padding
-				val += jQuery.css(elem, "padding" + cssExpand[i], true, styles);
-
-				// at this point, extra isn't content nor padding, so add border
-				if (extra !== "padding") {
-					val += jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
-				}
-			}
-		}
-
-		return val;
-	}
-
-	function getWidthOrHeight(elem, name, extra) {
-
-		// Start with offset property, which is equivalent to the border-box value
-		var valueIsBorderBox = true,
-			val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
-			styles = getStyles(elem),
-			isBorderBox = jQuery.support.boxSizing && jQuery.css(elem, "boxSizing", false, styles) === "border-box";
-
-		// some non-html elements return undefined for offsetWidth, so check for null/undefined
-		// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
-		// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
-		if (val <= 0 || val == null) {
-			// Fall back to computed then uncomputed css if necessary
-			val = curCSS(elem, name, styles);
-			if (val < 0 || val == null) {
-				val = elem.style[name];
-			}
-
-			// Computed unit is not pixels. Stop here and return.
-			if (rnumnonpx.test(val)) {
-				return val;
-			}
-
-			// we need the check for style in case a browser which returns unreliable values
-			// for getComputedStyle silently falls back to the reliable elem.style
-			valueIsBorderBox = isBorderBox && (jQuery.support.boxSizingReliable || val === elem.style[name]);
-
-			// Normalize "", auto, and prepare for extra
-			val = parseFloat(val) || 0;
-		}
-
-		// use the active box-sizing model to add/subtract irrelevant styles
-		return (val +
-			augmentWidthOrHeight(
-				elem,
-				name,
-				extra || (isBorderBox ? "border" : "content"),
-				valueIsBorderBox,
-				styles
-			)
-		) + "px";
-	}
-
-	// Try to determine the default display value of an element
-
-	function css_defaultDisplay(nodeName) {
-		var doc = document,
-			display = elemdisplay[nodeName];
-
-		if (!display) {
-			display = actualDisplay(nodeName, doc);
-
-			// If the simple way fails, read from inside an iframe
-			if (display === "none" || !display) {
-				// Use the already-created iframe if possible
-				iframe = (iframe ||
-					jQuery("<iframe frameborder='0' width='0' height='0'/>")
-					.css("cssText", "display:block !important")
-				).appendTo(doc.documentElement);
-
-				// Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
-				doc = (iframe[0].contentWindow || iframe[0].contentDocument).document;
-				doc.write("<!doctype html><html><body>");
-				doc.close();
-
-				display = actualDisplay(nodeName, doc);
-				iframe.detach();
-			}
-
-			// Store the correct default display
-			elemdisplay[nodeName] = display;
-		}
-
-		return display;
-	}
-
-	// Called ONLY from within css_defaultDisplay
-
-	function actualDisplay(name, doc) {
-		var elem = jQuery(doc.createElement(name)).appendTo(doc.body),
-			display = jQuery.css(elem[0], "display");
-		elem.remove();
-		return display;
-	}
-
-	jQuery.each(["height", "width"], function (i, name) {
-		jQuery.cssHooks[name] = {
-			get: function (elem, computed, extra) {
-				if (computed) {
-					// certain elements can have dimension info if we invisibly show them
-					// however, it must have a current display style that would benefit from this
-					return elem.offsetWidth === 0 && rdisplayswap.test(jQuery.css(elem, "display")) ?
-						jQuery.swap(elem, cssShow, function () {
-							return getWidthOrHeight(elem, name, extra);
-						}) :
-						getWidthOrHeight(elem, name, extra);
-				}
-			},
-
-			set: function (elem, value, extra) {
-				var styles = extra && getStyles(elem);
-				return setPositiveNumber(elem, value, extra ?
-					augmentWidthOrHeight(
-						elem,
-						name,
-						extra,
-						jQuery.support.boxSizing && jQuery.css(elem, "boxSizing", false, styles) === "border-box",
-						styles
-					) : 0
-				);
-			}
-		};
-	});
-
-	if (!jQuery.support.opacity) {
-		jQuery.cssHooks.opacity = {
-			get: function (elem, computed) {
-				// IE uses filters for opacity
-				return ropacity.test((computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "") ?
-					(0.01 * parseFloat(RegExp.$1)) + "" :
-					computed ? "1" : "";
-			},
-
-			set: function (elem, value) {
-				var style = elem.style,
-					currentStyle = elem.currentStyle,
-					opacity = jQuery.isNumeric(value) ? "alpha(opacity=" + value * 100 + ")" : "",
-					filter = currentStyle && currentStyle.filter || style.filter || "";
-
-				// IE has trouble with opacity if it does not have layout
-				// Force it by setting the zoom level
-				style.zoom = 1;
-
-				// if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
-				// if value === "", then remove inline opacity #12685
-				if ((value >= 1 || value === "") &&
-					jQuery.trim(filter.replace(ralpha, "")) === "" &&
-					style.removeAttribute) {
-
-					// Setting style.filter to null, "" & " " still leave "filter:" in the cssText
-					// if "filter:" is present at all, clearType is disabled, we want to avoid this
-					// style.removeAttribute is IE Only, but so apparently is this code path...
-					style.removeAttribute("filter");
-
-					// if there is no filter style applied in a css rule or unset inline opacity, we are done
-					if (value === "" || currentStyle && !currentStyle.filter) {
-						return;
-					}
-				}
-
-				// otherwise, set new filter values
-				style.filter = ralpha.test(filter) ?
-					filter.replace(ralpha, opacity) :
-					filter + " " + opacity;
-			}
-		};
-	}
-
-	// These hooks cannot be added until DOM ready because the support test
-	// for it is not run until after DOM ready
-	jQuery(function () {
-		if (!jQuery.support.reliableMarginRight) {
-			jQuery.cssHooks.marginRight = {
-				get: function (elem, computed) {
-					if (computed) {
-						// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
-						// Work around by temporarily setting element display to inline-block
-						return jQuery.swap(elem, {
-								"display": "inline-block"
-							},
-							curCSS, [elem, "marginRight"]);
-					}
-				}
-			};
-		}
-
-		// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
-		// getComputedStyle returns percent when specified for top/left/bottom/right
-		// rather than make the css module depend on the offset module, we just check for it here
-		if (!jQuery.support.pixelPosition && jQuery.fn.position) {
-			jQuery.each(["top", "left"], function (i, prop) {
-				jQuery.cssHooks[prop] = {
-					get: function (elem, computed) {
-						if (computed) {
-							computed = curCSS(elem, prop);
-							// if curCSS returns percentage, fallback to offset
-							return rnumnonpx.test(computed) ?
-								jQuery(elem).position()[prop] + "px" :
-								computed;
-						}
-					}
-				};
-			});
-		}
-
-	});
-
-	if (jQuery.expr && jQuery.expr.filters) {
-		jQuery.expr.filters.hidden = function (elem) {
-			// Support: Opera <= 12.12
-			// Opera reports offsetWidths and offsetHeights less than zero on some elements
-			return elem.offsetWidth <= 0 && elem.offsetHeight <= 0 ||
-				(!jQuery.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || jQuery.css(elem, "display")) === "none");
-		};
-
-		jQuery.expr.filters.visible = function (elem) {
-			return !jQuery.expr.filters.hidden(elem);
-		};
-	}
-
-	// These hooks are used by animate to expand properties
-	jQuery.each({
-		margin: "",
-		padding: "",
-		border: "Width"
-	}, function (prefix, suffix) {
-		jQuery.cssHooks[prefix + suffix] = {
-			expand: function (value) {
-				var i = 0,
-					expanded = {},
-
-					// assumes a single number if not a string
-					parts = typeof value === "string" ? value.split(" ") : [value];
-
-				for (; i < 4; i++) {
-					expanded[prefix + cssExpand[i] + suffix] =
-						parts[i] || parts[i - 2] || parts[0];
-				}
-
-				return expanded;
-			}
-		};
-
-		if (!rmargin.test(prefix)) {
-			jQuery.cssHooks[prefix + suffix].set = setPositiveNumber;
-		}
-	});
-	var r20 = /%20/g,
-		rbracket = /\[\]$/,
-		rCRLF = /\r?\n/g,
-		rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
-		rsubmittable = /^(?:input|select|textarea|keygen)/i;
-
-	jQuery.fn.extend({
-		serialize: function () {
-			return jQuery.param(this.serializeArray());
-		},
-		serializeArray: function () {
-			return this.map(function () {
-				// Can add propHook for "elements" to filter or add form elements
-				var elements = jQuery.prop(this, "elements");
-				return elements ? jQuery.makeArray(elements) : this;
-			})
-				.filter(function () {
-					var type = this.type;
-					// Use .is(":disabled") so that fieldset[disabled] works
-					return this.name && !jQuery(this).is(":disabled") &&
-						rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) &&
-						(this.checked || !manipulation_rcheckableType.test(type));
-				})
-				.map(function (i, elem) {
-					var val = jQuery(this).val();
-
-					return val == null ?
-						null :
-						jQuery.isArray(val) ?
-						jQuery.map(val, function (val) {
-							return {
-								name: elem.name,
-								value: val.replace(rCRLF, "\r\n")
-							};
-						}) : {
-							name: elem.name,
-							value: val.replace(rCRLF, "\r\n")
-					};
-				}).get();
-		}
-	});
-
-	//Serialize an array of form elements or a set of
-	//key/values into a query string
-	jQuery.param = function (a, traditional) {
-		var prefix,
-			s = [],
-			add = function (key, value) {
-				// If value is a function, invoke it and return its value
-				value = jQuery.isFunction(value) ? value() : (value == null ? "" : value);
-				s[s.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
-			};
-
-		// Set traditional to true for jQuery <= 1.3.2 behavior.
-		if (traditional === undefined) {
-			traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;
-		}
-
-		// If an array was passed in, assume that it is an array of form elements.
-		if (jQuery.isArray(a) || (a.jquery && !jQuery.isPlainObject(a))) {
-			// Serialize the form elements
-			jQuery.each(a, function () {
-				add(this.name, this.value);
-			});
-
-		} else {
-			// If traditional, encode the "old" way (the way 1.3.2 or older
-			// did it), otherwise encode params recursively.
-			for (prefix in a) {
-				buildParams(prefix, a[prefix], traditional, add);
-			}
-		}
-
-		// Return the resulting serialization
-		return s.join("&").replace(r20, "+");
-	};
-
-	function buildParams(prefix, obj, traditional, add) {
-		var name;
-
-		if (jQuery.isArray(obj)) {
-			// Serialize array item.
-			jQuery.each(obj, function (i, v) {
-				if (traditional || rbracket.test(prefix)) {
-					// Treat each array item as a scalar.
-					add(prefix, v);
-
-				} else {
-					// Item is non-scalar (array or object), encode its numeric index.
-					buildParams(prefix + "[" + (typeof v === "object" ? i : "") + "]", v, traditional, add);
-				}
-			});
-
-		} else if (!traditional && jQuery.type(obj) === "object") {
-			// Serialize object item.
-			for (name in obj) {
-				buildParams(prefix + "[" + name + "]", obj[name], traditional, add);
-			}
-
-		} else {
-			// Serialize scalar item.
-			add(prefix, obj);
-		}
-	}
-	jQuery.each(("blur focus focusin focusout load resize scroll unload click dblclick " +
-		"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
-		"change select submit keydown keypress keyup error contextmenu").split(" "), function (i, name) {
-
-		// Handle event binding
-		jQuery.fn[name] = function (data, fn) {
-			return arguments.length > 0 ?
-				this.on(name, null, data, fn) :
-				this.trigger(name);
-		};
-	});
-
-	jQuery.fn.extend({
-		hover: function (fnOver, fnOut) {
-			return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);
-		},
-
-		bind: function (types, data, fn) {
-			return this.on(types, null, data, fn);
-		},
-		unbind: function (types, fn) {
-			return this.off(types, null, fn);
-		},
-
-		delegate: function (selector, types, data, fn) {
-			return this.on(types, selector, data, fn);
-		},
-		undelegate: function (selector, types, fn) {
-			// ( namespace ) or ( selector, types [, fn] )
-			return arguments.length === 1 ? this.off(selector, "**") : this.off(types, selector || "**", fn);
-		}
-	});
-	var
-	// Document location
-	ajaxLocParts,
-		ajaxLocation,
-		ajax_nonce = jQuery.now(),
-
-		ajax_rquery = /\?/,
-		rhash = /#.*$/,
-		rts = /([?&])_=[^&]*/,
-		rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
-		// #7653, #8125, #8152: local protocol detection
-		rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
-		rnoContent = /^(?:GET|HEAD)$/,
-		rprotocol = /^\/\//,
-		rurl = /^([\w.+-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/,
-
-		// Keep a copy of the old load method
-		_load = jQuery.fn.load,
-
-		/* Prefilters
-		 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
-		 * 2) These are called:
-		 *    - BEFORE asking for a transport
-		 *    - AFTER param serialization (s.data is a string if s.processData is true)
-		 * 3) key is the dataType
-		 * 4) the catchall symbol "*" can be used
-		 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
-		 */
-		prefilters = {},
-
-		/* Transports bindings
-		 * 1) key is the dataType
-		 * 2) the catchall symbol "*" can be used
-		 * 3) selection will start with transport dataType and THEN go to "*" if needed
-		 */
-		transports = {},
-
-		// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
-		allTypes = "*/".concat("*");
-
-	// #8138, IE may throw an exception when accessing
-	// a field from window.location if document.domain has been set
-	try {
-		ajaxLocation = location.href;
-	} catch (e) {
-		// Use the href attribute of an A element
-		// since IE will modify it given document.location
-		ajaxLocation = document.createElement("a");
-		ajaxLocation.href = "";
-		ajaxLocation = ajaxLocation.href;
-	}
-
-	// Segment location into parts
-	ajaxLocParts = rurl.exec(ajaxLocation.toLowerCase()) || [];
-
-	// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
-
-	function addToPrefiltersOrTransports(structure) {
-
-		// dataTypeExpression is optional and defaults to "*"
-		return function (dataTypeExpression, func) {
-
-			if (typeof dataTypeExpression !== "string") {
-				func = dataTypeExpression;
-				dataTypeExpression = "*";
-			}
-
-			var dataType,
-				i = 0,
-				dataTypes = dataTypeExpression.toLowerCase().match(core_rnotwhite) || [];
-
-			if (jQuery.isFunction(func)) {
-				// For each dataType in the dataTypeExpression
-				while ((dataType = dataTypes[i++])) {
-					// Prepend if requested
-					if (dataType[0] === "+") {
-						dataType = dataType.slice(1) || "*";
-						(structure[dataType] = structure[dataType] || []).unshift(func);
-
-						// Otherwise append
-					} else {
-						(structure[dataType] = structure[dataType] || []).push(func);
-					}
-				}
-			}
-		};
-	}
-
-	// Base inspection function for prefilters and transports
-
-	function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {
-
-		var inspected = {},
-			seekingTransport = (structure === transports);
-
-		function inspect(dataType) {
-			var selected;
-			inspected[dataType] = true;
-			jQuery.each(structure[dataType] || [], function (_, prefilterOrFactory) {
-				var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR);
-				if (typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[dataTypeOrTransport]) {
-					options.dataTypes.unshift(dataTypeOrTransport);
-					inspect(dataTypeOrTransport);
-					return false;
-				} else if (seekingTransport) {
-					return !(selected = dataTypeOrTransport);
-				}
-			});
-			return selected;
-		}
-
-		return inspect(options.dataTypes[0]) || !inspected["*"] && inspect("*");
-	}
-
-	// A special extend for ajax options
-	// that takes "flat" options (not to be deep extended)
-	// Fixes #9887
-
-	function ajaxExtend(target, src) {
-		var deep, key,
-			flatOptions = jQuery.ajaxSettings.flatOptions || {};
-
-		for (key in src) {
-			if (src[key] !== undefined) {
-				(flatOptions[key] ? target : (deep || (deep = {})))[key] = src[key];
-			}
-		}
-		if (deep) {
-			jQuery.extend(true, target, deep);
-		}
-
-		return target;
-	}
-
-	jQuery.fn.load = function (url, params, callback) {
-		if (typeof url !== "string" && _load) {
-			return _load.apply(this, arguments);
-		}
-
-		var selector, response, type,
-			self = this,
-			off = url.indexOf(" ");
-
-		if (off >= 0) {
-			selector = url.slice(off, url.length);
-			url = url.slice(0, off);
-		}
-
-		// If it's a function
-		if (jQuery.isFunction(params)) {
-
-			// We assume that it's the callback
-			callback = params;
-			params = undefined;
-
-			// Otherwise, build a param string
-		} else if (params && typeof params === "object") {
-			type = "POST";
-		}
-
-		// If we have elements to modify, make the request
-		if (self.length > 0) {
-			jQuery.ajax({
-				url: url,
-
-				// if "type" variable is undefined, then "GET" method will be used
-				type: type,
-				dataType: "html",
-				data: params
-			}).done(function (responseText) {
-
-				// Save response for use in complete callback
-				response = arguments;
-
-				self.html(selector ?
-
-					// If a selector was specified, locate the right elements in a dummy div
-					// Exclude scripts to avoid IE 'Permission Denied' errors
-					jQuery("<div>").append(jQuery.parseHTML(responseText)).find(selector) :
-
-					// Otherwise use the full result
-					responseText);
-
-			}).complete(callback && function (jqXHR, status) {
-				self.each(callback, response || [jqXHR.responseText, status, jqXHR]);
-			});
-		}
-
-		return this;
-	};
-
-	// Attach a bunch of functions for handling common AJAX events
-	jQuery.each(["ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend"], function (i, type) {
-		jQuery.fn[type] = function (fn) {
-			return this.on(type, fn);
-		};
-	});
-
-	jQuery.extend({
-
-		// Counter for holding the number of active queries
-		active: 0,
-
-		// Last-Modified header cache for next request
-		lastModified: {},
-		etag: {},
-
-		ajaxSettings: {
-			url: ajaxLocation,
-			type: "GET",
-			isLocal: rlocalProtocol.test(ajaxLocParts[1]),
-			global: true,
-			processData: true,
-			async: true,
-			contentType: "application/x-www-form-urlencoded; charset=UTF-8",
-			/*
-		timeout: 0,
-		data: null,
-		dataType: null,
-		username: null,
-		password: null,
-		cache: null,
-		throws: false,
-		traditional: false,
-		headers: {},
-		*/
-
-			accepts: {
-				"*": allTypes,
-				text: "text/plain",
-				html: "text/html",
-				xml: "application/xml, text/xml",
-				json: "application/json, text/javascript"
-			},
-
-			contents: {
-				xml: /xml/,
-				html: /html/,
-				json: /json/
-			},
-
-			responseFields: {
-				xml: "responseXML",
-				text: "responseText",
-				json: "responseJSON"
-			},
-
-			// Data converters
-			// Keys separate source (or catchall "*") and destination types with a single space
-			converters: {
-
-				// Convert anything to text
-				"* text": String,
-
-				// Text to html (true = no transformation)
-				"text html": true,
-
-				// Evaluate text as a json expression
-				"text json": jQuery.parseJSON,
-
-				// Parse text as xml
-				"text xml": jQuery.parseXML
-			},
-
-			// For options that shouldn't be deep extended:
-			// you can add your own custom options here if
-			// and when you create one that shouldn't be
-			// deep extended (see ajaxExtend)
-			flatOptions: {
-				url: true,
-				context: true
-			}
-		},
-
-		// Creates a full fledged settings object into target
-		// with both ajaxSettings and settings fields.
-		// If target is omitted, writes into ajaxSettings.
-		ajaxSetup: function (target, settings) {
-			return settings ?
-
-			// Building a settings object
-			ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) :
-
-			// Extending ajaxSettings
-			ajaxExtend(jQuery.ajaxSettings, target);
-		},
-
-		ajaxPrefilter: addToPrefiltersOrTransports(prefilters),
-		ajaxTransport: addToPrefiltersOrTransports(transports),
-
-		// Main method
-		ajax: function (url, options) {
-
-			// If url is an object, simulate pre-1.5 signature
-			if (typeof url === "object") {
-				options = url;
-				url = undefined;
-			}
-
-			// Force options to be an object
-			options = options || {};
-
-			var // Cross-domain detection vars
-			parts,
-				// Loop variable
-				i,
-				// URL without anti-cache param
-				cacheURL,
-				// Response headers as string
-				responseHeadersString,
-				// timeout handle
-				timeoutTimer,
-
-				// To know if global events are to be dispatched
-				fireGlobals,
-
-				transport,
-				// Response headers
-				responseHeaders,
-				// Create the final options object
-				s = jQuery.ajaxSetup({}, options),
-				// Callbacks context
-				callbackContext = s.context || s,
-				// Context for global events is callbackContext if it is a DOM node or jQuery collection
-				globalEventContext = s.context && (callbackContext.nodeType || callbackContext.jquery) ?
-					jQuery(callbackContext) :
-					jQuery.event,
-				// Deferreds
-				deferred = jQuery.Deferred(),
-				completeDeferred = jQuery.Callbacks("once memory"),
-				// Status-dependent callbacks
-				statusCode = s.statusCode || {},
-				// Headers (they are sent all at once)
-				requestHeaders = {},
-				requestHeadersNames = {},
-				// The jqXHR state
-				state = 0,
-				// Default abort message
-				strAbort = "canceled",
-				// Fake xhr
-				jqXHR = {
-					readyState: 0,
-
-					// Builds headers hashtable if needed
-					getResponseHeader: function (key) {
-						var match;
-						if (state === 2) {
-							if (!responseHeaders) {
-								responseHeaders = {};
-								while ((match = rheaders.exec(responseHeadersString))) {
-									responseHeaders[match[1].toLowerCase()] = match[2];
-								}
-							}
-							match = responseHeaders[key.toLowerCase()];
-						}
-						return match == null ? null : match;
-					},
-
-					// Raw string
-					getAllResponseHeaders: function () {
-						return state === 2 ? responseHeadersString : null;
-					},
-
-					// Caches the header
-					setRequestHeader: function (name, value) {
-						var lname = name.toLowerCase();
-						if (!state) {
-							name = requestHeadersNames[lname] = requestHeadersNames[lname] || name;
-							requestHeaders[name] = value;
-						}
-						return this;
-					},
-
-					// Overrides response content-type header
-					overrideMimeType: function (type) {
-						if (!state) {
-							s.mimeType = type;
-						}
-						return this;
-					},
-
-					// Status-dependent callbacks
-					statusCode: function (map) {
-						var code;
-						if (map) {
-							if (state < 2) {
-								for (code in map) {
-									// Lazy-add the new callback in a way that preserves old ones
-									statusCode[code] = [statusCode[code], map[code]];
-								}
-							} else {
-								// Execute the appropriate callbacks
-								jqXHR.always(map[jqXHR.status]);
-							}
-						}
-						return this;
-					},
-
-					// Cancel the request
-					abort: function (statusText) {
-						var finalText = statusText || strAbort;
-						if (transport) {
-							transport.abort(finalText);
-						}
-						done(0, finalText);
-						return this;
-					}
-				};
-
-			// Attach deferreds
-			deferred.promise(jqXHR).complete = completeDeferred.add;
-			jqXHR.success = jqXHR.done;
-			jqXHR.error = jqXHR.fail;
-
-			// Remove hash character (#7531: and string promotion)
-			// Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
-			// Handle falsy url in the settings object (#10093: consistency with old signature)
-			// We also use the url parameter if available
-			s.url = ((url || s.url || ajaxLocation) + "").replace(rhash, "").replace(rprotocol, ajaxLocParts[1] + "//");
-
-			// Alias method option to type as per ticket #12004
-			s.type = options.method || options.type || s.method || s.type;
-
-			// Extract dataTypes list
-			s.dataTypes = jQuery.trim(s.dataType || "*").toLowerCase().match(core_rnotwhite) || [""];
-
-			// A cross-domain request is in order when we have a protocol:host:port mismatch
-			if (s.crossDomain == null) {
-				parts = rurl.exec(s.url.toLowerCase());
-				s.crossDomain = !! (parts &&
-					(parts[1] !== ajaxLocParts[1] || parts[2] !== ajaxLocParts[2] ||
-						(parts[3] || (parts[1] === "http:" ? "80" : "443")) !==
-						(ajaxLocParts[3] || (ajaxLocParts[1] === "http:" ? "80" : "443")))
-				);
-			}
-
-			// Convert data if not already a string
-			if (s.data && s.processData && typeof s.data !== "string") {
-				s.data = jQuery.param(s.data, s.traditional);
-			}
-
-			// Apply prefilters
-			inspectPrefiltersOrTransports(prefilters, s, options, jqXHR);
-
-			// If request was aborted inside a prefilter, stop there
-			if (state === 2) {
-				return jqXHR;
-			}
-
-			// We can fire global events as of now if asked to
-			fireGlobals = s.global;
-
-			// Watch for a new set of requests
-			if (fireGlobals && jQuery.active++ === 0) {
-				jQuery.event.trigger("ajaxStart");
-			}
-
-			// Uppercase the type
-			s.type = s.type.toUpperCase();
-
-			// Determine if request has content
-			s.hasContent = !rnoContent.test(s.type);
-
-			// Save the URL in case we're toying with the If-Modified-Since
-			// and/or If-None-Match header later on
-			cacheURL = s.url;
-
-			// More options handling for requests with no content
-			if (!s.hasContent) {
-
-				// If data is available, append data to url
-				if (s.data) {
-					cacheURL = (s.url += (ajax_rquery.test(cacheURL) ? "&" : "?") + s.data);
-					// #9682: remove data so that it's not used in an eventual retry
-					delete s.data;
-				}
-
-				// Add anti-cache in url if needed
-				if (s.cache === false) {
-					s.url = rts.test(cacheURL) ?
-
-					// If there is already a '_' parameter, set its value
-					cacheURL.replace(rts, "$1_=" + ajax_nonce++) :
-
-					// Otherwise add one to the end
-					cacheURL + (ajax_rquery.test(cacheURL) ? "&" : "?") + "_=" + ajax_nonce++;
-				}
-			}
-
-			// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
-			if (s.ifModified) {
-				if (jQuery.lastModified[cacheURL]) {
-					jqXHR.setRequestHeader("If-Modified-Since", jQuery.lastModified[cacheURL]);
-				}
-				if (jQuery.etag[cacheURL]) {
-					jqXHR.setRequestHeader("If-None-Match", jQuery.etag[cacheURL]);
-				}
-			}
-
-			// Set the correct header, if data is being sent
-			if (s.data && s.hasContent && s.contentType !== false || options.contentType) {
-				jqXHR.setRequestHeader("Content-Type", s.contentType);
-			}
-
-			// Set the Accepts header for the server, depending on the dataType
-			jqXHR.setRequestHeader(
-				"Accept",
-				s.dataTypes[0] && s.accepts[s.dataTypes[0]] ?
-				s.accepts[s.dataTypes[0]] + (s.dataTypes[0] !== "*" ? ", " + allTypes + "; q=0.01" : "") :
-				s.accepts["*"]
-			);
-
-			// Check for headers option
-			for (i in s.headers) {
-				jqXHR.setRequestHeader(i, s.headers[i]);
-			}
-
-			// Allow custom headers/mimetypes and early abort
-			if (s.beforeSend && (s.beforeSend.call(callbackContext, jqXHR, s) === false || state === 2)) {
-				// Abort if not done already and return
-				return jqXHR.abort();
-			}
-
-			// aborting is no longer a cancellation
-			strAbort = "abort";
-
-			// Install callbacks on deferreds
-			for (i in {
-				success: 1,
-				error: 1,
-				complete: 1
-			}) {
-				jqXHR[i](s[i]);
-			}
-
-			// Get transport
-			transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR);
-
-			// If no transport, we auto-abort
-			if (!transport) {
-				done(-1, "No Transport");
-			} else {
-				jqXHR.readyState = 1;
-
-				// Send global event
-				if (fireGlobals) {
-					globalEventContext.trigger("ajaxSend", [jqXHR, s]);
-				}
-				// Timeout
-				if (s.async && s.timeout > 0) {
-					timeoutTimer = setTimeout(function () {
-						jqXHR.abort("timeout");
-					}, s.timeout);
-				}
-
-				try {
-					state = 1;
-					transport.send(requestHeaders, done);
-				} catch (e) {
-					// Propagate exception as error if not done
-					if (state < 2) {
-						done(-1, e);
-						// Simply rethrow otherwise
-					} else {
-						throw e;
-					}
-				}
-			}
-
-			// Callback for when everything is done
-
-			function done(status, nativeStatusText, responses, headers) {
-				var isSuccess, success, error, response, modified,
-					statusText = nativeStatusText;
-
-				// Called once
-				if (state === 2) {
-					return;
-				}
-
-				// State is "done" now
-				state = 2;
-
-				// Clear timeout if it exists
-				if (timeoutTimer) {
-					clearTimeout(timeoutTimer);
-				}
-
-				// Dereference transport for early garbage collection
-				// (no matter how long the jqXHR object will be used)
-				transport = undefined;
-
-				// Cache response headers
-				responseHeadersString = headers || "";
-
-				// Set readyState
-				jqXHR.readyState = status > 0 ? 4 : 0;
-
-				// Determine if successful
-				isSuccess = status >= 200 && status < 300 || status === 304;
-
-				// Get response data
-				if (responses) {
-					response = ajaxHandleResponses(s, jqXHR, responses);
-				}
-
-				// Convert no matter what (that way responseXXX fields are always set)
-				response = ajaxConvert(s, response, jqXHR, isSuccess);
-
-				// If successful, handle type chaining
-				if (isSuccess) {
-
-					// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
-					if (s.ifModified) {
-						modified = jqXHR.getResponseHeader("Last-Modified");
-						if (modified) {
-							jQuery.lastModified[cacheURL] = modified;
-						}
-						modified = jqXHR.getResponseHeader("etag");
-						if (modified) {
-							jQuery.etag[cacheURL] = modified;
-						}
-					}
-
-					// if no content
-					if (status === 204 || s.type === "HEAD") {
-						statusText = "nocontent";
-
-						// if not modified
-					} else if (status === 304) {
-						statusText = "notmodified";
-
-						// If we have data, let's convert it
-					} else {
-						statusText = response.state;
-						success = response.data;
-						error = response.error;
-						isSuccess = !error;
-					}
-				} else {
-					// We extract error from statusText
-					// then normalize statusText and status for non-aborts
-					error = statusText;
-					if (status || !statusText) {
-						statusText = "error";
-						if (status < 0) {
-							status = 0;
-						}
-					}
-				}
-
-				// Set data for the fake xhr object
-				jqXHR.status = status;
-				jqXHR.statusText = (nativeStatusText || statusText) + "";
-
-				// Success/Error
-				if (isSuccess) {
-					deferred.resolveWith(callbackContext, [success, statusText, jqXHR]);
-				} else {
-					deferred.rejectWith(callbackContext, [jqXHR, statusText, error]);
-				}
-
-				// Status-dependent callbacks
-				jqXHR.statusCode(statusCode);
-				statusCode = undefined;
-
-				if (fireGlobals) {
-					globalEventContext.trigger(isSuccess ? "ajaxSuccess" : "ajaxError", [jqXHR, s, isSuccess ? success : error]);
-				}
-
-				// Complete
-				completeDeferred.fireWith(callbackContext, [jqXHR, statusText]);
-
-				if (fireGlobals) {
-					globalEventContext.trigger("ajaxComplete", [jqXHR, s]);
-					// Handle the global AJAX counter
-					if (!(--jQuery.active)) {
-						jQuery.event.trigger("ajaxStop");
-					}
-				}
-			}
-
-			return jqXHR;
-		},
-
-		getJSON: function (url, data, callback) {
-			return jQuery.get(url, data, callback, "json");
-		},
-
-		getScript: function (url, callback) {
-			return jQuery.get(url, undefined, callback, "script");
-		}
-	});
-
-	jQuery.each(["get", "post"], function (i, method) {
-		jQuery[method] = function (url, data, callback, type) {
-			// shift arguments if data argument was omitted
-			if (jQuery.isFunction(data)) {
-				type = type || callback;
-				callback = data;
-				data = undefined;
-			}
-
-			return jQuery.ajax({
-				url: url,
-				type: method,
-				dataType: type,
-				data: data,
-				success: callback
-			});
-		};
-	});
-
-	/* Handles responses to an ajax request:
-	 * - finds the right dataType (mediates between content-type and expected dataType)
-	 * - returns the corresponding response
-	 */
-
-	function ajaxHandleResponses(s, jqXHR, responses) {
-		var firstDataType, ct, finalDataType, type,
-			contents = s.contents,
-			dataTypes = s.dataTypes;
-
-		// Remove auto dataType and get content-type in the process
-		while (dataTypes[0] === "*") {
-			dataTypes.shift();
-			if (ct === undefined) {
-				ct = s.mimeType || jqXHR.getResponseHeader("Content-Type");
-			}
-		}
-
-		// Check if we're dealing with a known content-type
-		if (ct) {
-			for (type in contents) {
-				if (contents[type] && contents[type].test(ct)) {
-					dataTypes.unshift(type);
-					break;
-				}
-			}
-		}
-
-		// Check to see if we have a response for the expected dataType
-		if (dataTypes[0] in responses) {
-			finalDataType = dataTypes[0];
-		} else {
-			// Try convertible dataTypes
-			for (type in responses) {
-				if (!dataTypes[0] || s.converters[type + " " + dataTypes[0]]) {
-					finalDataType = type;
-					break;
-				}
-				if (!firstDataType) {
-					firstDataType = type;
-				}
-			}
-			// Or just use first one
-			finalDataType = finalDataType || firstDataType;
-		}
-
-		// If we found a dataType
-		// We add the dataType to the list if needed
-		// and return the corresponding response
-		if (finalDataType) {
-			if (finalDataType !== dataTypes[0]) {
-				dataTypes.unshift(finalDataType);
-			}
-			return responses[finalDataType];
-		}
-	}
-
-	/* Chain conversions given the request and the original response
-	 * Also sets the responseXXX fields on the jqXHR instance
-	 */
-
-	function ajaxConvert(s, response, jqXHR, isSuccess) {
-		var conv2, current, conv, tmp, prev,
-			converters = {},
-			// Work with a copy of dataTypes in case we need to modify it for conversion
-			dataTypes = s.dataTypes.slice();
-
-		// Create converters map with lowercased keys
-		if (dataTypes[1]) {
-			for (conv in s.converters) {
-				converters[conv.toLowerCase()] = s.converters[conv];
-			}
-		}
-
-		current = dataTypes.shift();
-
-		// Convert to each sequential dataType
-		while (current) {
-
-			if (s.responseFields[current]) {
-				jqXHR[s.responseFields[current]] = response;
-			}
-
-			// Apply the dataFilter if provided
-			if (!prev && isSuccess && s.dataFilter) {
-				response = s.dataFilter(response, s.dataType);
-			}
-
-			prev = current;
-			current = dataTypes.shift();
-
-			if (current) {
-
-				// There's only work to do if current dataType is non-auto
-				if (current === "*") {
-
-					current = prev;
-
-					// Convert response if prev dataType is non-auto and differs from current
-				} else if (prev !== "*" && prev !== current) {
-
-					// Seek a direct converter
-					conv = converters[prev + " " + current] || converters["* " + current];
-
-					// If none found, seek a pair
-					if (!conv) {
-						for (conv2 in converters) {
-
-							// If conv2 outputs current
-							tmp = conv2.split(" ");
-							if (tmp[1] === current) {
-
-								// If prev can be converted to accepted input
-								conv = converters[prev + " " + tmp[0]] ||
-									converters["* " + tmp[0]];
-								if (conv) {
-									// Condense equivalence converters
-									if (conv === true) {
-										conv = converters[conv2];
-
-										// Otherwise, insert the intermediate dataType
-									} else if (converters[conv2] !== true) {
-										current = tmp[0];
-										dataTypes.unshift(tmp[1]);
-									}
-									break;
-								}
-							}
-						}
-					}
-
-					// Apply converter (if not an equivalence)
-					if (conv !== true) {
-
-						// Unless errors are allowed to bubble, catch and return them
-						if (conv && s["throws"]) {
-							response = conv(response);
-						} else {
-							try {
-								response = conv(response);
-							} catch (e) {
-								return {
-									state: "parsererror",
-									error: conv ? e : "No conversion from " + prev + " to " + current
-								};
-							}
-						}
-					}
-				}
-			}
-		}
-
-		return {
-			state: "success",
-			data: response
-		};
-	}
-	// Install script dataType
-	jQuery.ajaxSetup({
-		accepts: {
-			script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
-		},
-		contents: {
-			script: /(?:java|ecma)script/
-		},
-		converters: {
-			"text script": function (text) {
-				jQuery.globalEval(text);
-				return text;
-			}
-		}
-	});
-
-	// Handle cache's special case and global
-	jQuery.ajaxPrefilter("script", function (s) {
-		if (s.cache === undefined) {
-			s.cache = false;
-		}
-		if (s.crossDomain) {
-			s.type = "GET";
-			s.global = false;
-		}
-	});
-
-	// Bind script tag hack transport
-	jQuery.ajaxTransport("script", function (s) {
-
-		// This transport only deals with cross domain requests
-		if (s.crossDomain) {
-
-			var script,
-				head = document.head || jQuery("head")[0] || document.documentElement;
-
-			return {
-
-				send: function (_, callback) {
-
-					script = document.createElement("script");
-
-					script.async = true;
-
-					if (s.scriptCharset) {
-						script.charset = s.scriptCharset;
-					}
-
-					script.src = s.url;
-
-					// Attach handlers for all browsers
-					script.onload = script.onreadystatechange = function (_, isAbort) {
-
-						if (isAbort || !script.readyState || /loaded|complete/.test(script.readyState)) {
-
-							// Handle memory leak in IE
-							script.onload = script.onreadystatechange = null;
-
-							// Remove the script
-							if (script.parentNode) {
-								script.parentNode.removeChild(script);
-							}
-
-							// Dereference the script
-							script = null;
-
-							// Callback if not abort
-							if (!isAbort) {
-								callback(200, "success");
-							}
-						}
-					};
-
-					// Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending
-					// Use native DOM manipulation to avoid our domManip AJAX trickery
-					head.insertBefore(script, head.firstChild);
-				},
-
-				abort: function () {
-					if (script) {
-						script.onload(undefined, true);
-					}
-				}
-			};
-		}
-	});
-	var oldCallbacks = [],
-		rjsonp = /(=)\?(?=&|$)|\?\?/;
-
-	// Default jsonp settings
-	jQuery.ajaxSetup({
-		jsonp: "callback",
-		jsonpCallback: function () {
-			var callback = oldCallbacks.pop() || (jQuery.expando + "_" + (ajax_nonce++));
-			this[callback] = true;
-			return callback;
-		}
-	});
-
-	// Detect, normalize options and install callbacks for jsonp requests
-	jQuery.ajaxPrefilter("json jsonp", function (s, originalSettings, jqXHR) {
-
-		var callbackName, overwritten, responseContainer,
-			jsonProp = s.jsonp !== false && (rjsonp.test(s.url) ?
-				"url" :
-				typeof s.data === "string" && !(s.contentType || "").indexOf("application/x-www-form-urlencoded") && rjsonp.test(s.data) && "data"
-			);
-
-		// Handle iff the expected data type is "jsonp" or we have a parameter to set
-		if (jsonProp || s.dataTypes[0] === "jsonp") {
-
-			// Get callback name, remembering preexisting value associated with it
-			callbackName = s.jsonpCallback = jQuery.isFunction(s.jsonpCallback) ?
-				s.jsonpCallback() :
-				s.jsonpCallback;
-
-			// Insert callback into url or form data
-			if (jsonProp) {
-				s[jsonProp] = s[jsonProp].replace(rjsonp, "$1" + callbackName);
-			} else if (s.jsonp !== false) {
-				s.url += (ajax_rquery.test(s.url) ? "&" : "?") + s.jsonp + "=" + callbackName;
-			}
-
-			// Use data converter to retrieve json after script execution
-			s.converters["script json"] = function () {
-				if (!responseContainer) {
-					jQuery.error(callbackName + " was not called");
-				}
-				return responseContainer[0];
-			};
-
-			// force json dataType
-			s.dataTypes[0] = "json";
-
-			// Install callback
-			overwritten = window[callbackName];
-			window[callbackName] = function () {
-				responseContainer = arguments;
-			};
-
-			// Clean-up function (fires after converters)
-			jqXHR.always(function () {
-				// Restore preexisting value
-				window[callbackName] = overwritten;
-
-				// Save back as free
-				if (s[callbackName]) {
-					// make sure that re-using the options doesn't screw things around
-					s.jsonpCallback = originalSettings.jsonpCallback;
-
-					// save the callback name for future use
-					oldCallbacks.push(callbackName);
-				}
-
-				// Call if it was a function and we have a response
-				if (responseContainer && jQuery.isFunction(overwritten)) {
-					overwritten(responseContainer[0]);
-				}
-
-				responseContainer = overwritten = undefined;
-			});
-
-			// Delegate to script
-			return "script";
-		}
-	});
-	var xhrCallbacks, xhrSupported,
-		xhrId = 0,
-		// #5280: Internet Explorer will keep connections alive if we don't abort on unload
-		xhrOnUnloadAbort = window.ActiveXObject && function () {
-			// Abort all pending requests
-			var key;
-			for (key in xhrCallbacks) {
-				xhrCallbacks[key](undefined, true);
-			}
-		};
-
-	// Functions to create xhrs
-
-	function createStandardXHR() {
-		try {
-			return new window.XMLHttpRequest();
-		} catch (e) {}
-	}
-
-	function createActiveXHR() {
-		try {
-			return new window.ActiveXObject("Microsoft.XMLHTTP");
-		} catch (e) {}
-	}
-
-	// Create the request object
-	// (This is still attached to ajaxSettings for backward compatibility)
-	jQuery.ajaxSettings.xhr = window.ActiveXObject ?
-	/* Microsoft failed to properly
-	 * implement the XMLHttpRequest in IE7 (can't request local files),
-	 * so we use the ActiveXObject when it is available
-	 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
-	 * we need a fallback.
-	 */
-
-	function () {
-		return !this.isLocal && createStandardXHR() || createActiveXHR();
-	} :
-	// For all other browsers, use the standard XMLHttpRequest object
-	createStandardXHR;
-
-	// Determine support properties
-	xhrSupported = jQuery.ajaxSettings.xhr();
-	jQuery.support.cors = !! xhrSupported && ("withCredentials" in xhrSupported);
-	xhrSupported = jQuery.support.ajax = !! xhrSupported;
-
-	// Create transport if the browser can provide an xhr
-	if (xhrSupported) {
-
-		jQuery.ajaxTransport(function (s) {
-			// Cross domain only allowed if supported through XMLHttpRequest
-			if (!s.crossDomain || jQuery.support.cors) {
-
-				var callback;
-
-				return {
-					send: function (headers, complete) {
-
-						// Get a new xhr
-						var handle, i,
-							xhr = s.xhr();
-
-						// Open the socket
-						// Passing null username, generates a login popup on Opera (#2865)
-						if (s.username) {
-							xhr.open(s.type, s.url, s.async, s.username, s.password);
-						} else {
-							xhr.open(s.type, s.url, s.async);
-						}
-
-						// Apply custom fields if provided
-						if (s.xhrFields) {
-							for (i in s.xhrFields) {
-								xhr[i] = s.xhrFields[i];
-							}
-						}
-
-						// Override mime type if needed
-						if (s.mimeType && xhr.overrideMimeType) {
-							xhr.overrideMimeType(s.mimeType);
-						}
-
-						// X-Requested-With header
-						// For cross-domain requests, seeing as conditions for a preflight are
-						// akin to a jigsaw puzzle, we simply never set it to be sure.
-						// (it can always be set on a per-request basis or even using ajaxSetup)
-						// For same-domain requests, won't change header if already provided.
-						if (!s.crossDomain && !headers["X-Requested-With"]) {
-							headers["X-Requested-With"] = "XMLHttpRequest";
-						}
-
-						// Need an extra try/catch for cross domain requests in Firefox 3
-						try {
-							for (i in headers) {
-								xhr.setRequestHeader(i, headers[i]);
-							}
-						} catch (err) {}
-
-						// Do send the request
-						// This may raise an exception which is actually
-						// handled in jQuery.ajax (so no try/catch here)
-						xhr.send((s.hasContent && s.data) || null);
-
-						// Listener
-						callback = function (_, isAbort) {
-							var status, responseHeaders, statusText, responses;
-
-							// Firefox throws exceptions when accessing properties
-							// of an xhr when a network error occurred
-							// http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
-							try {
-
-								// Was never called and is aborted or complete
-								if (callback && (isAbort || xhr.readyState === 4)) {
-
-									// Only called once
-									callback = undefined;
-
-									// Do not keep as active anymore
-									if (handle) {
-										xhr.onreadystatechange = jQuery.noop;
-										if (xhrOnUnloadAbort) {
-											delete xhrCallbacks[handle];
-										}
-									}
-
-									// If it's an abort
-									if (isAbort) {
-										// Abort it manually if needed
-										if (xhr.readyState !== 4) {
-											xhr.abort();
-										}
-									} else {
-										responses = {};
-										status = xhr.status;
-										responseHeaders = xhr.getAllResponseHeaders();
-
-										// When requesting binary data, IE6-9 will throw an exception
-										// on any attempt to access responseText (#11426)
-										if (typeof xhr.responseText === "string") {
-											responses.text = xhr.responseText;
-										}
-
-										// Firefox throws an exception when accessing
-										// statusText for faulty cross-domain requests
-										try {
-											statusText = xhr.statusText;
-										} catch (e) {
-											// We normalize with Webkit giving an empty statusText
-											statusText = "";
-										}
-
-										// Filter status for non standard behaviors
-
-										// If the request is local and we have data: assume a success
-										// (success with no data won't get notified, that's the best we
-										// can do given current implementations)
-										if (!status && s.isLocal && !s.crossDomain) {
-											status = responses.text ? 200 : 404;
-											// IE - #1450: sometimes returns 1223 when it should be 204
-										} else if (status === 1223) {
-											status = 204;
-										}
-									}
-								}
-							} catch (firefoxAccessException) {
-								if (!isAbort) {
-									complete(-1, firefoxAccessException);
-								}
-							}
-
-							// Call complete if needed
-							if (responses) {
-								complete(status, statusText, responses, responseHeaders);
-							}
-						};
-
-						if (!s.async) {
-							// if we're in sync mode we fire the callback
-							callback();
-						} else if (xhr.readyState === 4) {
-							// (IE6 & IE7) if it's in cache and has been
-							// retrieved directly we need to fire the callback
-							setTimeout(callback);
-						} else {
-							handle = ++xhrId;
-							if (xhrOnUnloadAbort) {
-								// Create the active xhrs callbacks list if needed
-								// and attach the unload handler
-								if (!xhrCallbacks) {
-									xhrCallbacks = {};
-									jQuery(window).unload(xhrOnUnloadAbort);
-								}
-								// Add to list of active xhrs callbacks
-								xhrCallbacks[handle] = callback;
-							}
-							xhr.onreadystatechange = callback;
-						}
-					},
-
-					abort: function () {
-						if (callback) {
-							callback(undefined, true);
-						}
-					}
-				};
-			}
-		});
-	}
-	var fxNow, timerId,
-		rfxtypes = /^(?:toggle|show|hide)$/,
-		rfxnum = new RegExp("^(?:([+-])=|)(" + core_pnum + ")([a-z%]*)$", "i"),
-		rrun = /queueHooks$/,
-		animationPrefilters = [defaultPrefilter],
-		tweeners = {
-			"*": [
-				function (prop, value) {
-					var tween = this.createTween(prop, value),
-						target = tween.cur(),
-						parts = rfxnum.exec(value),
-						unit = parts && parts[3] || (jQuery.cssNumber[prop] ? "" : "px"),
-
-						// Starting value computation is required for potential unit mismatches
-						start = (jQuery.cssNumber[prop] || unit !== "px" && +target) &&
-							rfxnum.exec(jQuery.css(tween.elem, prop)),
-						scale = 1,
-						maxIterations = 20;
-
-					if (start && start[3] !== unit) {
-						// Trust units reported by jQuery.css
-						unit = unit || start[3];
-
-						// Make sure we update the tween properties later on
-						parts = parts || [];
-
-						// Iteratively approximate from a nonzero starting point
-						start = +target || 1;
-
-						do {
-							// If previous iteration zeroed out, double until we get *something*
-							// Use a string for doubling factor so we don't accidentally see scale as unchanged below
-							scale = scale || ".5";
-
-							// Adjust and apply
-							start = start / scale;
-							jQuery.style(tween.elem, prop, start + unit);
-
-							// Update scale, tolerating zero or NaN from tween.cur()
-							// And breaking the loop if scale is unchanged or perfect, or if we've just had enough
-						} while (scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations);
-					}
-
-					// Update tween properties
-					if (parts) {
-						start = tween.start = +start || +target || 0;
-						tween.unit = unit;
-						// If a +=/-= token was provided, we're doing a relative animation
-						tween.end = parts[1] ?
-							start + (parts[1] + 1) * parts[2] : +parts[2];
-					}
-
-					return tween;
-				}
-			]
-		};
-
-	// Animations created synchronously will run synchronously
-
-	function createFxNow() {
-		setTimeout(function () {
-			fxNow = undefined;
-		});
-		return (fxNow = jQuery.now());
-	}
-
-	function createTween(value, prop, animation) {
-		var tween,
-			collection = (tweeners[prop] || []).concat(tweeners["*"]),
-			index = 0,
-			length = collection.length;
-		for (; index < length; index++) {
-			if ((tween = collection[index].call(animation, prop, value))) {
-
-				// we're done with this property
-				return tween;
-			}
-		}
-	}
-
-	function Animation(elem, properties, options) {
-		var result,
-			stopped,
-			index = 0,
-			length = animationPrefilters.length,
-			deferred = jQuery.Deferred().always(function () {
-				// don't match elem in the :animated selector
-				delete tick.elem;
-			}),
-			tick = function () {
-				if (stopped) {
-					return false;
-				}
-				var currentTime = fxNow || createFxNow(),
-					remaining = Math.max(0, animation.startTime + animation.duration - currentTime),
-					// archaic crash bug won't allow us to use 1 - ( 0.5 || 0 ) (#12497)
-					temp = remaining / animation.duration || 0,
-					percent = 1 - temp,
-					index = 0,
-					length = animation.tweens.length;
-
-				for (; index < length; index++) {
-					animation.tweens[index].run(percent);
-				}
-
-				deferred.notifyWith(elem, [animation, percent, remaining]);
-
-				if (percent < 1 && length) {
-					return remaining;
-				} else {
-					deferred.resolveWith(elem, [animation]);
-					return false;
-				}
-			},
-			animation = deferred.promise({
-				elem: elem,
-				props: jQuery.extend({}, properties),
-				opts: jQuery.extend(true, {
-					specialEasing: {}
-				}, options),
-				originalProperties: properties,
-				originalOptions: options,
-				startTime: fxNow || createFxNow(),
-				duration: options.duration,
-				tweens: [],
-				createTween: function (prop, end) {
-					var tween = jQuery.Tween(elem, animation.opts, prop, end,
-						animation.opts.specialEasing[prop] || animation.opts.easing);
-					animation.tweens.push(tween);
-					return tween;
-				},
-				stop: function (gotoEnd) {
-					var index = 0,
-						// if we are going to the end, we want to run all the tweens
-						// otherwise we skip this part
-						length = gotoEnd ? animation.tweens.length : 0;
-					if (stopped) {
-						return this;
-					}
-					stopped = true;
-					for (; index < length; index++) {
-						animation.tweens[index].run(1);
-					}
-
-					// resolve when we played the last frame
-					// otherwise, reject
-					if (gotoEnd) {
-						deferred.resolveWith(elem, [animation, gotoEnd]);
-					} else {
-						deferred.rejectWith(elem, [animation, gotoEnd]);
-					}
-					return this;
-				}
-			}),
-			props = animation.props;
-
-		propFilter(props, animation.opts.specialEasing);
-
-		for (; index < length; index++) {
-			result = animationPrefilters[index].call(animation, elem, props, animation.opts);
-			if (result) {
-				return result;
-			}
-		}
-
-		jQuery.map(props, createTween, animation);
-
-		if (jQuery.isFunction(animation.opts.start)) {
-			animation.opts.start.call(elem, animation);
-		}
-
-		jQuery.fx.timer(
-			jQuery.extend(tick, {
-				elem: elem,
-				anim: animation,
-				queue: animation.opts.queue
-			})
-		);
-
-		// attach callbacks from options
-		return animation.progress(animation.opts.progress)
-			.done(animation.opts.done, animation.opts.complete)
-			.fail(animation.opts.fail)
-			.always(animation.opts.always);
-	}
-
-	function propFilter(props, specialEasing) {
-		var index, name, easing, value, hooks;
-
-		// camelCase, specialEasing and expand cssHook pass
-		for (index in props) {
-			name = jQuery.camelCase(index);
-			easing = specialEasing[name];
-			value = props[index];
-			if (jQuery.isArray(value)) {
-				easing = value[1];
-				value = props[index] = value[0];
-			}
-
-			if (index !== name) {
-				props[name] = value;
-				delete props[index];
-			}
-
-			hooks = jQuery.cssHooks[name];
-			if (hooks && "expand" in hooks) {
-				value = hooks.expand(value);
-				delete props[name];
-
-				// not quite $.extend, this wont overwrite keys already present.
-				// also - reusing 'index' from above because we have the correct "name"
-				for (index in value) {
-					if (!(index in props)) {
-						props[index] = value[index];
-						specialEasing[index] = easing;
-					}
-				}
-			} else {
-				specialEasing[name] = easing;
-			}
-		}
-	}
-
-	jQuery.Animation = jQuery.extend(Animation, {
-
-		tweener: function (props, callback) {
-			if (jQuery.isFunction(props)) {
-				callback = props;
-				props = ["*"];
-			} else {
-				props = props.split(" ");
-			}
-
-			var prop,
-				index = 0,
-				length = props.length;
-
-			for (; index < length; index++) {
-				prop = props[index];
-				tweeners[prop] = tweeners[prop] || [];
-				tweeners[prop].unshift(callback);
-			}
-		},
-
-		prefilter: function (callback, prepend) {
-			if (prepend) {
-				animationPrefilters.unshift(callback);
-			} else {
-				animationPrefilters.push(callback);
-			}
-		}
-	});
-
-	function defaultPrefilter(elem, props, opts) {
-		/* jshint validthis: true */
-		var prop, value, toggle, tween, hooks, oldfire,
-			anim = this,
-			orig = {},
-			style = elem.style,
-			hidden = elem.nodeType && isHidden(elem),
-			dataShow = jQuery._data(elem, "fxshow");
-
-		// handle queue: false promises
-		if (!opts.queue) {
-			hooks = jQuery._queueHooks(elem, "fx");
-			if (hooks.unqueued == null) {
-				hooks.unqueued = 0;
-				oldfire = hooks.empty.fire;
-				hooks.empty.fire = function () {
-					if (!hooks.unqueued) {
-						oldfire();
-					}
-				};
-			}
-			hooks.unqueued++;
-
-			anim.always(function () {
-				// doing this makes sure that the complete handler will be called
-				// before this completes
-				anim.always(function () {
-					hooks.unqueued--;
-					if (!jQuery.queue(elem, "fx").length) {
-						hooks.empty.fire();
-					}
-				});
-			});
-		}
-
-		// height/width overflow pass
-		if (elem.nodeType === 1 && ("height" in props || "width" in props)) {
-			// Make sure that nothing sneaks out
-			// Record all 3 overflow attributes because IE does not
-			// change the overflow attribute when overflowX and
-			// overflowY are set to the same value
-			opts.overflow = [style.overflow, style.overflowX, style.overflowY];
-
-			// Set display property to inline-block for height/width
-			// animations on inline elements that are having width/height animated
-			if (jQuery.css(elem, "display") === "inline" &&
-				jQuery.css(elem, "float") === "none") {
-
-				// inline-level elements accept inline-block;
-				// block-level elements need to be inline with layout
-				if (!jQuery.support.inlineBlockNeedsLayout || css_defaultDisplay(elem.nodeName) === "inline") {
-					style.display = "inline-block";
-
-				} else {
-					style.zoom = 1;
-				}
-			}
-		}
-
-		if (opts.overflow) {
-			style.overflow = "hidden";
-			if (!jQuery.support.shrinkWrapBlocks) {
-				anim.always(function () {
-					style.overflow = opts.overflow[0];
-					style.overflowX = opts.overflow[1];
-					style.overflowY = opts.overflow[2];
-				});
-			}
-		}
-
-
-		// show/hide pass
-		for (prop in props) {
-			value = props[prop];
-			if (rfxtypes.exec(value)) {
-				delete props[prop];
-				toggle = toggle || value === "toggle";
-				if (value === (hidden ? "hide" : "show")) {
-					continue;
-				}
-				orig[prop] = dataShow && dataShow[prop] || jQuery.style(elem, prop);
-			}
-		}
-
-		if (!jQuery.isEmptyObject(orig)) {
-			if (dataShow) {
-				if ("hidden" in dataShow) {
-					hidden = dataShow.hidden;
-				}
-			} else {
-				dataShow = jQuery._data(elem, "fxshow", {});
-			}
-
-			// store state if its toggle - enables .stop().toggle() to "reverse"
-			if (toggle) {
-				dataShow.hidden = !hidden;
-			}
-			if (hidden) {
-				jQuery(elem).show();
-			} else {
-				anim.done(function () {
-					jQuery(elem).hide();
-				});
-			}
-			anim.done(function () {
-				var prop;
-				jQuery._removeData(elem, "fxshow");
-				for (prop in orig) {
-					jQuery.style(elem, prop, orig[prop]);
-				}
-			});
-			for (prop in orig) {
-				tween = createTween(hidden ? dataShow[prop] : 0, prop, anim);
-
-				if (!(prop in dataShow)) {
-					dataShow[prop] = tween.start;
-					if (hidden) {
-						tween.end = tween.start;
-						tween.start = prop === "width" || prop === "height" ? 1 : 0;
-					}
-				}
-			}
-		}
-	}
-
-	function Tween(elem, options, prop, end, easing) {
-		return new Tween.prototype.init(elem, options, prop, end, easing);
-	}
-	jQuery.Tween = Tween;
-
-	Tween.prototype = {
-		constructor: Tween,
-		init: function (elem, options, prop, end, easing, unit) {
-			this.elem = elem;
-			this.prop = prop;
-			this.easing = easing || "swing";
-			this.options = options;
-			this.start = this.now = this.cur();
-			this.end = end;
-			this.unit = unit || (jQuery.cssNumber[prop] ? "" : "px");
-		},
-		cur: function () {
-			var hooks = Tween.propHooks[this.prop];
-
-			return hooks && hooks.get ?
-				hooks.get(this) :
-				Tween.propHooks._default.get(this);
-		},
-		run: function (percent) {
-			var eased,
-				hooks = Tween.propHooks[this.prop];
-
-			if (this.options.duration) {
-				this.pos = eased = jQuery.easing[this.easing](
-					percent, this.options.duration * percent, 0, 1, this.options.duration
-				);
-			} else {
-				this.pos = eased = percent;
-			}
-			this.now = (this.end - this.start) * eased + this.start;
-
-			if (this.options.step) {
-				this.options.step.call(this.elem, this.now, this);
-			}
-
-			if (hooks && hooks.set) {
-				hooks.set(this);
-			} else {
-				Tween.propHooks._default.set(this);
-			}
-			return this;
-		}
-	};
-
-	Tween.prototype.init.prototype = Tween.prototype;
-
-	Tween.propHooks = {
-		_default: {
-			get: function (tween) {
-				var result;
-
-				if (tween.elem[tween.prop] != null &&
-					(!tween.elem.style || tween.elem.style[tween.prop] == null)) {
-					return tween.elem[tween.prop];
-				}
-
-				// passing an empty string as a 3rd parameter to .css will automatically
-				// attempt a parseFloat and fallback to a string if the parse fails
-				// so, simple values such as "10px" are parsed to Float.
-				// complex values such as "rotate(1rad)" are returned as is.
-				result = jQuery.css(tween.elem, tween.prop, "");
-				// Empty strings, null, undefined and "auto" are converted to 0.
-				return !result || result === "auto" ? 0 : result;
-			},
-			set: function (tween) {
-				// use step hook for back compat - use cssHook if its there - use .style if its
-				// available and use plain properties where available
-				if (jQuery.fx.step[tween.prop]) {
-					jQuery.fx.step[tween.prop](tween);
-				} else if (tween.elem.style && (tween.elem.style[jQuery.cssProps[tween.prop]] != null || jQuery.cssHooks[tween.prop])) {
-					jQuery.style(tween.elem, tween.prop, tween.now + tween.unit);
-				} else {
-					tween.elem[tween.prop] = tween.now;
-				}
-			}
-		}
-	};
-
-	// Support: IE <=9
-	// Panic based approach to setting things on disconnected nodes
-
-	Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
-		set: function (tween) {
-			if (tween.elem.nodeType && tween.elem.parentNode) {
-				tween.elem[tween.prop] = tween.now;
-			}
-		}
-	};
-
-	jQuery.each(["toggle", "show", "hide"], function (i, name) {
-		var cssFn = jQuery.fn[name];
-		jQuery.fn[name] = function (speed, easing, callback) {
-			return speed == null || typeof speed === "boolean" ?
-				cssFn.apply(this, arguments) :
-				this.animate(genFx(name, true), speed, easing, callback);
-		};
-	});
-
-	jQuery.fn.extend({
-		fadeTo: function (speed, to, easing, callback) {
-
-			// show any hidden elements after setting opacity to 0
-			return this.filter(isHidden).css("opacity", 0).show()
-
-			// animate to the value specified
-			.end().animate({
-				opacity: to
-			}, speed, easing, callback);
-		},
-		animate: function (prop, speed, easing, callback) {
-			var empty = jQuery.isEmptyObject(prop),
-				optall = jQuery.speed(speed, easing, callback),
-				doAnimation = function () {
-					// Operate on a copy of prop so per-property easing won't be lost
-					var anim = Animation(this, jQuery.extend({}, prop), optall);
-
-					// Empty animations, or finishing resolves immediately
-					if (empty || jQuery._data(this, "finish")) {
-						anim.stop(true);
-					}
-				};
-			doAnimation.finish = doAnimation;
-
-			return empty || optall.queue === false ?
-				this.each(doAnimation) :
-				this.queue(optall.queue, doAnimation);
-		},
-		stop: function (type, clearQueue, gotoEnd) {
-			var stopQueue = function (hooks) {
-				var stop = hooks.stop;
-				delete hooks.stop;
-				stop(gotoEnd);
-			};
-
-			if (typeof type !== "string") {
-				gotoEnd = clearQueue;
-				clearQueue = type;
-				type = undefined;
-			}
-			if (clearQueue && type !== false) {
-				this.queue(type || "fx", []);
-			}
-
-			return this.each(function () {
-				var dequeue = true,
-					index = type != null && type + "queueHooks",
-					timers = jQuery.timers,
-					data = jQuery._data(this);
-
-				if (index) {
-					if (data[index] && data[index].stop) {
-						stopQueue(data[index]);
-					}
-				} else {
-					for (index in data) {
-						if (data[index] && data[index].stop && rrun.test(index)) {
-							stopQueue(data[index]);
-						}
-					}
-				}
-
-				for (index = timers.length; index--;) {
-					if (timers[index].elem === this && (type == null || timers[index].queue === type)) {
-						timers[index].anim.stop(gotoEnd);
-						dequeue = false;
-						timers.splice(index, 1);
-					}
-				}
-
-				// start the next in the queue if the last step wasn't forced
-				// timers currently will call their complete callbacks, which will dequeue
-				// but only if they were gotoEnd
-				if (dequeue || !gotoEnd) {
-					jQuery.dequeue(this, type);
-				}
-			});
-		},
-		finish: function (type) {
-			if (type !== false) {
-				type = type || "fx";
-			}
-			return this.each(function () {
-				var index,
-					data = jQuery._data(this),
-					queue = data[type + "queue"],
-					hooks = data[type + "queueHooks"],
-					timers = jQuery.timers,
-					length = queue ? queue.length : 0;
-
-				// enable finishing flag on private data
-				data.finish = true;
-
-				// empty the queue first
-				jQuery.queue(this, type, []);
-
-				if (hooks && hooks.stop) {
-					hooks.stop.call(this, true);
-				}
-
-				// look for any active animations, and finish them
-				for (index = timers.length; index--;) {
-					if (timers[index].elem === this && timers[index].queue === type) {
-						timers[index].anim.stop(true);
-						timers.splice(index, 1);
-					}
-				}
-
-				// look for any animations in the old queue and finish them
-				for (index = 0; index < length; index++) {
-					if (queue[index] && queue[index].finish) {
-						queue[index].finish.call(this);
-					}
-				}
-
-				// turn off finishing flag
-				delete data.finish;
-			});
-		}
-	});
-
-	// Generate parameters to create a standard animation
-
-	function genFx(type, includeWidth) {
-		var which,
-			attrs = {
-				height: type
-			},
-			i = 0;
-
-		// if we include width, step value is 1 to do all cssExpand values,
-		// if we don't include width, step value is 2 to skip over Left and Right
-		includeWidth = includeWidth ? 1 : 0;
-		for (; i < 4; i += 2 - includeWidth) {
-			which = cssExpand[i];
-			attrs["margin" + which] = attrs["padding" + which] = type;
-		}
-
-		if (includeWidth) {
-			attrs.opacity = attrs.width = type;
-		}
-
-		return attrs;
-	}
-
-	// Generate shortcuts for custom animations
-	jQuery.each({
-		slideDown: genFx("show"),
-		slideUp: genFx("hide"),
-		slideToggle: genFx("toggle"),
-		fadeIn: {
-			opacity: "show"
-		},
-		fadeOut: {
-			opacity: "hide"
-		},
-		fadeToggle: {
-			opacity: "toggle"
-		}
-	}, function (name, props) {
-		jQuery.fn[name] = function (speed, easing, callback) {
-			return this.animate(props, speed, easing, callback);
-		};
-	});
-
-	jQuery.speed = function (speed, easing, fn) {
-		var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
-			complete: fn || !fn && easing || jQuery.isFunction(speed) && speed,
-			duration: speed,
-			easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
-		};
-
-		opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
-			opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
-
-		// normalize opt.queue - true/undefined/null -> "fx"
-		if (opt.queue == null || opt.queue === true) {
-			opt.queue = "fx";
-		}
-
-		// Queueing
-		opt.old = opt.complete;
-
-		opt.complete = function () {
-			if (jQuery.isFunction(opt.old)) {
-				opt.old.call(this);
-			}
-
-			if (opt.queue) {
-				jQuery.dequeue(this, opt.queue);
-			}
-		};
-
-		return opt;
-	};
-
-	jQuery.easing = {
-		linear: function (p) {
-			return p;
-		},
-		swing: function (p) {
-			return 0.5 - Math.cos(p * Math.PI) / 2;
-		}
-	};
-
-	jQuery.timers = [];
-	jQuery.fx = Tween.prototype.init;
-	jQuery.fx.tick = function () {
-		var timer,
-			timers = jQuery.timers,
-			i = 0;
-
-		fxNow = jQuery.now();
-
-		for (; i < timers.length; i++) {
-			timer = timers[i];
-			// Checks the timer has not already been removed
-			if (!timer() && timers[i] === timer) {
-				timers.splice(i--, 1);
-			}
-		}
-
-		if (!timers.length) {
-			jQuery.fx.stop();
-		}
-		fxNow = undefined;
-	};
-
-	jQuery.fx.timer = function (timer) {
-		if (timer() && jQuery.timers.push(timer)) {
-			jQuery.fx.start();
-		}
-	};
-
-	jQuery.fx.interval = 13;
-
-	jQuery.fx.start = function () {
-		if (!timerId) {
-			timerId = setInterval(jQuery.fx.tick, jQuery.fx.interval);
-		}
-	};
-
-	jQuery.fx.stop = function () {
-		clearInterval(timerId);
-		timerId = null;
-	};
-
-	jQuery.fx.speeds = {
-		slow: 600,
-		fast: 200,
-		// Default speed
-		_default: 400
-	};
-
-	// Back Compat <1.8 extension point
-	jQuery.fx.step = {};
-
-	if (jQuery.expr && jQuery.expr.filters) {
-		jQuery.expr.filters.animated = function (elem) {
-			return jQuery.grep(jQuery.timers, function (fn) {
-				return elem === fn.elem;
-			}).length;
-		};
-	}
-	jQuery.fn.offset = function (options) {
-		if (arguments.length) {
-			return options === undefined ?
-				this :
-				this.each(function (i) {
-					jQuery.offset.setOffset(this, options, i);
-				});
-		}
-
-		var docElem, win,
-			box = {
-				top: 0,
-				left: 0
-			},
-			elem = this[0],
-			doc = elem && elem.ownerDocument;
-
-		if (!doc) {
-			return;
-		}
-
-		docElem = doc.documentElement;
-
-		// Make sure it's not a disconnected DOM node
-		if (!jQuery.contains(docElem, elem)) {
-			return box;
-		}
-
-		// If we don't have gBCR, just use 0,0 rather than error
-		// BlackBerry 5, iOS 3 (original iPhone)
-		if (typeof elem.getBoundingClientRect !== core_strundefined) {
-			box = elem.getBoundingClientRect();
-		}
-		win = getWindow(doc);
-		return {
-			top: box.top + (win.pageYOffset || docElem.scrollTop) - (docElem.clientTop || 0),
-			left: box.left + (win.pageXOffset || docElem.scrollLeft) - (docElem.clientLeft || 0)
-		};
-	};
-
-	jQuery.offset = {
-
-		setOffset: function (elem, options, i) {
-			var position = jQuery.css(elem, "position");
-
-			// set position first, in-case top/left are set even on static elem
-			if (position === "static") {
-				elem.style.position = "relative";
-			}
-
-			var curElem = jQuery(elem),
-				curOffset = curElem.offset(),
-				curCSSTop = jQuery.css(elem, "top"),
-				curCSSLeft = jQuery.css(elem, "left"),
-				calculatePosition = (position === "absolute" || position === "fixed") && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
-				props = {}, curPosition = {}, curTop, curLeft;
-
-			// need to be able to calculate position if either top or left is auto and position is either absolute or fixed
-			if (calculatePosition) {
-				curPosition = curElem.position();
-				curTop = curPosition.top;
-				curLeft = curPosition.left;
-			} else {
-				curTop = parseFloat(curCSSTop) || 0;
-				curLeft = parseFloat(curCSSLeft) || 0;
-			}
-
-			if (jQuery.isFunction(options)) {
-				options = options.call(elem, i, curOffset);
-			}
-
-			if (options.top != null) {
-				props.top = (options.top - curOffset.top) + curTop;
-			}
-			if (options.left != null) {
-				props.left = (options.left - curOffset.left) + curLeft;
-			}
-
-			if ("using" in options) {
-				options.using.call(elem, props);
-			} else {
-				curElem.css(props);
-			}
-		}
-	};
-
-
-	jQuery.fn.extend({
-
-		position: function () {
-			if (!this[0]) {
-				return;
-			}
-
-			var offsetParent, offset,
-				parentOffset = {
-					top: 0,
-					left: 0
-				},
-				elem = this[0];
-
-			// fixed elements are offset from window (parentOffset = {top:0, left: 0}, because it is it's only offset parent
-			if (jQuery.css(elem, "position") === "fixed") {
-				// we assume that getBoundingClientRect is available when computed position is fixed
-				offset = elem.getBoundingClientRect();
-			} else {
-				// Get *real* offsetParent
-				offsetParent = this.offsetParent();
-
-				// Get correct offsets
-				offset = this.offset();
-				if (!jQuery.nodeName(offsetParent[0], "html")) {
-					parentOffset = offsetParent.offset();
-				}
-
-				// Add offsetParent borders
-				parentOffset.top += jQuery.css(offsetParent[0], "borderTopWidth", true);
-				parentOffset.left += jQuery.css(offsetParent[0], "borderLeftWidth", true);
-			}
-
-			// Subtract parent offsets and element margins
-			// note: when an element has margin: auto the offsetLeft and marginLeft
-			// are the same in Safari causing offset.left to incorrectly be 0
-			return {
-				top: offset.top - parentOffset.top - jQuery.css(elem, "marginTop", true),
-				left: offset.left - parentOffset.left - jQuery.css(elem, "marginLeft", true)
-			};
-		},
-
-		offsetParent: function () {
-			return this.map(function () {
-				var offsetParent = this.offsetParent || docElem;
-				while (offsetParent && (!jQuery.nodeName(offsetParent, "html") && jQuery.css(offsetParent, "position") === "static")) {
-					offsetParent = offsetParent.offsetParent;
-				}
-				return offsetParent || docElem;
-			});
-		}
-	});
-
-
-	// Create scrollLeft and scrollTop methods
-	jQuery.each({
-		scrollLeft: "pageXOffset",
-		scrollTop: "pageYOffset"
-	}, function (method, prop) {
-		var top = /Y/.test(prop);
-
-		jQuery.fn[method] = function (val) {
-			return jQuery.access(this, function (elem, method, val) {
-				var win = getWindow(elem);
-
-				if (val === undefined) {
-					return win ? (prop in win) ? win[prop] :
-						win.document.documentElement[method] :
-						elem[method];
-				}
-
-				if (win) {
-					win.scrollTo(!top ? val : jQuery(win).scrollLeft(),
-						top ? val : jQuery(win).scrollTop()
-					);
-
-				} else {
-					elem[method] = val;
-				}
-			}, method, val, arguments.length, null);
-		};
-	});
-
-	function getWindow(elem) {
-		return jQuery.isWindow(elem) ?
-			elem :
-			elem.nodeType === 9 ?
-			elem.defaultView || elem.parentWindow :
-			false;
-	}
-	// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
-	jQuery.each({
-		Height: "height",
-		Width: "width"
-	}, function (name, type) {
-		jQuery.each({
-			padding: "inner" + name,
-			content: type,
-			"": "outer" + name
-		}, function (defaultExtra, funcName) {
-			// margin is only for outerHeight, outerWidth
-			jQuery.fn[funcName] = function (margin, value) {
-				var chainable = arguments.length && (defaultExtra || typeof margin !== "boolean"),
-					extra = defaultExtra || (margin === true || value === true ? "margin" : "border");
-
-				return jQuery.access(this, function (elem, type, value) {
-					var doc;
-
-					if (jQuery.isWindow(elem)) {
-						// As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
-						// isn't a whole lot we can do. See pull request at this URL for discussion:
-						// https://github.com/jquery/jquery/pull/764
-						return elem.document.documentElement["client" + name];
-					}
-
-					// Get document width or height
-					if (elem.nodeType === 9) {
-						doc = elem.documentElement;
-
-						// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], whichever is greatest
-						// unfortunately, this causes bug #3838 in IE6/8 only, but there is currently no good, small way to fix it.
-						return Math.max(
-							elem.body["scroll" + name], doc["scroll" + name],
-							elem.body["offset" + name], doc["offset" + name],
-							doc["client" + name]
-						);
-					}
-
-					return value === undefined ?
-					// Get width or height on the element, requesting but not forcing parseFloat
-					jQuery.css(elem, type, extra) :
-
-					// Set width or height on the element
-					jQuery.style(elem, type, value, extra);
-				}, type, chainable ? margin : undefined, chainable, null);
-			};
-		});
-	});
-	// Limit scope pollution from any deprecated API
-	// (function() {
-
-	// The number of elements contained in the matched element set
-	jQuery.fn.size = function () {
-		return this.length;
-	};
-
-	jQuery.fn.andSelf = jQuery.fn.addBack;
-
-	// })();
-	if (typeof module === "object" && module && typeof module.exports === "object") {
-		// Expose jQuery as module.exports in loaders that implement the Node
-		// module pattern (including browserify). Do not create the global, since
-		// the user will be storing it themselves locally, and globals are frowned
-		// upon in the Node module world.
-		module.exports = jQuery;
-	} else {
-		// Otherwise expose jQuery to the global object as usual
-		window.jQuery = window.$ = jQuery;
-
-		// Register as a named AMD module, since jQuery can be concatenated with other
-		// files that may use define, but not via a proper concatenation script that
-		// understands anonymous AMD modules. A named AMD is safest and most robust
-		// way to register. Lowercase jquery is used because AMD module names are
-		// derived from file names, and jQuery is normally delivered in a lowercase
-		// file name. Do this after creating the global so that if an AMD module wants
-		// to call noConflict to hide this version of jQuery, it will work.
-		if (typeof define === "function" && define.amd) {
-			define("jquery", [], function () {
-				return jQuery;
-			});
-		}
-	}
-
-})(window);
\ No newline at end of file

From 1e83d33283643167c08a0c7c60c79bcb6bdcd00d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Tue, 23 May 2017 15:37:32 -0400
Subject: [PATCH 36/42] tests for login

---
 src/controllers/authentication.js |  54 +++++------
 test/authentication.js            | 146 +++++++++++++++++++-----------
 2 files changed, 122 insertions(+), 78 deletions(-)

diff --git a/src/controllers/authentication.js b/src/controllers/authentication.js
index 5ca9c421ad..cc4ef41aab 100644
--- a/src/controllers/authentication.js
+++ b/src/controllers/authentication.js
@@ -282,14 +282,14 @@ authenticationController.doLogin = function (req, uid, callback) {
 	if (!uid) {
 		return callback();
 	}
-
-	req.login({ uid: uid }, function (err) {
-		if (err) {
-			return callback(err);
-		}
-
-		authenticationController.onSuccessfulLogin(req, uid, callback);
-	});
+	async.waterfall([
+		function (next) {
+			req.login({ uid: uid }, next);
+		},
+		function (next) {
+			authenticationController.onSuccessfulLogin(req, uid, next);
+		},
+	], callback);
 };
 
 authenticationController.onSuccessfulLogin = function (req, uid, callback) {
@@ -312,28 +312,30 @@ authenticationController.onSuccessfulLogin = function (req, uid, callback) {
 		version: req.useragent.version,
 	});
 
-	// Associate login session with user
-	async.parallel([
+	async.waterfall([
 		function (next) {
-			user.auth.addSession(uid, req.sessionID, next);
+			async.parallel([
+				function (next) {
+					user.auth.addSession(uid, req.sessionID, next);
+				},
+				function (next) {
+					db.setObjectField('uid:' + uid + ':sessionUUID:sessionId', uuid, req.sessionID, next);
+				},
+				function (next) {
+					user.updateLastOnlineTime(uid, next);
+				},
+			], function (err) {
+				next(err);
+			});
 		},
 		function (next) {
-			db.setObjectField('uid:' + uid + ':sessionUUID:sessionId', uuid, req.sessionID, next);
-		},
-		function (next) {
-			user.updateLastOnlineTime(uid, next);
-		},
-	], function (err) {
-		if (err) {
-			return callback(err);
-		}
+			// Force session check for all connected socket.io clients with the same session id
+			sockets.in('sess_' + req.sessionID).emit('checkSession', uid);
 
-		// Force session check for all connected socket.io clients with the same session id
-		sockets.in('sess_' + req.sessionID).emit('checkSession', uid);
-
-		plugins.fireHook('action:user.loggedIn', { uid: uid, req: req });
-		callback();
-	});
+			plugins.fireHook('action:user.loggedIn', { uid: uid, req: req });
+			next();
+		},
+	], callback);
 };
 
 authenticationController.localLogin = function (req, username, password, next) {
diff --git a/test/authentication.js b/test/authentication.js
index 9d49a8e0ff..4ab15b500f 100644
--- a/test/authentication.js
+++ b/test/authentication.js
@@ -7,8 +7,37 @@ var request = require('request');
 
 var db = require('./mocks/databasemock');
 var user = require('../src/user');
+var meta = require('../src/meta');
 
 describe('authentication', function () {
+	function loginUser(username, password, callback) {
+		var jar = request.jar();
+		request({
+			url: nconf.get('url') + '/api/config',
+			json: true,
+			jar: jar,
+		}, function (err, response, body) {
+			if (err) {
+				return callback(err);
+			}
+
+			request.post(nconf.get('url') + '/login', {
+				form: {
+					username: username,
+					password: password,
+				},
+				json: true,
+				jar: jar,
+				headers: {
+					'x-csrf-token': body.csrf_token,
+				},
+			}, function (err, response, body) {
+				callback(err, response, body, jar);
+			});
+		});
+	}
+
+
 	var jar = request.jar();
 	var regularUid;
 	before(function (done) {
@@ -89,43 +118,24 @@ describe('authentication', function () {
 	});
 
 	it('should login a user', function (done) {
-		var jar = request.jar();
-		request({
-			url: nconf.get('url') + '/api/config',
-			json: true,
-			jar: jar,
-		}, function (err, response, body) {
+		loginUser('regular', 'regularpwd', function (err, response, body, jar) {
 			assert.ifError(err);
+			assert(body);
 
-			request.post(nconf.get('url') + '/login', {
-				form: {
-					username: 'regular',
-					password: 'regularpwd',
-				},
+			request({
+				url: nconf.get('url') + '/api/me',
 				json: true,
 				jar: jar,
-				headers: {
-					'x-csrf-token': body.csrf_token,
-				},
 			}, function (err, response, body) {
 				assert.ifError(err);
 				assert(body);
-
-				request({
-					url: nconf.get('url') + '/api/me',
-					json: true,
-					jar: jar,
-				}, function (err, response, body) {
+				assert.equal(body.username, 'regular');
+				assert.equal(body.email, 'regular@nodebb.org');
+				db.getObject('uid:' + regularUid + ':sessionUUID:sessionId', function (err, sessions) {
 					assert.ifError(err);
-					assert(body);
-					assert.equal(body.username, 'regular');
-					assert.equal(body.email, 'regular@nodebb.org');
-					db.getObject('uid:' + regularUid + ':sessionUUID:sessionId', function (err, sessions) {
-						assert.ifError(err);
-						assert(sessions);
-						assert(Object.keys(sessions).length > 0);
-						done();
-					});
+					assert(sessions);
+					assert(Object.keys(sessions).length > 0);
+					done();
 				});
 			});
 		});
@@ -148,33 +158,65 @@ describe('authentication', function () {
 	});
 
 	it('should fail to login if user does not exist', function (done) {
-		var jar = request.jar();
-		request({
-			url: nconf.get('url') + '/api/config',
-			json: true,
-			jar: jar,
-		}, function (err, response, body) {
+		loginUser('doesnotexist', 'nopassword', function (err, response, body) {
 			assert.ifError(err);
-
-			request.post(nconf.get('url') + '/login', {
-				form: {
-					username: 'doesnotexist',
-					password: 'nopassword',
-				},
-				json: true,
-				jar: jar,
-				headers: {
-					'x-csrf-token': body.csrf_token,
-				},
-			}, function (err, response, body) {
-				assert.ifError(err);
-				assert.equal(response.statusCode, 403);
-				assert.equal(body, '[[error:invalid-login-credentials]]');
-				done();
-			});
+			assert.equal(response.statusCode, 403);
+			assert.equal(body, '[[error:invalid-login-credentials]]');
+			done();
 		});
 	});
 
+	it('should fail to login if username is empty', function (done) {
+		loginUser('', 'some password', function (err, response, body) {
+			assert.ifError(err);
+			assert.equal(response.statusCode, 403);
+			assert.equal(body, '[[error:invalid-username-or-password]]');
+			done();
+		});
+	});
+
+	it('should fail to login if password is empty', function (done) {
+		loginUser('someuser', '', function (err, response, body) {
+			assert.ifError(err);
+			assert.equal(response.statusCode, 403);
+			assert.equal(body, '[[error:invalid-username-or-password]]');
+			done();
+		});
+	});
+
+	it('should fail to login if username and password are empty', function (done) {
+		loginUser('', '', function (err, response, body) {
+			assert.ifError(err);
+			assert.equal(response.statusCode, 403);
+			assert.equal(body, '[[error:invalid-username-or-password]]');
+			done();
+		});
+	});
+
+	it('should fail to login if password is longer than 4096', function (done) {
+		var longPassword;
+		for (var i = 0; i < 5000; i++) {
+			longPassword += 'a';
+		}
+		loginUser('someuser', longPassword, function (err, response, body) {
+			assert.ifError(err);
+			assert.equal(response.statusCode, 403);
+			assert.equal(body, '[[error:password-too-long]]');
+			done();
+		});
+	});
+
+
+	it('should fail to login if local login is disabled', function (done) {
+		meta.config.allowLocalLogin = 0;
+		loginUser('someuser', 'somepass', function (err, response, body) {
+			meta.config.allowLocalLogin = 1;
+			assert.ifError(err);
+			assert.equal(response.statusCode, 403);
+			assert.equal(body, '[[error:local-login-disabled]]');
+			done();
+		});
+	});
 
 	after(function (done) {
 		db.emptydb(done);

From 542ae5e71f2e89681e74738932a8052c8748eec4 Mon Sep 17 00:00:00 2001
From: Peter Jaszkowiak <p.jaszkow@gmail.com>
Date: Wed, 17 May 2017 15:59:55 -0600
Subject: [PATCH 37/42] Extract in-place translation from bootbox wrapper for
 use anywhere

---
 public/src/modules/translator.js | 66 +++++++++++++++++++++++++++++++-
 public/vendor/bootbox/wrapper.js | 61 ++++-------------------------
 2 files changed, 72 insertions(+), 55 deletions(-)

diff --git a/public/src/modules/translator.js b/public/src/modules/translator.js
index afd64317ef..5296e1eef4 100644
--- a/public/src/modules/translator.js
+++ b/public/src/modules/translator.js
@@ -304,7 +304,7 @@
 		 * Load translation file (or use a cached version), and optionally return the translation of a certain key
 		 * @param {string} namespace - The file name of the translation namespace
 		 * @param {string} [key] - The key of the specific translation to getJSON
-		 * @returns {Promise<Object>|Promise<string>}
+		 * @returns {Promise<{ [key: string]: string }>|Promise<string>}
 		 */
 		Translator.prototype.getTranslation = function getTranslation(namespace, key) {
 			var translation;
@@ -324,6 +324,70 @@
 			return translation;
 		};
 
+		/**
+		 * @param {Node} node
+		 * @returns {Node[]}
+		 */
+		function descendantTextNodes(node) {
+			var textNodes = [];
+
+			function helper(node) {
+				if (node.nodeType === 3) {
+					textNodes.push(node);
+				} else {
+					for (var i = 0, c = node.childNodes, l = c.length; i < l; i += 1) {
+						helper(c[i]);
+					}
+				}
+			}
+
+			helper(node);
+			return textNodes;
+		}
+
+		/**
+		 * Recursively translate a DOM element in place
+		 * @param {Element} element - Root element to translate
+		 * @param {string[]} [attributes] - Array of node attributes to translate
+		 * @returns {Promise<void>}
+		 */
+		Translator.prototype.translateInPlace = function translateInPlace(element, attributes) {
+			attributes = attributes || ['placeholder', 'title'];
+
+			var nodes = descendantTextNodes(element);
+			var text = nodes.map(function (node) {
+				return node.nodeValue;
+			}).join('  ||  ');
+
+			var attrNodes = attributes.reduce(function (prev, attr) {
+				var tuples = Array.prototype.map.call(element.querySelectorAll('[' + attr + '*="[["]'), function (el) {
+					return [attr, el];
+				});
+				return prev.concat(tuples);
+			}, []);
+			var attrText = attrNodes.map(function (node) {
+				return node[1].getAttribute(node[0]);
+			}).join('  ||  ');
+
+			return Promise.all([
+				this.translate(text),
+				this.translate(attrText),
+			]).then(function (ref) {
+				var translated = ref[0];
+				var translatedAttrs = ref[1];
+				if (translated) {
+					translated.split('  ||  ').forEach(function (html, i) {
+						$(nodes[i]).replaceWith(html);
+					});
+				}
+				if (translatedAttrs) {
+					translatedAttrs.split('  ||  ').forEach(function (text, i) {
+						attrNodes[i][1].setAttribute(attrNodes[i][0], text);
+					});
+				}
+			});
+		};
+
 		/**
 		 * Get the language of the current environment, falling back to defaults
 		 * @returns {string}
diff --git a/public/vendor/bootbox/wrapper.js b/public/vendor/bootbox/wrapper.js
index 505b42788f..35efdd8305 100644
--- a/public/vendor/bootbox/wrapper.js
+++ b/public/vendor/bootbox/wrapper.js
@@ -1,67 +1,20 @@
 /* global bootbox */
 
 require(['translator'], function (shim) {
-	"use strict";
-
-	function descendantTextNodes(node) {
-		var textNodes = [];
-
-		function helper(node) {
-			if (node.nodeType === 3) {
-				textNodes.push(node);
-			} else {
-				for (var i = 0, c = node.childNodes, l = c.length; i < l; i += 1) {
-					helper(c[i]);
-				}
-			}
-		}
-
-		helper(node);
-		return textNodes;
-	}
+	'use strict';
 
 	var translator = shim.Translator.create();
 	var dialog = bootbox.dialog;
 	var attrsToTranslate = ['placeholder', 'title', 'value'];
 	bootbox.dialog = function (options) {
-		var show, $elem, nodes, text, attrNodes, attrText;
-
-		show = options.show !== false;
+		var show = options.show !== false;
 		options.show = false;
 
-		$elem = dialog.call(bootbox, options);
+		var $elem = dialog.call(bootbox, options);
+		var element = $elem[0];
 
-		if (/\[\[.+\]\]/.test($elem[0].outerHTML)) {
-			nodes = descendantTextNodes($elem[0]);
-			text = nodes.map(function (node) {
-				return node.nodeValue;
-			}).join('  ||  ');
-
-			attrNodes = attrsToTranslate.reduce(function (prev, attr) {
-				return prev.concat(nodes.map.call($elem.find('[' + attr + '*="[["]'), function (el) {
-					return [attr, el];
-				}));
-			}, []);
-			attrText = attrNodes.map(function (node) {
-				return node[1].getAttribute(node[0]);
-			}).join('  ||  ');
-
-			Promise.all([
-				translator.translate(text),
-				translator.translate(attrText),
-			]).then(function (ref) {
-				var translated = ref[0];
-				var translatedAttrs = ref[1];
-				if (translated) {
-					translated.split('  ||  ').forEach(function (html, i) {
-						$(nodes[i]).replaceWith(html);
-					});
-				}
-				if (translatedAttrs) {
-					translatedAttrs.split('  ||  ').forEach(function (text, i) {
-						attrNodes[i][1].setAttribute(attrNodes[i][0], text);
-					});
-				}
+		if (/\[\[.+\]\]/.test(element.outerHTML)) {
+			translator.translateInPlace(element, attrsToTranslate).then(function () {
 				if (show) {
 					$elem.modal('show');
 				}
@@ -84,7 +37,7 @@ require(['translator'], function (shim) {
 			CANCEL: translations[1],
 			CONFIRM: translations[2],
 		});
-		
+
 		bootbox.setLocale(lang);
 	});
 });

From 5297c31b1c60d11c370bc544dceb26108951742a Mon Sep 17 00:00:00 2001
From: Julian Lam <julian@nodebb.org>
Date: Tue, 23 May 2017 15:41:12 -0400
Subject: [PATCH 38/42] adding yarn.lock to ignore file

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index 469b990863..25ad8bffae 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
+yarn.lock
 npm-debug.log
 node_modules/
 sftp-config.json

From 9625f896656d522a09c5a27208447dcc74ffb05f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Tue, 23 May 2017 15:53:29 -0400
Subject: [PATCH 39/42] remove for loop

---
 src/controllers/authentication.js | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/src/controllers/authentication.js b/src/controllers/authentication.js
index cc4ef41aab..3db8b26472 100644
--- a/src/controllers/authentication.js
+++ b/src/controllers/authentication.js
@@ -26,13 +26,7 @@ authenticationController.register = function (req, res) {
 		return res.sendStatus(403);
 	}
 
-	var userData = {};
-
-	for (var key in req.body) {
-		if (req.body.hasOwnProperty(key)) {
-			userData[key] = req.body[key];
-		}
-	}
+	var userData = req.body;
 
 	async.waterfall([
 		function (next) {

From e4714a0c5832a1e59db461a4c512ddd543b120e5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Tue, 23 May 2017 17:37:16 -0400
Subject: [PATCH 40/42] more auth tests

---
 src/controllers/authentication.js | 25 +++++-----
 test/authentication.js            | 80 +++++++++++++++++++++++++++++++
 2 files changed, 91 insertions(+), 14 deletions(-)

diff --git a/src/controllers/authentication.js b/src/controllers/authentication.js
index 3db8b26472..64823e74b7 100644
--- a/src/controllers/authentication.js
+++ b/src/controllers/authentication.js
@@ -97,21 +97,18 @@ function registerAndLoginUser(req, res, userData, callback) {
 			plugins.fireHook('filter:register.interstitial', {
 				userData: userData,
 				interstitials: [],
-			}, function (err, data) {
-				if (err) {
-					return next(err);
-				}
+			}, next);
+		},
+		function (data, next) {
+			// If interstitials are found, save registration attempt into session and abort
+			var deferRegistration = data.interstitials.length;
 
-				// If interstitials are found, save registration attempt into session and abort
-				var deferRegistration = data.interstitials.length;
-
-				if (!deferRegistration) {
-					return next();
-				}
-				userData.register = true;
-				req.session.registration = userData;
-				return res.json({ referrer: nconf.get('relative_path') + '/register/complete' });
-			});
+			if (!deferRegistration) {
+				return next();
+			}
+			userData.register = true;
+			req.session.registration = userData;
+			return res.json({ referrer: nconf.get('relative_path') + '/register/complete' });
 		},
 		function (next) {
 			user.create(userData, next);
diff --git a/test/authentication.js b/test/authentication.js
index 4ab15b500f..1d3651e183 100644
--- a/test/authentication.js
+++ b/test/authentication.js
@@ -37,6 +37,33 @@ describe('authentication', function () {
 		});
 	}
 
+	function registerUser(email, username, password, callback) {
+		var jar = request.jar();
+		request({
+			url: nconf.get('url') + '/api/config',
+			json: true,
+			jar: jar,
+		}, function (err, response, body) {
+			if (err) {
+				return callback(err);
+			}
+
+			request.post(nconf.get('url') + '/register', {
+				form: {
+					email: email,
+					username: username,
+					password: password,
+				},
+				json: true,
+				jar: jar,
+				headers: {
+					'x-csrf-token': body.csrf_token,
+				},
+			}, function (err, response, body) {
+				callback(err, response, body, jar);
+			});
+		});
+	}
 
 	var jar = request.jar();
 	var regularUid;
@@ -218,6 +245,59 @@ describe('authentication', function () {
 		});
 	});
 
+	it('should fail to register if registraton is disabled', function (done) {
+		meta.config.registrationType = 'disabled';
+		registerUser('some@user.com', 'someuser', 'somepassword', function (err, response, body) {
+			assert.ifError(err);
+			assert.equal(response.statusCode, 403);
+			assert.equal(body, 'Forbidden');
+			done();
+		});
+	});
+
+	it('should return error if invitation is not valid', function (done) {
+		meta.config.registrationType = 'invite-only';
+		registerUser('some@user.com', 'someuser', 'somepassword', function (err, response, body) {
+			meta.config.registrationType = 'normal';
+			assert.ifError(err);
+			assert.equal(response.statusCode, 400);
+			assert.equal(body, '[[error:invalid-data]]');
+			done();
+		});
+	});
+
+	it('should fail to register if email is falsy', function (done) {
+		registerUser('', 'someuser', 'somepassword', function (err, response, body) {
+			assert.ifError(err);
+			assert.equal(response.statusCode, 400);
+			assert.equal(body, '[[error:invalid-email]]');
+			done();
+		});
+	});
+
+	it('should fail to register if username is falsy or too short', function (done) {
+		registerUser('some@user.com', '', 'somepassword', function (err, response, body) {
+			assert.ifError(err);
+			assert.equal(response.statusCode, 400);
+			assert.equal(body, '[[error:username-too-short]]');
+			registerUser('some@user.com', 'a', 'somepassword', function (err, response, body) {
+				assert.ifError(err);
+				assert.equal(response.statusCode, 400);
+				assert.equal(body, '[[error:username-too-short]]');
+				done();
+			});
+		});
+	});
+
+	it('should fail to register if username is too long', function (done) {
+		registerUser('some@user.com', 'thisisareallylongusername', '123456', function (err, response, body) {
+			assert.ifError(err);
+			assert.equal(response.statusCode, 400);
+			assert.equal(body, '[[error:username-too-long]]');
+			done();
+		});
+	});
+
 	after(function (done) {
 		db.emptydb(done);
 	});

From a8c649cca64c7baad12a3d007167e014ddf438dc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Tue, 23 May 2017 17:41:40 -0400
Subject: [PATCH 41/42] check data.uid

---
 src/controllers/authentication.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/controllers/authentication.js b/src/controllers/authentication.js
index 64823e74b7..c8de5c60f1 100644
--- a/src/controllers/authentication.js
+++ b/src/controllers/authentication.js
@@ -82,7 +82,7 @@ authenticationController.register = function (req, res) {
 			return res.status(400).send(err.message);
 		}
 
-		if (req.body.userLang) {
+		if (data.uid && req.body.userLang) {
 			user.setSetting(data.uid, 'userLang', req.body.userLang);
 		}
 

From 2a9cdb7be24f889cc75693f42f4f025d9898860f Mon Sep 17 00:00:00 2001
From: Peter Jaszkowiak <p.jaszkow@gmail.com>
Date: Tue, 23 May 2017 14:00:37 -0600
Subject: [PATCH 42/42] Add `--threads=#` option for setting max threads

Make grunt NODE_ENV development by default
---
 Gruntfile.js         |  2 ++
 src/meta/build.js    |  5 +++++
 src/meta/minifier.js | 16 ++++++++++++++--
 3 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/Gruntfile.js b/Gruntfile.js
index c97795e743..9a84c15aa0 100644
--- a/Gruntfile.js
+++ b/Gruntfile.js
@@ -8,6 +8,8 @@ var initWorker;
 var incomplete = [];
 var running = 0;
 
+env.NODE_ENV = env.NODE_ENV || 'development';
+
 module.exports = function (grunt) {
 	var args = [];
 	var initArgs = ['--build'];
diff --git a/src/meta/build.js b/src/meta/build.js
index cc3321923f..290957512a 100644
--- a/src/meta/build.js
+++ b/src/meta/build.js
@@ -180,6 +180,11 @@ function build(targets, callback) {
 	async.series([
 		beforeBuild,
 		function (next) {
+			var threads = parseInt(nconf.get('threads'), 10);
+			if (threads) {
+				require('./minifier').maxThreads = threads - 1;
+			}
+
 			var parallel = !nconf.get('series');
 			if (parallel) {
 				winston.info('[build] Building in parallel mode');
diff --git a/src/meta/minifier.js b/src/meta/minifier.js
index 7c1a83bea4..07f33d8253 100644
--- a/src/meta/minifier.js
+++ b/src/meta/minifier.js
@@ -41,9 +41,21 @@ function setupDebugging() {
 var pool = [];
 var free = [];
 
-Minifier.maxThreads = os.cpus().length - 1;
+var maxThreads = 0;
 
-winston.verbose('[minifier] utilizing a maximum of ' + Minifier.maxThreads + ' additional threads');
+Object.defineProperty(Minifier, 'maxThreads', {
+	get: function () {
+		return maxThreads;
+	},
+	set: function (val) {
+		maxThreads = val;
+		winston.verbose('[minifier] utilizing a maximum of ' + maxThreads + ' additional threads');
+	},
+	configurable: true,
+	enumerable: true,
+});
+
+Minifier.maxThreads = os.cpus().length - 1;
 
 Minifier.killAll = function () {
 	pool.forEach(function (child) {