https://www.brighthorizons.com/assets/js/brighthorizons.js

914        type: "POST",
915        url: url + "/SendEmail",
916        data: JSON.stringify({
917            firstName: firstName,
918            lastName: lastName,
919            email: email,
920            phoneNumber: phoneNumber,
921            postalCode: postalCode,
922            currentGrade: currentGrade,
923            comments: comments,
924            studentName: studentName,
925            employer: employer
926        }),
927        contentType: "application/json; charset=utf-8",
928        dataType: "json",
929        success: function () {
930            //On a successful submit, hide the form.
931            $(".tutor-help-form").removeClass("active");
932            $(".tutor-help-thankyou").addClass("active");
933        },
934        error: function () {
935            $(".tutor-help-error").addClass("active");
936        }
937    });
938}
939},{}],36:[function(require,module,exports){
940/*!
941 * jQuery JavaScript Library v3.5.1
942 * https://jquery.com/
943 *
944 * Includes Sizzle.js
945 * https://sizzlejs.com/
946 *
947 * Copyright JS Foundation and other contributors
948 * Released under the MIT license
949 * https://jquery.org/license
950 *
951 * Date: 2020-05-04T22:49Z
952 */
953( function( global, factory ) {
954
955	"use strict";
956
957	if ( typeof module === "object" && typeof module.exports === "object" ) {
958
959		// For CommonJS and CommonJS-like environments where a proper `window`
960		// is present, execute the factory and get jQuery.
961		// For environments that do not have a `window` with a `document`
962		// (such as Node.js), expose a factory as module.exports.
963		// This accentuates the need for the creation of a real `window`.
964		// e.g. var jQuery = require("jquery")(window);
965		// See ticket #14549 for more info.
966		module.exports = global.document ?
967			factory( global, true ) :
968			function( w ) {
969				if ( !w.document ) {
970					throw new Error( "jQuery requires a window with a document" );
971				}
972				return factory( w );
973			};
974	} else {
975		factory( global );
976	}
977
978// Pass this if window is not defined yet
979} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
980
981// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
982// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
983// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
984// enough that all such attempts are guarded in a try block.
985"use strict";
986
987var arr = [];
988
989var getProto = Object.getPrototypeOf;
990
991var slice = arr.slice;
992
993var flat = arr.flat ? function( array ) {
994	return arr.flat.call( array );
995} : function( array ) {
996	return arr.concat.apply( [], array );
997};
998
999
1000var push = arr.push;
1001
1002var indexOf = arr.indexOf;
1003
1004var class2type = {};
1005
1006var toString = class2type.toString;
1007
1008var hasOwn = class2type.hasOwnProperty;
1009
1010var fnToString = hasOwn.toString;
1011
1012var ObjectFunctionString = fnToString.call( Object );
1013
1014var support = {};
1015
1016var isFunction = function isFunction( obj ) {
1017
1018      // Support: Chrome <=57, Firefox <=52
1019      // In some browsers, typeof returns "function" for HTML <object> elements
1020      // (i.e., `typeof document.createElement( "object" ) === "function"`).
1021      // We don't want to classify *any* DOM node as a function.
1022      return typeof obj === "function" && typeof obj.nodeType !== "number";
1023  };
1024
1025
1026var isWindow = function isWindow( obj ) {
1027		return obj != null && obj === obj.window;
1028	};
1029
1030
1031var document = window.document;
1032
1033
1034
1035	var preservedScriptAttributes = {
1036		type: true,
1037		src: true,
1038		nonce: true,
1039		noModule: true
1040	};
1041
1042	function DOMEval( code, node, doc ) {
1043		doc = doc || document;
1044
1045		var i, val,
1046			script = doc.createElement( "script" );
1047
1048		script.text = code;
1049		if ( node ) {
1050			for ( i in preservedScriptAttributes ) {
1051
1052				// Support: Firefox 64+, Edge 18+
1053				// Some browsers don't support the "nonce" property on scripts.
1054				// On the other hand, just using `getAttribute` is not enough as
1055				// the `nonce` attribute is reset to an empty string whenever it
1056				// becomes browsing-context connected.
1057				// See https://github.com/whatwg/html/issues/2369

1058				// See https://html.spec.whatwg.org/#nonce-attributes
1059				// The `node.getAttribute` check was added for the sake of
1060				// `jQuery.globalEval` so that it can fake a nonce-containing node
1061				// via an object.
1062				val = node[ i ] || node.getAttribute && node.getAttribute( i );
1063				if ( val ) {
1064					script.setAttribute( i, val );
1065				}
1066			}
1067		}
1068		doc.head.appendChild( script ).parentNode.removeChild( script );
1069	}
1070
1071
1072function toType( obj ) {
1073	if ( obj == null ) {
1074		return obj + "";
1075	}
1076
1077	// Support: Android <=2.3 only (functionish RegExp)
1078	return typeof obj === "object" || typeof obj === "function" ?
1079		class2type[ toString.call( obj ) ] || "object" :
1080		typeof obj;
1081}
1082/* global Symbol */
1083// Defining this global in .eslintrc.json would create a danger of using the global
1084// unguarded in another place, it seems safer to define global only for this module
1085
1086
1087
1088var
1089	version = "3.5.1",
1090
1091	// Define a local copy of jQuery
1092	jQuery = function( selector, context ) {
1093
1094		// The jQuery object is actually just the init constructor 'enhanced'
1095		// Need init if jQuery is called (just allow error to be thrown if not included)
1096		return new jQuery.fn.init( selector, context );
1097	};
1098
1099jQuery.fn = jQuery.prototype = {
1100
1101	// The current version of jQuery being used
1102	jquery: version,
1103
1104	constructor: jQuery,
1105
1106	// The default length of a jQuery object is 0
1107	length: 0,
1108
1109	toArray: function() {
1110		return slice.call( this );
1111	},
1112
1113	// Get the Nth element in the matched element set OR
1114	// Get the whole matched element set as a clean array
1115	get: function( num ) {
1116
1117		// Return all the elements in a clean array
1118		if ( num == null ) {
1119			return slice.call( this );
1120		}
1121
1122		// Return just the one element from the set
1123		return num < 0 ? this[ num + this.length ] : this[ num ];
1124	},
1125
1126	// Take an array of elements and push it onto the stack
1127	// (returning the new matched element set)
1128	pushStack: function( elems ) {
1129
1130		// Build a new jQuery matched element set
1131		var ret = jQuery.merge( this.constructor(), elems );
1132
1133		// Add the old object onto the stack (as a reference)
1134		ret.prevObject = this;
1135
1136		// Return the newly-formed element set
1137		return ret;
1138	},
1139
1140	// Execute a callback for every element in the matched set.
1141	each: function( callback ) {
1142		return jQuery.each( this, callback );
1143	},
1144
1145	map: function( callback ) {
1146		return this.pushStack( jQuery.map( this, function( elem, i ) {
1147			return callback.call( elem, i, elem );
1148		} ) );
1149	},
1150
1151	slice: function() {
1152		return this.pushStack( slice.apply( this, arguments ) );
1153	},
1154
1155	first: function() {
1156		return this.eq( 0 );
1157	},
1158
1159	last: function() {
1160		return this.eq( -1 );
1161	},
1162
1163	even: function() {
1164		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
1165			return ( i + 1 ) % 2;
1166		} ) );
1167	},
1168
1169	odd: function() {
1170		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
1171			return i % 2;
1172		} ) );
1173	},
1174
1175	eq: function( i ) {
1176		var len = this.length,
1177			j = +i + ( i < 0 ? len : 0 );
1178		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
1179	},
1180
1181	end: function() {
1182		return this.prevObject || this.constructor();
1183	},
1184
1185	// For internal use only.
1186	// Behaves like an Array's method, not like a jQuery method.
1187	push: push,
1188	sort: arr.sort,
1189	splice: arr.splice
1190};
1191
1192jQuery.extend = jQuery.fn.extend = function() {
1193	var options, name, src, copy, copyIsArray, clone,
1194		target = arguments[ 0 ] || {},
1195		i = 1,
1196		length = arguments.length,
1197		deep = false;
1198
1199	// Handle a deep copy situation
1200	if ( typeof target === "boolean" ) {
1201		deep = target;
1202
1203		// Skip the boolean and the target
1204		target = arguments[ i ] || {};
1205		i++;
1206	}
1207
1208	// Handle case when target is a string or something (possible in deep copy)
1209	if ( typeof target !== "object" && !isFunction( target ) ) {
1210		target = {};
1211	}
1212
1213	// Extend jQuery itself if only one argument is passed
1214	if ( i === length ) {
1215		target = this;
1216		i--;
1217	}
1218
1219	for ( ; i < length; i++ ) {
1220
1221		// Only deal with non-null/undefined values
1222		if ( ( options = arguments[ i ] ) != null ) {
1223
1224			// Extend the base object
1225			for ( name in options ) {
1226				copy = options[ name ];
1227
1228				// Prevent Object.prototype pollution
1229				// Prevent never-ending loop

1230				if ( name === "__proto__" || target === copy ) {
1231					continue;
1232				}
1233
1234				// Recurse if we're merging plain objects or arrays
1235				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
1236					( copyIsArray = Array.isArray( copy ) ) ) ) {
1237					src = target[ name ];
1238
1239					// Ensure proper type for the source value
1240					if ( copyIsArray && !Array.isArray( src ) ) {
1241						clone = [];
1242					} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
1243						clone = {};
1244					} else {
1245						clone = src;
1246					}
1247					copyIsArray = false;
1248
1249					// Never move original objects, clone them
1250					target[ name ] = jQuery.extend( deep, clone, copy );
1251
1252				// Don't bring in undefined values
1253				} else if ( copy !== undefined ) {
1254					target[ name ] = copy;
1255				}
1256			}
1257		}
1258	}
1259
1260	// Return the modified object
1261	return target;
1262};
1263
1264jQuery.extend( {
1265
1266	// Unique for each copy of jQuery on the page
1267	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
1268
1269	// Assume jQuery is ready without the ready module
1270	isReady: true,
1271
1272	error: function( msg ) {
1273		throw new Error( msg );
1274	},
1275
1276	noop: function() {},
1277
1278	isPlainObject: function( obj ) {
1279		var proto, Ctor;
1280
1281		// Detect obvious negatives
1282		// Use toString instead of jQuery.type to catch host objects
1283		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
1284			return false;
1285		}
1286
1287		proto = getProto( obj );
1288
1289		// Objects with no prototype (e.g., `Object.create( null )`) are plain
1290		if ( !proto ) {
1291			return true;
1292		}
1293
1294		// Objects with prototype are plain iff they were constructed by a global Object function
1295		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
1296		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
1297	},
1298
1299	isEmptyObject: function( obj ) {
1300		var name;
1301
1302		for ( name in obj ) {
1303			return false;
1304		}
1305		return true;
1306	},
1307
1308	// Evaluates a script in a provided context; falls back to the global one
1309	// if not specified.
1310	globalEval: function( code, options, doc ) {
1311		DOMEval( code, { nonce: options && options.nonce }, doc );
1312	},
1313
1314	each: function( obj, callback ) {
1315		var length, i = 0;
1316
1317		if ( isArrayLike( obj ) ) {
1318			length = obj.length;
1319			for ( ; i < length; i++ ) {
1320				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
1321					break;
1322				}
1323			}
1324		} else {
1325			for ( i in obj ) {
1326				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
1327					break;
1328				}
1329			}
1330		}
1331
1332		return obj;
1333	},
1334
1335	// results is for internal usage only
1336	makeArray: function( arr, results ) {
1337		var ret = results || [];
1338
1339		if ( arr != null ) {
1340			if ( isArrayLike( Object( arr ) ) ) {
1341				jQuery.merge( ret,
1342					typeof arr === "string" ?
1343					[ arr ] : arr
1344				);
1345			} else {
1346				push.call( ret, arr );
1347			}
1348		}
1349
1350		return ret;
1351	},
1352
1353	inArray: function( elem, arr, i ) {
1354		return arr == null ? -1 : indexOf.call( arr, elem, i );
1355	},
1356
1357	// Support: Android <=4.0 only, PhantomJS 1 only
1358	// push.apply(_, arraylike) throws on ancient WebKit
1359	merge: function( first, second ) {
1360		var len = +second.length,
1361			j = 0,
1362			i = first.length;
1363
1364		for ( ; j < len; j++ ) {
1365			first[ i++ ] = second[ j ];
1366		}
1367
1368		first.length = i;
1369
1370		return first;
1371	},
1372
1373	grep: function( elems, callback, invert ) {
1374		var callbackInverse,
1375			matches = [],
1376			i = 0,
1377			length = elems.length,
1378			callbackExpect = !invert;
1379
1380		// Go through the array, only saving the items
1381		// that pass the validator function
1382		for ( ; i < length; i++ ) {
1383			callbackInverse = !callback( elems[ i ], i );
1384			if ( callbackInverse !== callbackExpect ) {
1385				matches.push( elems[ i ] );
1386			}
1387		}
1388
1389		return matches;
1390	},
1391
1392	// arg is for internal usage only
1393	map: function( elems, callback, arg ) {
1394		var length, value,
1395			i = 0,
1396			ret = [];
1397
1398		// Go through the array, translating each of the items to their new values
1399		if ( isArrayLike( elems ) ) {
1400			length = elems.length;
1401			for ( ; i < length; i++ ) {
1402				value = callback( elems[ i ], i, arg );
1403
1404				if ( value != null ) {

1405					ret.push( value );
1406				}
1407			}
1408
1409		// Go through every key on the object,
1410		} else {
1411			for ( i in elems ) {
1412				value = callback( elems[ i ], i, arg );
1413
1414				if ( value != null ) {
1415					ret.push( value );
1416				}
1417			}
1418		}
1419
1420		// Flatten any nested arrays
1421		return flat( ret );
1422	},
1423
1424	// A global GUID counter for objects
1425	guid: 1,
1426
1427	// jQuery.support is not used in Core but other projects attach their
1428	// properties to it so it needs to exist.
1429	support: support
1430} );
1431
1432if ( typeof Symbol === "function" ) {
1433	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
1434}
1435
1436// Populate the class2type map
1437jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
1438function( _i, name ) {
1439	class2type[ "[object " + name + "]" ] = name.toLowerCase();
1440} );
1441
1442function isArrayLike( obj ) {
1443
1444	// Support: real iOS 8.2 only (not reproducible in simulator)
1445	// `in` check used to prevent JIT error (gh-2145)
1446	// hasOwn isn't used here due to false negatives
1447	// regarding Nodelist length in IE
1448	var length = !!obj && "length" in obj && obj.length,
1449		type = toType( obj );
1450
1451	if ( isFunction( obj ) || isWindow( obj ) ) {
1452		return false;
1453	}
1454
1455	return type === "array" || length === 0 ||
1456		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
1457}
1458var Sizzle =
1459/*!
1460 * Sizzle CSS Selector Engine v2.3.5
1461 * https://sizzlejs.com/
1462 *
1463 * Copyright JS Foundation and other contributors
1464 * Released under the MIT license
1465 * https://js.foundation/
1466 *
1467 * Date: 2020-03-14
1468 */
1469( function( window ) {
1470var i,
1471	support,
1472	Expr,
1473	getText,
1474	isXML,
1475	tokenize,
1476	compile,
1477	select,
1478	outermostContext,
1479	sortInput,
1480	hasDuplicate,
1481
1482	// Local document vars
1483	setDocument,
1484	document,
1485	docElem,
1486	documentIsHTML,
1487	rbuggyQSA,
1488	rbuggyMatches,
1489	matches,
1490	contains,
1491
1492	// Instance-specific data
1493	expando = "sizzle" + 1 * new Date(),
1494	preferredDoc = window.document,
1495	dirruns = 0,
1496	done = 0,
1497	classCache = createCache(),
1498	tokenCache = createCache(),
1499	compilerCache = createCache(),
1500	nonnativeSelectorCache = createCache(),
1501	sortOrder = function( a, b ) {
1502		if ( a === b ) {
1503			hasDuplicate = true;
1504		}
1505		return 0;
1506	},
1507
1508	// Instance methods
1509	hasOwn = ( {} ).hasOwnProperty,
1510	arr = [],
1511	pop = arr.pop,
1512	pushNative = arr.push,
1513	push = arr.push,
1514	slice = arr.slice,
1515
1516	// Use a stripped-down indexOf as it's faster than native
1517	// https://jsperf.com/thor-indexof-vs-for/5
1518	indexOf = function( list, elem ) {
1519		var i = 0,
1520			len = list.length;
1521		for ( ; i < len; i++ ) {
1522			if ( list[ i ] === elem ) {
1523				return i;
1524			}
1525		}
1526		return -1;
1527	},
1528
1529	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" +
1530		"ismap|loop|multiple|open|readonly|required|scoped",
1531
1532	// Regular expressions
1533
1534	// http://www.w3.org/TR/css3-selectors/#whitespace
1535	whitespace = "[\\x20\\t\\r\\n\\f]",
1536
1537	// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
1538	identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace +
1539		"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
1540
1541	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
1542	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
1543
1544		// Operator (capture 2)
1545		"*([*^$|!~]?=)" + whitespace +
1546
1547		// "Attribute values must be CSS identifiers [capture 5]
1548		// or strings [capture 3 or capture 4]"
1549		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" +
1550		whitespace + "*\\]",
1551
1552	pseudos = ":(" + identifier + ")(?:\\((" +
1553
1554		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
1555		// 1. quoted (capture 3; capture 4 or capture 5)
1556		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
1557
1558		// 2. simple (capture 6)
1559		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
1560
1561		// 3. anything else (capture 2)
1562		".*" +
1563		")\\)|)",
1564
1565	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
1566	rwhitespace = new RegExp( whitespace + "+", "g" ),
1567	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" +
1568		whitespace + "+$", "g" ),
1569
1570	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
1571	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace +
1572		"*" ),
1573	rdescend = new RegExp( whitespace + "|>" ),
1574
1575	rpseudo = new RegExp( pseudos ),
1576	ridentifier = new RegExp( "^" + identifier + "$" ),
1577
1578	matchExpr = {
1579		"ID": new RegExp( "^#(" + identifier + ")" ),
1580		"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
1581		"TAG": new RegExp( "^(" + identifier + "|[*])" ),
1582		"ATTR": new RegExp( "^" + attributes ),
1583		"PSEUDO": new RegExp( "^" + pseudos ),
1584		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
1585			whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" +
1586			whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
1587		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
1588
1589		// For use in libraries implementing .is()
1590		// We use this for POS matching in `select`
1591		"needsContext": new RegExp( "^" + whitespace +
1592			"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
1593			"*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
1594	},
1595
1596	rhtml = /HTML$/i,
1597	rinputs = /^(?:input|select|textarea|button)$/i,
1598	rheader = /^h\d$/i,
1599
1600	rnative = /^[^{]+\{\s*\[native \w/,
1601
1602	// Easily-parseable/retrievable ID or TAG or CLASS selectors
1603	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
1604
1605	rsibling = /[+~]/,
1606
1607	// CSS escapes
1608	// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
1609	runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g" ),
1610	funescape = function( escape, nonHex ) {
1611		var high = "0x" + escape.slice( 1 ) - 0x10000;
1612
1613		return nonHex ?
1614
1615			// Strip the backslash prefix from a non-hex escape sequence
1616			nonHex :
1617
1618			// Replace a hexadecimal escape sequence with the encoded Unicode code point
1619			// Support: IE <=11+
1620			// For values outside the Basic Multilingual Plane (BMP), manually construct a
1621			// surrogate pair
1622			high < 0 ?
1623				String.fromCharCode( high + 0x10000 ) :
1624				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
1625	},
1626
1627	// CSS string/identifier serialization
1628	// https://drafts.csswg.org/cssom/#common-serializing-idioms
1629	rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
1630	fcssescape = function( ch, asCodePoint ) {
1631		if ( asCodePoint ) {
1632
1633			// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
1634			if ( ch === "\0" ) {
1635				return "\uFFFD";
1636			}
1637
1638			// Control characters and (dependent upon position) numbers get escaped as code points
1639			return ch.slice( 0, -1 ) + "\\" +
1640				ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
1641		}
1642
1643		// Other potentially-special ASCII characters get backslash-escaped
1644		return "\\" + ch;
1645	},
1646
1647	// Used for iframes
1648	// See setDocument()
1649	// Removing the function wrapper causes a "Permission Denied"
1650	// error in IE
1651	unloadHandler = function() {
1652		setDocument();
1653	},
1654
1655	inDisabledFieldset = addCombinator(
1656		function( elem ) {
1657			return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
1658		},
1659		{ dir: "parentNode", next: "legend" }
1660	);
1661
1662// Optimize for push.apply( _, NodeList )
1663try {
1664	push.apply(
1665		( arr = slice.call( preferredDoc.childNodes ) ),
1666		preferredDoc.childNodes
1667	);
1668
1669	// Support: Android<4.0
1670	// Detect silently failing push.apply
1671	// eslint-disable-next-line no-unused-expressions
1672	arr[ preferredDoc.childNodes.length ].nodeType;
1673} catch ( e ) {
1674	push = { apply: arr.length ?
1675
1676		// Leverage slice if possible
1677		function( target, els ) {
1678			pushNative.apply( target, slice.call( els ) );
1679		} :
1680
1681		// Support: IE<9
1682		// Otherwise append directly
1683		function( target, els ) {
1684			var j = target.length,
1685				i = 0;
1686
1687			// Can't trust NodeList.length
1688			while ( ( target[ j++ ] = els[ i++ ] ) ) {}
1689			target.length = j - 1;
1690		}
1691	};
1692}
1693
1694function Sizzle( selector, context, results, seed ) {
1695	var m, i, elem, nid, match, groups, newSelector,
1696		newContext = context && context.ownerDocument,
1697
1698		// nodeType defaults to 9, since context defaults to document
1699		nodeType = context ? context.nodeType : 9;
1700
1701	results = results || [];
1702
1703	// Return early from calls with invalid selector or context
1704	if ( typeof selector !== "string" || !selector ||
1705		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
1706
1707		return results;
1708	}
1709
1710	// Try to shortcut find operations (as opposed to filters) in HTML documents
1711	if ( !seed ) {
1712		setDocument( context );
1713		context = context || document;
1714
1715		if ( documentIsHTML ) {
1716
1717			// If the selector is sufficiently simple, try using a "get*By*" DOM method
1718			// (excepting DocumentFragment context, where the methods don't exist)
1719			if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {
1720
1721				// ID selector
1722				if ( ( m = match[ 1 ] ) ) {
1723
1724					// Document context
1725					if ( nodeType === 9 ) {
1726						if ( ( elem = context.getElementById( m ) ) ) {
1727
1728							// Support: IE, Opera, Webkit
1729							// TODO: identify versions
1730							// getElementById can match elements by name instead of ID
1731							if ( elem.id === m ) {
1732								results.push( elem );
1733								return results;
1734							}
1735						} else {
1736							return results;
1737						}
1738
1739					// Element context
1740					} else {
1741
1742						// Support: IE, Opera, Webkit
1743						// TODO: identify versions
1744						// getElementById can match elements by name instead of ID
1745						if ( newContext && ( elem = newContext.getElementById( m ) ) &&
1746							contains( context, elem ) &&
1747							elem.id === m ) {
1748
1749							results.push( elem );
1750							return results;
1751						}
1752					}
1753
1754				// Type selector
1755				} else if ( match[ 2 ] ) {
1756					push.apply( results, context.getElementsByTagName( selector ) );
1757					return results;
1758
1759				// Class selector
1760				} else if ( ( m = match[ 3 ] ) && support.getElementsByClassName &&
1761					context.getElementsByClassName ) {
1762
1763					push.apply( results, context.getElementsByClassName( m ) );
1764					return results;
1765				}
1766			}
1767
1768			// Take advantage of querySelectorAll
1769			if ( support.qsa &&
1770				!nonnativeSelectorCache[ selector + " " ] &&
1771				( !rbuggyQSA || !rbuggyQSA.test( selector ) ) &&
1772
1773				// Support: IE 8 only
1774				// Exclude object elements
1775				( nodeType !== 1 || context.nodeName.toLowerCase() !== "object" ) ) {
1776
1777				newSelector = selector;
1778				newContext = context;
1779
1780				// qSA considers elements outside a scoping root when evaluating child or
1781				// descendant combinators, which is not what we want.
1782				// In such cases, we work around the behavior by prefixing every selector in the
1783				// list with an ID selector referencing the scope context.
1784				// The technique has to be used as well when a leading combinator is used
1785				// as such selectors are not recognized by querySelectorAll.
1786				// Thanks to Andrew Dupont for this technique.
1787				if ( nodeType === 1 &&
1788					( rdescend.test( selector ) || rcombinators.test( selector ) ) ) {
1789
1790					// Expand context for sibling selectors
1791					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
1792						context;
1793
1794					// We can use :scope instead of the ID hack if the browser
1795					// supports it & if we're not changing the context.
1796					if ( newContext !== context || !support.scope ) {
1797
1798						// Capture the context ID, setting it first if necessary
1799						if ( ( nid = context.getAttribute( "id" ) ) ) {
1800							nid = nid.replace( rcssescape, fcssescape );
1801						} else {
1802							context.setAttribute( "id", ( nid = expando ) );
1803						}
1804					}
1805
1806					// Prefix every selector in the list
1807					groups = tokenize( selector );
1808					i = groups.length;
1809					while ( i-- ) {
1810						groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " +
1811							toSelector( groups[ i ] );
1812					}
1813					newSelector = groups.join( "," );
1814				}
1815
1816				try {
1817					push.apply( results,
1818						newContext.querySelectorAll( newSelector )
1819					);
1820					return results;
1821				} catch ( qsaError ) {
1822					nonnativeSelectorCache( selector, true );
1823				} finally {
1824					if ( nid === expando ) {
1825						context.removeAttribute( "id" );
1826					}
1827				}
1828			}
1829		}
1830	}
1831
1832	// All others
1833	return select( selector.replace( rtrim, "$1" ), context, results, seed );
1834}
1835
1836/**
1837 * Create key-value caches of limited size
1838 * @returns {function(string, object)} Returns the Object data after storing it on itself with
1839 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
1840 *	deleting the oldest entry
1841 */
1842function createCache() {
1843	var keys = [];
1844
1845	function cache( key, value ) {
1846
1847		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
1848		if ( keys.push( key + " " ) > Expr.cacheLength ) {
1849
1850			// Only keep the most recent entries
1851			delete cache[ keys.shift() ];
1852		}
1853		return ( cache[ key + " " ] = value );
1854	}
1855	return cache;
1856}
1857
1858/**
1859 * Mark a function for special use by Sizzle
1860 * @param {Function} fn The function to mark
1861 */
1862function markFunction( fn ) {
1863	fn[ expando ] = true;
1864	return fn;
1865}
1866
1867/**
1868 * Support testing using an element
1869 * @param {Function} fn Passed the created element and returns a boolean result
1870 */
1871function assert( fn ) {
1872	var el = document.createElement( "fieldset" );
1873
1874	try {
1875		return !!fn( el );
1876	} catch ( e ) {
1877		return false;
1878	} finally {
1879
1880		// Remove from its parent by default
1881		if ( el.parentNode ) {
1882			el.parentNode.removeChild( el );
1883		}
1884
1885		// release memory in IE
1886		el = null;
1887	}
1888}
1889
1890/**
1891 * Adds the same handler for all of the specified attrs
1892 * @param {String} attrs Pipe-separated list of attributes
1893 * @param {Function} handler The method that will be applied
1894 */
1895function addHandle( attrs, handler ) {
1896	var arr = attrs.split( "|" ),
1897		i = arr.length;
1898
1899	while ( i-- ) {
1900		Expr.attrHandle[ arr[ i ] ] = handler;
1901	}
1902}
1903
1904/**
1905 * Checks document order of two siblings
1906 * @param {Element} a
1907 * @param {Element} b
1908 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
1909 */
1910function siblingCheck( a, b ) {
1911	var cur = b && a,
1912		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
1913			a.sourceIndex - b.sourceIndex;
1914
1915	// Use IE sourceIndex if available on both nodes
1916	if ( diff ) {
1917		return diff;
1918	}
1919
1920	// Check if b follows a
1921	if ( cur ) {
1922		while ( ( cur = cur.nextSibling ) ) {
1923			if ( cur === b ) {
1924				return -1;
1925			}
1926		}
1927	}
1928
1929	return a ? 1 : -1;
1930}
1931
1932/**
1933 * Returns a function to use in pseudos for input types
1934 * @param {String} type
1935 */
1936function createInputPseudo( type ) {
1937	return function( elem ) {
1938		var name = elem.nodeName.toLowerCase();
1939		return name === "input" && elem.type === type;
1940	};
1941}
1942
1943/**
1944 * Returns a function to use in pseudos for buttons
1945 * @param {String} type
1946 */
1947function createButtonPseudo( type ) {
1948	return function( elem ) {
1949		var name = elem.nodeName.toLowerCase();
1950		return ( name === "input" || name === "button" ) && elem.type === type;
1951	};
1952}
1953
1954/**
1955 * Returns a function to use in pseudos for :enabled/:disabled
1956 * @param {Boolean} disabled true for :disabled; false for :enabled
1957 */
1958function createDisabledPseudo( disabled ) {
1959
1960	// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
1961	return function( elem ) {
1962
1963		// Only certain elements can match :enabled or :disabled
1964		// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
1965		// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
1966		if ( "form" in elem ) {
1967
1968			// Check for inherited disabledness on relevant non-disabled elements:
1969			// * listed form-associated elements in a disabled fieldset
1970			//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
1971			//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
1972			// * option elements in a disabled optgroup
1973			//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
1974			// All such elements have a "form" property.
1975			if ( elem.parentNode && elem.disabled === false ) {
1976
1977				// Option elements defer to a parent optgroup if present
1978				if ( "label" in elem ) {
1979					if ( "label" in elem.parentNode ) {
1980						return elem.parentNode.disabled === disabled;
1981					} else {
1982						return elem.disabled === disabled;
1983					}
1984				}
1985
1986				// Support: IE 6 - 11
1987				// Use the isDisabled shortcut property to check for disabled fieldset ancestors
1988				return elem.isDisabled === disabled ||
1989
1990					// Where there is no isDisabled, check manually
1991					/* jshint -W018 */
1992					elem.isDisabled !== !disabled &&
1993					inDisabledFieldset( elem ) === disabled;
1994			}
1995
1996			return elem.disabled === disabled;
1997
1998		// Try to winnow out elements that can't be disabled before trusting the disabled property.
1999		// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
2000		// even exist on them, let alone have a boolean value.
2001		} else if ( "label" in elem ) {
2002			return elem.disabled === disabled;
2003		}
2004
2005		// Remaining elements are neither :enabled nor :disabled
2006		return false;
2007	};
2008}
2009
2010/**
2011 * Returns a function to use in pseudos for positionals
2012 * @param {Function} fn
2013 */
2014function createPositionalPseudo( fn ) {
2015	return markFunction( function( argument ) {
2016		argument = +argument;
2017		return markFunction( function( seed, matches ) {
2018			var j,
2019				matchIndexes = fn( [], seed.length, argument ),
2020				i = matchIndexes.length;
2021
2022			// Match elements found at the specified indexes
2023			while ( i-- ) {
2024				if ( seed[ ( j = matchIndexes[ i ] ) ] ) {
2025					seed[ j ] = !( matches[ j ] = seed[ j ] );
2026				}
2027			}
2028		} );
2029	} );
2030}
2031
2032/**
2033 * Checks a node for validity as a Sizzle context
2034 * @param {Element|Object=} context
2035 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
2036 */
2037function testContext( context ) {
2038	return context && typeof context.getElementsByTagName !== "undefined" && context;
2039}
2040
2041// Expose support vars for convenience
2042support = Sizzle.support = {};
2043
2044/**
2045 * Detects XML nodes
2046 * @param {Element|Object} elem An element or a document
2047 * @returns {Boolean} True iff elem is a non-HTML XML node
2048 */
2049isXML = Sizzle.isXML = function( elem ) {
2050	var namespace = elem.namespaceURI,
2051		docElem = ( elem.ownerDocument || elem ).documentElement;
2052
2053	// Support: IE <=8
2054	// Assume HTML when documentElement doesn't yet exist, such as inside loading iframes
2055	// https://bugs.jquery.com/ticket/4833
2056	return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" );
2057};
2058
2059/**
2060 * Sets document-related variables once based on the current document
2061 * @param {Element|Object} [doc] An element or document object to use to set the document
2062 * @returns {Object} Returns the current document
2063 */
2064setDocument = Sizzle.setDocument = function( node ) {
2065	var hasCompare, subWindow,
2066		doc = node ? node.ownerDocument || node : preferredDoc;
2067
2068	// Return early if doc is invalid or already selected
2069	// Support: IE 11+, Edge 17 - 18+
2070	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2071	// two documents; shallow comparisons work.
2072	// eslint-disable-next-line eqeqeq
2073	if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {
2074		return document;
2075	}
2076
2077	// Update global variables
2078	document = doc;
2079	docElem = document.documentElement;
2080	documentIsHTML = !isXML( document );
2081
2082	// Support: IE 9 - 11+, Edge 12 - 18+
2083	// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
2084	// Support: IE 11+, Edge 17 - 18+
2085	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2086	// two documents; shallow comparisons work.
2087	// eslint-disable-next-line eqeqeq
2088	if ( preferredDoc != document &&
2089		( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {
2090
2091		// Support: IE 11, Edge
2092		if ( subWindow.addEventListener ) {
2093			subWindow.addEventListener( "unload", unloadHandler, false );
2094
2095		// Support: IE 9 - 10 only
2096		} else if ( subWindow.attachEvent ) {
2097			subWindow.attachEvent( "onunload", unloadHandler );
2098		}
2099	}
2100
2101	// Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,
2102	// Safari 4 - 5 only, Opera <=11.6 - 12.x only
2103	// IE/Edge & older browsers don't support the :scope pseudo-class.
2104	// Support: Safari 6.0 only
2105	// Safari 6.0 supports :scope but it's an alias of :root there.
2106	support.scope = assert( function( el ) {
2107		docElem.appendChild( el ).appendChild( document.createElement( "div" ) );
2108		return typeof el.querySelectorAll !== "undefined" &&
2109			!el.querySelectorAll( ":scope fieldset div" ).length;
2110	} );
2111
2112	/* Attributes
2113	---------------------------------------------------------------------- */
2114
2115	// Support: IE<8
2116	// Verify that getAttribute really returns attributes and not properties
2117	// (excepting IE8 booleans)
2118	support.attributes = assert( function( el ) {
2119		el.className = "i";
2120		return !el.getAttribute( "className" );
2121	} );
2122
2123	/* getElement(s)By*
2124	---------------------------------------------------------------------- */
2125
2126	// Check if getElementsByTagName("*") returns only elements
2127	support.getElementsByTagName = assert( function( el ) {
2128		el.appendChild( document.createComment( "" ) );
2129		return !el.getElementsByTagName( "*" ).length;
2130	} );
2131
2132	// Support: IE<9
2133	support.getElementsByClassName = rnative.test( document.getElementsByClassName );
2134
2135	// Support: IE<10
2136	// Check if getElementById returns elements by name
2137	// The broken getElementById methods don't pick up programmatically-set names,
2138	// so use a roundabout getElementsByName test
2139	support.getById = assert( function( el ) {
2140		docElem.appendChild( el ).id = expando;
2141		return !document.getElementsByName || !document.getElementsByName( expando ).length;
2142	} );
2143
2144	// ID filter and find
2145	if ( support.getById ) {
2146		Expr.filter[ "ID" ] = function( id ) {
2147			var attrId = id.replace( runescape, funescape );
2148			return function( elem ) {
2149				return elem.getAttribute( "id" ) === attrId;
2150			};
2151		};
2152		Expr.find[ "ID" ] = function( id, context ) {
2153			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
2154				var elem = context.getElementById( id );
2155				return elem ? [ elem ] : [];
2156			}
2157		};
2158	} else {
2159		Expr.filter[ "ID" ] =  function( id ) {
2160			var attrId = id.replace( runescape, funescape );
2161			return function( elem ) {
2162				var node = typeof elem.getAttributeNode !== "undefined" &&
2163					elem.getAttributeNode( "id" );
2164				return node && node.value === attrId;
2165			};
2166		};
2167
2168		// Support: IE 6 - 7 only
2169		// getElementById is not reliable as a find shortcut
2170		Expr.find[ "ID" ] = function( id, context ) {
2171			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
2172				var node, i, elems,
2173					elem = context.getElementById( id );
2174
2175				if ( elem ) {
2176
2177					// Verify the id attribute
2178					node = elem.getAttributeNode( "id" );
2179					if ( node && node.value === id ) {
2180						return [ elem ];
2181					}
2182
2183					// Fall back on getElementsByName
2184					elems = context.getElementsByName( id );
2185					i = 0;
2186					while ( ( elem = elems[ i++ ] ) ) {
2187						node = elem.getAttributeNode( "id" );
2188						if ( node && node.value === id ) {
2189							return [ elem ];
2190						}
2191					}
2192				}
2193
2194				return [];
2195			}
2196		};
2197	}
2198
2199	// Tag
2200	Expr.find[ "TAG" ] = support.getElementsByTagName ?
2201		function( tag, context ) {
2202			if ( typeof context.getElementsByTagName !== "undefined" ) {
2203				return context.getElementsByTagName( tag );
2204
2205			// DocumentFragment nodes don't have gEBTN
2206			} else if ( support.qsa ) {
2207				return context.querySelectorAll( tag );
2208			}
2209		} :
2210
2211		function( tag, context ) {
2212			var elem,
2213				tmp = [],
2214				i = 0,
2215
2216				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
2217				results = context.getElementsByTagName( tag );
2218
2219			// Filter out possible comments
2220			if ( tag === "*" ) {
2221				while ( ( elem = results[ i++ ] ) ) {
2222					if ( elem.nodeType === 1 ) {
2223						tmp.push( elem );
2224					}
2225				}
2226
2227				return tmp;
2228			}
2229			return results;
2230		};
2231
2232	// Class
2233	Expr.find[ "CLASS" ] = support.getElementsByClassName && function( className, context ) {
2234		if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
2235			return context.getElementsByClassName( className );
2236		}
2237	};
2238
2239	/* QSA/matchesSelector
2240	---------------------------------------------------------------------- */
2241
2242	// QSA and matchesSelector support
2243
2244	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
2245	rbuggyMatches = [];
2246
2247	// qSa(:focus) reports false when true (Chrome 21)
2248	// We allow this because of a bug in IE8/9 that throws an error
2249	// whenever `document.activeElement` is accessed on an iframe
2250	// So, we allow :focus to pass through QSA all the time to avoid the IE error
2251	// See https://bugs.jquery.com/ticket/13378
2252	rbuggyQSA = [];
2253
2254	if ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) {
2255
2256		// Build QSA regex
2257		// Regex strategy adopted from Diego Perini
2258		assert( function( el ) {
2259
2260			var input;
2261
2262			// Select is set to empty string on purpose
2263			// This is to test IE's treatment of not explicitly
2264			// setting a boolean content attribute,
2265			// since its presence should be enough
2266			// https://bugs.jquery.com/ticket/12359
2267			docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
2268				"<select id='" + expando + "-\r\\' msallowcapture=''>" +
2269				"<option selected=''></option></select>";
2270
2271			// Support: IE8, Opera 11-12.16
2272			// Nothing should be selected when empty strings follow ^= or $= or *=
2273			// The test attribute must be unknown in Opera but "safe" for WinRT
2274			// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
2275			if ( el.querySelectorAll( "[msallowcapture^='']" ).length ) {
2276				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
2277			}
2278
2279			// Support: IE8
2280			// Boolean attributes and "value" are not treated correctly
2281			if ( !el.querySelectorAll( "[selected]" ).length ) {
2282				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
2283			}
2284
2285			// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
2286			if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
2287				rbuggyQSA.push( "~=" );
2288			}
2289
2290			// Support: IE 11+, Edge 15 - 18+
2291			// IE 11/Edge don't find elements on a `[name='']` query in some cases.
2292			// Adding a temporary attribute to the document before the selection works
2293			// around the issue.
2294			// Interestingly, IE 10 & older don't seem to have the issue.
2295			input = document.createElement( "input" );
2296			input.setAttribute( "name", "" );
2297			el.appendChild( input );
2298			if ( !el.querySelectorAll( "[name='']" ).length ) {
2299				rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" +
2300					whitespace + "*(?:''|\"\")" );
2301			}
2302
2303			// Webkit/Opera - :checked should return selected option elements
2304			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2305			// IE8 throws error here and will not see later tests
2306			if ( !el.querySelectorAll( ":checked" ).length ) {
2307				rbuggyQSA.push( ":checked" );
2308			}
2309
2310			// Support: Safari 8+, iOS 8+
2311			// https://bugs.webkit.org/show_bug.cgi?id=136851
2312			// In-page `selector#id sibling-combinator selector` fails
2313			if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
2314				rbuggyQSA.push( ".#.+[+~]" );
2315			}
2316
2317			// Support: Firefox <=3.6 - 5 only
2318			// Old Firefox doesn't throw on a badly-escaped identifier.
2319			el.querySelectorAll( "\\\f" );
2320			rbuggyQSA.push( "[\\r\\n\\f]" );
2321		} );
2322
2323		assert( function( el ) {
2324			el.innerHTML = "<a href='' disabled='disabled'></a>" +
2325				"<select disabled='disabled'><option/></select>";
2326
2327			// Support: Windows 8 Native Apps
2328			// The type and name attributes are restricted during .innerHTML assignment
2329			var input = document.createElement( "input" );
2330			input.setAttribute( "type", "hidden" );
2331			el.appendChild( input ).setAttribute( "name", "D" );
2332
2333			// Support: IE8
2334			// Enforce case-sensitivity of name attribute
2335			if ( el.querySelectorAll( "[name=d]" ).length ) {
2336				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
2337			}
2338
2339			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
2340			// IE8 throws error here and will not see later tests
2341			if ( el.querySelectorAll( ":enabled" ).length !== 2 ) {
2342				rbuggyQSA.push( ":enabled", ":disabled" );
2343			}
2344
2345			// Support: IE9-11+
2346			// IE's :disabled selector does not pick up the children of disabled fieldsets
2347			docElem.appendChild( el ).disabled = true;
2348			if ( el.querySelectorAll( ":disabled" ).length !== 2 ) {
2349				rbuggyQSA.push( ":enabled", ":disabled" );
2350			}
2351
2352			// Support: Opera 10 - 11 only
2353			// Opera 10-11 does not throw on post-comma invalid pseudos
2354			el.querySelectorAll( "*,:x" );
2355			rbuggyQSA.push( ",.*:" );
2356		} );
2357	}
2358
2359	if ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches ||
2360		docElem.webkitMatchesSelector ||
2361		docElem.mozMatchesSelector ||
2362		docElem.oMatchesSelector ||
2363		docElem.msMatchesSelector ) ) ) ) {
2364
2365		assert( function( el ) {
2366
2367			// Check to see if it's possible to do matchesSelector
2368			// on a disconnected node (IE 9)
2369			support.disconnectedMatch = matches.call( el, "*" );
2370
2371			// This should fail with an exception
2372			// Gecko does not error, returns false instead
2373			matches.call( el, "[s!='']:x" );
2374			rbuggyMatches.push( "!=", pseudos );
2375		} );
2376	}
2377
2378	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) );
2379	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( "|" ) );
2380
2381	/* Contains
2382	---------------------------------------------------------------------- */
2383	hasCompare = rnative.test( docElem.compareDocumentPosition );
2384
2385	// Element contains another
2386	// Purposefully self-exclusive
2387	// As in, an element does not contain itself
2388	contains = hasCompare || rnative.test( docElem.contains ) ?
2389		function( a, b ) {
2390			var adown = a.nodeType === 9 ? a.documentElement : a,
2391				bup = b && b.parentNode;
2392			return a === bup || !!( bup && bup.nodeType === 1 && (
2393				adown.contains ?
2394					adown.contains( bup ) :
2395					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
2396			) );
2397		} :
2398		function( a, b ) {
2399			if ( b ) {
2400				while ( ( b = b.parentNode ) ) {
2401					if ( b === a ) {
2402						return true;
2403					}
2404				}
2405			}
2406			return false;
2407		};
2408
2409	/* Sorting
2410	---------------------------------------------------------------------- */
2411
2412	// Document order sorting
2413	sortOrder = hasCompare ?
2414	function( a, b ) {
2415
2416		// Flag for duplicate removal
2417		if ( a === b ) {
2418			hasDuplicate = true;
2419			return 0;
2420		}
2421
2422		// Sort on method existence if only one input has compareDocumentPosition
2423		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
2424		if ( compare ) {
2425			return compare;
2426		}
2427
2428		// Calculate position if both inputs belong to the same document
2429		// Support: IE 11+, Edge 17 - 18+
2430		// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2431		// two documents; shallow comparisons work.
2432		// eslint-disable-next-line eqeqeq
2433		compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?
2434			a.compareDocumentPosition( b ) :
2435
2436			// Otherwise we know they are disconnected
2437			1;
2438
2439		// Disconnected nodes
2440		if ( compare & 1 ||
2441			( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {
2442
2443			// Choose the first element that is related to our preferred document
2444			// Support: IE 11+, Edge 17 - 18+
2445			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2446			// two documents; shallow comparisons work.
2447			// eslint-disable-next-line eqeqeq
2448			if ( a == document || a.ownerDocument == preferredDoc &&
2449				contains( preferredDoc, a ) ) {
2450				return -1;
2451			}
2452
2453			// Support: IE 11+, Edge 17 - 18+
2454			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2455			// two documents; shallow comparisons work.
2456			// eslint-disable-next-line eqeqeq
2457			if ( b == document || b.ownerDocument == preferredDoc &&
2458				contains( preferredDoc, b ) ) {
2459				return 1;
2460			}
2461
2462			// Maintain original order
2463			return sortInput ?
2464				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
2465				0;
2466		}
2467
2468		return compare & 4 ? -1 : 1;
2469	} :
2470	function( a, b ) {
2471
2472		// Exit early if the nodes are identical
2473		if ( a === b ) {
2474			hasDuplicate = true;
2475			return 0;
2476		}
2477
2478		var cur,
2479			i = 0,
2480			aup = a.parentNode,
2481			bup = b.parentNode,
2482			ap = [ a ],
2483			bp = [ b ];
2484
2485		// Parentless nodes are either documents or disconnected
2486		if ( !aup || !bup ) {
2487
2488			// Support: IE 11+, Edge 17 - 18+
2489			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2490			// two documents; shallow comparisons work.
2491			/* eslint-disable eqeqeq */
2492			return a == document ? -1 :
2493				b == document ? 1 :
2494				/* eslint-enable eqeqeq */
2495				aup ? -1 :
2496				bup ? 1 :
2497				sortInput ?
2498				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
2499				0;
2500
2501		// If the nodes are siblings, we can do a quick check
2502		} else if ( aup === bup ) {
2503			return siblingCheck( a, b );
2504		}
2505
2506		// Otherwise we need full lists of their ancestors for comparison
2507		cur = a;
2508		while ( ( cur = cur.parentNode ) ) {
2509			ap.unshift( cur );
2510		}
2511		cur = b;
2512		while ( ( cur = cur.parentNode ) ) {
2513			bp.unshift( cur );
2514		}
2515
2516		// Walk down the tree looking for a discrepancy
2517		while ( ap[ i ] === bp[ i ] ) {
2518			i++;
2519		}
2520
2521		return i ?
2522
2523			// Do a sibling check if the nodes have a common ancestor
2524			siblingCheck( ap[ i ], bp[ i ] ) :
2525
2526			// Otherwise nodes in our document sort first
2527			// Support: IE 11+, Edge 17 - 18+
2528			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2529			// two documents; shallow comparisons work.
2530			/* eslint-disable eqeqeq */
2531			ap[ i ] == preferredDoc ? -1 :
2532			bp[ i ] == preferredDoc ? 1 :
2533			/* eslint-enable eqeqeq */
2534			0;
2535	};
2536
2537	return document;
2538};
2539
2540Sizzle.matches = function( expr, elements ) {
2541	return Sizzle( expr, null, null, elements );
2542};
2543
2544Sizzle.matchesSelector = function( elem, expr ) {
2545	setDocument( elem );
2546
2547	if ( support.matchesSelector && documentIsHTML &&
2548		!nonnativeSelectorCache[ expr + " " ] &&
2549		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
2550		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
2551
2552		try {
2553			var ret = matches.call( elem, expr );
2554
2555			// IE 9's matchesSelector returns false on disconnected nodes
2556			if ( ret || support.disconnectedMatch ||
2557
2558				// As well, disconnected nodes are said to be in a document
2559				// fragment in IE 9
2560				elem.document && elem.document.nodeType !== 11 ) {
2561				return ret;
2562			}
2563		} catch ( e ) {
2564			nonnativeSelectorCache( expr, true );
2565		}
2566	}
2567
2568	return Sizzle( expr, document, null, [ elem ] ).length > 0;
2569};
2570
2571Sizzle.contains = function( context, elem ) {
2572
2573	// Set document vars if needed
2574	// Support: IE 11+, Edge 17 - 18+
2575	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2576	// two documents; shallow comparisons work.
2577	// eslint-disable-next-line eqeqeq
2578	if ( ( context.ownerDocument || context ) != document ) {
2579		setDocument( context );
2580	}
2581	return contains( context, elem );
2582};
2583
2584Sizzle.attr = function( elem, name ) {
2585
2586	// Set document vars if needed
2587	// Support: IE 11+, Edge 17 - 18+
2588	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2589	// two documents; shallow comparisons work.
2590	// eslint-disable-next-line eqeqeq
2591	if ( ( elem.ownerDocument || elem ) != document ) {
2592		setDocument( elem );
2593	}
2594
2595	var fn = Expr.attrHandle[ name.toLowerCase() ],
2596
2597		// Don't get fooled by Object.prototype properties (jQuery #13807)
2598		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
2599			fn( elem, name, !documentIsHTML ) :
2600			undefined;
2601
2602	return val !== undefined ?
2603		val :
2604		support.attributes || !documentIsHTML ?
2605			elem.getAttribute( name ) :
2606			( val = elem.getAttributeNode( name ) ) && val.specified ?
2607				val.value :
2608				null;
2609};
2610
2611Sizzle.escape = function( sel ) {
2612	return ( sel + "" ).replace( rcssescape, fcssescape );
2613};
2614
2615Sizzle.error = function( msg ) {
2616	throw new Error( "Syntax error, unrecognized expression: " + msg );
2617};
2618
2619/**
2620 * Document sorting and removing duplicates
2621 * @param {ArrayLike} results
2622 */
2623Sizzle.uniqueSort = function( results ) {
2624	var elem,
2625		duplicates = [],
2626		j = 0,
2627		i = 0;
2628
2629	// Unless we *know* we can detect duplicates, assume their presence
2630	hasDuplicate = !support.detectDuplicates;
2631	sortInput = !support.sortStable && results.slice( 0 );
2632	results.sort( sortOrder );
2633
2634	if ( hasDuplicate ) {
2635		while ( ( elem = results[ i++ ] ) ) {
2636			if ( elem === results[ i ] ) {
2637				j = duplicates.push( i );
2638			}
2639		}
2640		while ( j-- ) {
2641			results.splice( duplicates[ j ], 1 );
2642		}
2643	}
2644
2645	// Clear input after sorting to release objects
2646	// See https://github.com/jquery/sizzle/pull/225
2647	sortInput = null;
2648
2649	return results;
2650};
2651
2652/**
2653 * Utility function for retrieving the text value of an array of DOM nodes
2654 * @param {Array|Element} elem
2655 */
2656getText = Sizzle.getText = function( elem ) {
2657	var node,
2658		ret = "",
2659		i = 0,
2660		nodeType = elem.nodeType;
2661
2662	if ( !nodeType ) {
2663
2664		// If no nodeType, this is expected to be an array
2665		while ( ( node = elem[ i++ ] ) ) {
2666
2667			// Do not traverse comment nodes
2668			ret += getText( node );
2669		}
2670	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
2671
2672		// Use textContent for elements
2673		// innerText usage removed for consistency of new lines (jQuery #11153)
2674		if ( typeof elem.textContent === "string" ) {
2675			return elem.textContent;
2676		} else {
2677
2678			// Traverse its children
2679			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2680				ret += getText( elem );
2681			}
2682		}
2683	} else if ( nodeType === 3 || nodeType === 4 ) {
2684		return elem.nodeValue;
2685	}
2686
2687	// Do not include comment or processing instruction nodes
2688
2689	return ret;
2690};
2691
2692Expr = Sizzle.selectors = {
2693
2694	// Can be adjusted by the user
2695	cacheLength: 50,
2696
2697	createPseudo: markFunction,
2698
2699	match: matchExpr,
2700
2701	attrHandle: {},
2702
2703	find: {},
2704
2705	relative: {
2706		">": { dir: "parentNode", first: true },
2707		" ": { dir: "parentNode" },
2708		"+": { dir: "previousSibling", first: true },
2709		"~": { dir: "previousSibling" }
2710	},
2711
2712	preFilter: {
2713		"ATTR": function( match ) {
2714			match[ 1 ] = match[ 1 ].replace( runescape, funescape );
2715
2716			// Move the given value to match[3] whether quoted or unquoted
2717			match[ 3 ] = ( match[ 3 ] || match[ 4 ] ||
2718				match[ 5 ] || "" ).replace( runescape, funescape );
2719
2720			if ( match[ 2 ] === "~=" ) {
2721				match[ 3 ] = " " + match[ 3 ] + " ";
2722			}
2723
2724			return match.slice( 0, 4 );
2725		},
2726
2727		"CHILD": function( match ) {
2728
2729			/* matches from matchExpr["CHILD"]
2730				1 type (only|nth|...)
2731				2 what (child|of-type)