1 // 4.1.10 (2015-05-05)

     2 

     3 /**

     4  * Compiled inline version. (Library mode)

     5  */

     6 

     7 /*jshint smarttabs:true, undef:true, latedef:true, curly:true, bitwise:true, camelcase:true */

     8 /*globals $code */

     9 

    10 (function(exports, undefined) {

    11 	"use strict";

    12 

    13 	var modules = {};

    14 

    15 	function require(ids, callback) {

    16 		var module, defs = [];

    17 

    18 		for (var i = 0; i < ids.length; ++i) {

    19 			module = modules[ids[i]] || resolve(ids[i]);

    20 			if (!module) {

    21 				throw 'module definition dependecy not found: ' + ids[i];

    22 			}

    23 

    24 			defs.push(module);

    25 		}

    26 

    27 		callback.apply(null, defs);

    28 	}

    29 

    30 	function define(id, dependencies, definition) {

    31 		if (typeof id !== 'string') {

    32 			throw 'invalid module definition, module id must be defined and be a string';

    33 		}

    34 

    35 		if (dependencies === undefined) {

    36 			throw 'invalid module definition, dependencies must be specified';

    37 		}

    38 

    39 		if (definition === undefined) {

    40 			throw 'invalid module definition, definition function must be specified';

    41 		}

    42 

    43 		require(dependencies, function() {

    44 			modules[id] = definition.apply(null, arguments);

    45 		});

    46 	}

    47 

    48 	function defined(id) {

    49 		return !!modules[id];

    50 	}

    51 

    52 	function resolve(id) {

    53 		var target = exports;

    54 		var fragments = id.split(/[.\/]/);

    55 

    56 		for (var fi = 0; fi < fragments.length; ++fi) {

    57 			if (!target[fragments[fi]]) {

    58 				return;

    59 			}

    60 

    61 			target = target[fragments[fi]];

    62 		}

    63 

    64 		return target;

    65 	}

    66 

    67 	function expose(ids) {

    68 		for (var i = 0; i < ids.length; i++) {

    69 			var target = exports;

    70 			var id = ids[i];

    71 			var fragments = id.split(/[.\/]/);

    72 

    73 			for (var fi = 0; fi < fragments.length - 1; ++fi) {

    74 				if (target[fragments[fi]] === undefined) {

    75 					target[fragments[fi]] = {};

    76 				}

    77 

    78 				target = target[fragments[fi]];

    79 			}

    80 

    81 			target[fragments[fragments.length - 1]] = modules[id];

    82 		}

    83 	}

    84 

    85 // Included from: js/tinymce/classes/dom/EventUtils.js

    86 

    87 /**

    88  * EventUtils.js

    89  *

    90  * Copyright, Moxiecode Systems AB

    91  * Released under LGPL License.

    92  *

    93  * License: http://www.tinymce.com/license

    94  * Contributing: http://www.tinymce.com/contributing

    95  */

    96 

    97 /*jshint loopfunc:true*/

    98 /*eslint no-loop-func:0 */

    99 

   100 /**

   101  * This class wraps the browsers native event logic with more convenient methods.

   102  *

   103  * @class tinymce.dom.EventUtils

   104  */

   105 define("tinymce/dom/EventUtils", [], function() {

   106 	"use strict";

   107 

   108 	var eventExpandoPrefix = "mce-data-";

   109 	var mouseEventRe = /^(?:mouse|contextmenu)|click/;

   110 	var deprecated = {keyLocation: 1, layerX: 1, layerY: 1, returnValue: 1};

   111 

   112 	/**

   113 	 * Binds a native event to a callback on the speified target.

   114 	 */

   115 	function addEvent(target, name, callback, capture) {

   116 		if (target.addEventListener) {

   117 			target.addEventListener(name, callback, capture || false);

   118 		} else if (target.attachEvent) {

   119 			target.attachEvent('on' + name, callback);

   120 		}

   121 	}

   122 

   123 	/**

   124 	 * Unbinds a native event callback on the specified target.

   125 	 */

   126 	function removeEvent(target, name, callback, capture) {

   127 		if (target.removeEventListener) {

   128 			target.removeEventListener(name, callback, capture || false);

   129 		} else if (target.detachEvent) {

   130 			target.detachEvent('on' + name, callback);

   131 		}

   132 	}

   133 

   134 	/**

   135 	 * Normalizes a native event object or just adds the event specific methods on a custom event.

   136 	 */

   137 	function fix(originalEvent, data) {

   138 		var name, event = data || {}, undef;

   139 

   140 		// Dummy function that gets replaced on the delegation state functions

   141 		function returnFalse() {

   142 			return false;

   143 		}

   144 

   145 		// Dummy function that gets replaced on the delegation state functions

   146 		function returnTrue() {

   147 			return true;

   148 		}

   149 

   150 		// Copy all properties from the original event

   151 		for (name in originalEvent) {

   152 			// layerX/layerY is deprecated in Chrome and produces a warning

   153 			if (!deprecated[name]) {

   154 				event[name] = originalEvent[name];

   155 			}

   156 		}

   157 

   158 		// Normalize target IE uses srcElement

   159 		if (!event.target) {

   160 			event.target = event.srcElement || document;

   161 		}

   162 

   163 		// Calculate pageX/Y if missing and clientX/Y available

   164 		if (originalEvent && mouseEventRe.test(originalEvent.type) && originalEvent.pageX === undef && originalEvent.clientX !== undef) {

   165 			var eventDoc = event.target.ownerDocument || document;

   166 			var doc = eventDoc.documentElement;

   167 			var body = eventDoc.body;

   168 

   169 			event.pageX = originalEvent.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) -

   170 				(doc && doc.clientLeft || body && body.clientLeft || 0);

   171 

   172 			event.pageY = originalEvent.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) -

   173 				(doc && doc.clientTop || body && body.clientTop || 0);

   174 		}

   175 

   176 		// Add preventDefault method

   177 		event.preventDefault = function() {

   178 			event.isDefaultPrevented = returnTrue;

   179 

   180 			// Execute preventDefault on the original event object

   181 			if (originalEvent) {

   182 				if (originalEvent.preventDefault) {

   183 					originalEvent.preventDefault();

   184 				} else {

   185 					originalEvent.returnValue = false; // IE

   186 				}

   187 			}

   188 		};

   189 

   190 		// Add stopPropagation

   191 		event.stopPropagation = function() {

   192 			event.isPropagationStopped = returnTrue;

   193 

   194 			// Execute stopPropagation on the original event object

   195 			if (originalEvent) {

   196 				if (originalEvent.stopPropagation) {

   197 					originalEvent.stopPropagation();

   198 				} else {

   199 					originalEvent.cancelBubble = true; // IE

   200 				}

   201 			}

   202 		};

   203 

   204 		// Add stopImmediatePropagation

   205 		event.stopImmediatePropagation = function() {

   206 			event.isImmediatePropagationStopped = returnTrue;

   207 			event.stopPropagation();

   208 		};

   209 

   210 		// Add event delegation states

   211 		if (!event.isDefaultPrevented) {

   212 			event.isDefaultPrevented = returnFalse;

   213 			event.isPropagationStopped = returnFalse;

   214 			event.isImmediatePropagationStopped = returnFalse;

   215 		}

   216 

   217 		return event;

   218 	}

   219 

   220 	/**

   221 	 * Bind a DOMContentLoaded event across browsers and executes the callback once the page DOM is initialized.

   222 	 * It will also set/check the domLoaded state of the event_utils instance so ready isn't called multiple times.

   223 	 */

   224 	function bindOnReady(win, callback, eventUtils) {

   225 		var doc = win.document, event = {type: 'ready'};

   226 

   227 		if (eventUtils.domLoaded) {

   228 			callback(event);

   229 			return;

   230 		}

   231 

   232 		// Gets called when the DOM is ready

   233 		function readyHandler() {

   234 			if (!eventUtils.domLoaded) {

   235 				eventUtils.domLoaded = true;

   236 				callback(event);

   237 			}

   238 		}

   239 

   240 		function waitForDomLoaded() {

   241 			// Check complete or interactive state if there is a body

   242 			// element on some iframes IE 8 will produce a null body

   243 			if (doc.readyState === "complete" || (doc.readyState === "interactive" && doc.body)) {

   244 				removeEvent(doc, "readystatechange", waitForDomLoaded);

   245 				readyHandler();

   246 			}

   247 		}

   248 

   249 		function tryScroll() {

   250 			try {

   251 				// If IE is used, use the trick by Diego Perini licensed under MIT by request to the author.

   252 				// http://javascript.nwbox.com/IEContentLoaded/

   253 				doc.documentElement.doScroll("left");

   254 			} catch (ex) {

   255 				setTimeout(tryScroll, 0);

   256 				return;

   257 			}

   258 

   259 			readyHandler();

   260 		}

   261 

   262 		// Use W3C method

   263 		if (doc.addEventListener) {

   264 			if (doc.readyState === "complete") {

   265 				readyHandler();

   266 			} else {

   267 				addEvent(win, 'DOMContentLoaded', readyHandler);

   268 			}

   269 		} else {

   270 			// Use IE method

   271 			addEvent(doc, "readystatechange", waitForDomLoaded);

   272 

   273 			// Wait until we can scroll, when we can the DOM is initialized

   274 			if (doc.documentElement.doScroll && win.self === win.top) {

   275 				tryScroll();

   276 			}

   277 		}

   278 

   279 		// Fallback if any of the above methods should fail for some odd reason

   280 		addEvent(win, 'load', readyHandler);

   281 	}

   282 

   283 	/**

   284 	 * This class enables you to bind/unbind native events to elements and normalize it's behavior across browsers.

   285 	 */

   286 	function EventUtils() {

   287 		var self = this, events = {}, count, expando, hasFocusIn, hasMouseEnterLeave, mouseEnterLeave;

   288 

   289 		expando = eventExpandoPrefix + (+new Date()).toString(32);

   290 		hasMouseEnterLeave = "onmouseenter" in document.documentElement;

   291 		hasFocusIn = "onfocusin" in document.documentElement;

   292 		mouseEnterLeave = {mouseenter: 'mouseover', mouseleave: 'mouseout'};

   293 		count = 1;

   294 

   295 		// State if the DOMContentLoaded was executed or not

   296 		self.domLoaded = false;

   297 		self.events = events;

   298 

   299 		/**

   300 		 * Executes all event handler callbacks for a specific event.

   301 		 *

   302 		 * @private

   303 		 * @param {Event} evt Event object.

   304 		 * @param {String} id Expando id value to look for.

   305 		 */

   306 		function executeHandlers(evt, id) {

   307 			var callbackList, i, l, callback, container = events[id];

   308 

   309 			callbackList = container && container[evt.type];

   310 			if (callbackList) {

   311 				for (i = 0, l = callbackList.length; i < l; i++) {

   312 					callback = callbackList[i];

   313 

   314 					// Check if callback exists might be removed if a unbind is called inside the callback

   315 					if (callback && callback.func.call(callback.scope, evt) === false) {

   316 						evt.preventDefault();

   317 					}

   318 

   319 					// Should we stop propagation to immediate listeners

   320 					if (evt.isImmediatePropagationStopped()) {

   321 						return;

   322 					}

   323 				}

   324 			}

   325 		}

   326 

   327 		/**

   328 		 * Binds a callback to an event on the specified target.

   329 		 *

   330 		 * @method bind

   331 		 * @param {Object} target Target node/window or custom object.

   332 		 * @param {String} names Name of the event to bind.

   333 		 * @param {function} callback Callback function to execute when the event occurs.

   334 		 * @param {Object} scope Scope to call the callback function on, defaults to target.

   335 		 * @return {function} Callback function that got bound.

   336 		 */

   337 		self.bind = function(target, names, callback, scope) {

   338 			var id, callbackList, i, name, fakeName, nativeHandler, capture, win = window;

   339 

   340 			// Native event handler function patches the event and executes the callbacks for the expando

   341 			function defaultNativeHandler(evt) {

   342 				executeHandlers(fix(evt || win.event), id);

   343 			}

   344 

   345 			// Don't bind to text nodes or comments

   346 			if (!target || target.nodeType === 3 || target.nodeType === 8) {

   347 				return;

   348 			}

   349 

   350 			// Create or get events id for the target

   351 			if (!target[expando]) {

   352 				id = count++;

   353 				target[expando] = id;

   354 				events[id] = {};

   355 			} else {

   356 				id = target[expando];

   357 			}

   358 

   359 			// Setup the specified scope or use the target as a default

   360 			scope = scope || target;

   361 

   362 			// Split names and bind each event, enables you to bind multiple events with one call

   363 			names = names.split(' ');

   364 			i = names.length;

   365 			while (i--) {

   366 				name = names[i];

   367 				nativeHandler = defaultNativeHandler;

   368 				fakeName = capture = false;

   369 

   370 				// Use ready instead of DOMContentLoaded

   371 				if (name === "DOMContentLoaded") {

   372 					name = "ready";

   373 				}

   374 

   375 				// DOM is already ready

   376 				if (self.domLoaded && name === "ready" && target.readyState == 'complete') {

   377 					callback.call(scope, fix({type: name}));

   378 					continue;

   379 				}

   380 

   381 				// Handle mouseenter/mouseleaver

   382 				if (!hasMouseEnterLeave) {

   383 					fakeName = mouseEnterLeave[name];

   384 

   385 					if (fakeName) {

   386 						nativeHandler = function(evt) {

   387 							var current, related;

   388 

   389 							current = evt.currentTarget;

   390 							related = evt.relatedTarget;

   391 

   392 							// Check if related is inside the current target if it's not then the event should

   393 							// be ignored since it's a mouseover/mouseout inside the element

   394 							if (related && current.contains) {

   395 								// Use contains for performance

   396 								related = current.contains(related);

   397 							} else {

   398 								while (related && related !== current) {

   399 									related = related.parentNode;

   400 								}

   401 							}

   402 

   403 							// Fire fake event

   404 							if (!related) {

   405 								evt = fix(evt || win.event);

   406 								evt.type = evt.type === 'mouseout' ? 'mouseleave' : 'mouseenter';

   407 								evt.target = current;

   408 								executeHandlers(evt, id);

   409 							}

   410 						};

   411 					}

   412 				}

   413 

   414 				// Fake bubbeling of focusin/focusout

   415 				if (!hasFocusIn && (name === "focusin" || name === "focusout")) {

   416 					capture = true;

   417 					fakeName = name === "focusin" ? "focus" : "blur";

   418 					nativeHandler = function(evt) {

   419 						evt = fix(evt || win.event);

   420 						evt.type = evt.type === 'focus' ? 'focusin' : 'focusout';

   421 						executeHandlers(evt, id);

   422 					};

   423 				}

   424 

   425 				// Setup callback list and bind native event

   426 				callbackList = events[id][name];

   427 				if (!callbackList) {

   428 					events[id][name] = callbackList = [{func: callback, scope: scope}];

   429 					callbackList.fakeName = fakeName;

   430 					callbackList.capture = capture;

   431 					//callbackList.callback = callback;

   432 

   433 					// Add the nativeHandler to the callback list so that we can later unbind it

   434 					callbackList.nativeHandler = nativeHandler;

   435 

   436 					// Check if the target has native events support

   437 

   438 					if (name === "ready") {

   439 						bindOnReady(target, nativeHandler, self);

   440 					} else {

   441 						addEvent(target, fakeName || name, nativeHandler, capture);

   442 					}

   443 				} else {

   444 					if (name === "ready" && self.domLoaded) {

   445 						callback({type: name});

   446 					} else {

   447 						// If it already has an native handler then just push the callback

   448 						callbackList.push({func: callback, scope: scope});

   449 					}

   450 				}

   451 			}

   452 

   453 			target = callbackList = 0; // Clean memory for IE

   454 

   455 			return callback;

   456 		};

   457 

   458 		/**

   459 		 * Unbinds the specified event by name, name and callback or all events on the target.

   460 		 *

   461 		 * @method unbind

   462 		 * @param {Object} target Target node/window or custom object.

   463 		 * @param {String} names Optional event name to unbind.

   464 		 * @param {function} callback Optional callback function to unbind.

   465 		 * @return {EventUtils} Event utils instance.

   466 		 */

   467 		self.unbind = function(target, names, callback) {

   468 			var id, callbackList, i, ci, name, eventMap;

   469 

   470 			// Don't bind to text nodes or comments

   471 			if (!target || target.nodeType === 3 || target.nodeType === 8) {

   472 				return self;

   473 			}

   474 

   475 			// Unbind event or events if the target has the expando

   476 			id = target[expando];

   477 			if (id) {

   478 				eventMap = events[id];

   479 

   480 				// Specific callback

   481 				if (names) {

   482 					names = names.split(' ');

   483 					i = names.length;

   484 					while (i--) {

   485 						name = names[i];

   486 						callbackList = eventMap[name];

   487 

   488 						// Unbind the event if it exists in the map

   489 						if (callbackList) {

   490 							// Remove specified callback

   491 							if (callback) {

   492 								ci = callbackList.length;

   493 								while (ci--) {

   494 									if (callbackList[ci].func === callback) {

   495 										var nativeHandler = callbackList.nativeHandler;

   496 										var fakeName = callbackList.fakeName, capture = callbackList.capture;

   497 

   498 										// Clone callbackList since unbind inside a callback would otherwise break the handlers loop

   499 										callbackList = callbackList.slice(0, ci).concat(callbackList.slice(ci + 1));

   500 										callbackList.nativeHandler = nativeHandler;

   501 										callbackList.fakeName = fakeName;

   502 										callbackList.capture = capture;

   503 

   504 										eventMap[name] = callbackList;

   505 									}

   506 								}

   507 							}

   508 

   509 							// Remove all callbacks if there isn't a specified callback or there is no callbacks left

   510 							if (!callback || callbackList.length === 0) {

   511 								delete eventMap[name];

   512 								removeEvent(target, callbackList.fakeName || name, callbackList.nativeHandler, callbackList.capture);

   513 							}

   514 						}

   515 					}

   516 				} else {

   517 					// All events for a specific element

   518 					for (name in eventMap) {

   519 						callbackList = eventMap[name];

   520 						removeEvent(target, callbackList.fakeName || name, callbackList.nativeHandler, callbackList.capture);

   521 					}

   522 

   523 					eventMap = {};

   524 				}

   525 

   526 				// Check if object is empty, if it isn't then we won't remove the expando map

   527 				for (name in eventMap) {

   528 					return self;

   529 				}

   530 

   531 				// Delete event object

   532 				delete events[id];

   533 

   534 				// Remove expando from target

   535 				try {

   536 					// IE will fail here since it can't delete properties from window

   537 					delete target[expando];

   538 				} catch (ex) {

   539 					// IE will set it to null

   540 					target[expando] = null;

   541 				}

   542 			}

   543 

   544 			return self;

   545 		};

   546 

   547 		/**

   548 		 * Fires the specified event on the specified target.

   549 		 *

   550 		 * @method fire

   551 		 * @param {Object} target Target node/window or custom object.

   552 		 * @param {String} name Event name to fire.

   553 		 * @param {Object} args Optional arguments to send to the observers.

   554 		 * @return {EventUtils} Event utils instance.

   555 		 */

   556 		self.fire = function(target, name, args) {

   557 			var id;

   558 

   559 			// Don't bind to text nodes or comments

   560 			if (!target || target.nodeType === 3 || target.nodeType === 8) {

   561 				return self;

   562 			}

   563 

   564 			// Build event object by patching the args

   565 			args = fix(null, args);

   566 			args.type = name;

   567 			args.target = target;

   568 

   569 			do {

   570 				// Found an expando that means there is listeners to execute

   571 				id = target[expando];

   572 				if (id) {

   573 					executeHandlers(args, id);

   574 				}

   575 

   576 				// Walk up the DOM

   577 				target = target.parentNode || target.ownerDocument || target.defaultView || target.parentWindow;

   578 			} while (target && !args.isPropagationStopped());

   579 

   580 			return self;

   581 		};

   582 

   583 		/**

   584 		 * Removes all bound event listeners for the specified target. This will also remove any bound

   585 		 * listeners to child nodes within that target.

   586 		 *

   587 		 * @method clean

   588 		 * @param {Object} target Target node/window object.

   589 		 * @return {EventUtils} Event utils instance.

   590 		 */

   591 		self.clean = function(target) {

   592 			var i, children, unbind = self.unbind;

   593 

   594 			// Don't bind to text nodes or comments

   595 			if (!target || target.nodeType === 3 || target.nodeType === 8) {

   596 				return self;

   597 			}

   598 

   599 			// Unbind any element on the specificed target

   600 			if (target[expando]) {

   601 				unbind(target);

   602 			}

   603 

   604 			// Target doesn't have getElementsByTagName it's probably a window object then use it's document to find the children

   605 			if (!target.getElementsByTagName) {

   606 				target = target.document;

   607 			}

   608 

   609 			// Remove events from each child element

   610 			if (target && target.getElementsByTagName) {

   611 				unbind(target);

   612 

   613 				children = target.getElementsByTagName('*');

   614 				i = children.length;

   615 				while (i--) {

   616 					target = children[i];

   617 

   618 					if (target[expando]) {

   619 						unbind(target);

   620 					}

   621 				}

   622 			}

   623 

   624 			return self;

   625 		};

   626 

   627 		/**

   628 		 * Destroys the event object. Call this on IE to remove memory leaks.

   629 		 */

   630 		self.destroy = function() {

   631 			events = {};

   632 		};

   633 

   634 		// Legacy function for canceling events

   635 		self.cancel = function(e) {

   636 			if (e) {

   637 				e.preventDefault();

   638 				e.stopImmediatePropagation();

   639 			}

   640 

   641 			return false;

   642 		};

   643 	}

   644 

   645 	EventUtils.Event = new EventUtils();

   646 	EventUtils.Event.bind(window, 'ready', function() {});

   647 

   648 	return EventUtils;

   649 });

   650 

   651 // Included from: js/tinymce/classes/dom/Sizzle.js

   652 

   653 /**

   654  * Sizzle.js

   655  *

   656  * Copyright, Moxiecode Systems AB

   657  * Released under LGPL License.

   658  *

   659  * License: http://www.tinymce.com/license

   660  * Contributing: http://www.tinymce.com/contributing

   661  *

   662  * @ignore-file

   663  */

   664 

   665 /*jshint bitwise:false, expr:true, noempty:false, sub:true, eqnull:true, latedef:false, maxlen:255 */

   666 /*eslint dot-notation:0, no-empty:0, no-cond-assign:0, no-unused-expressions:0, new-cap:0 */

   667 /*eslint no-nested-ternary:0, func-style:0, no-bitwise:0, max-len:0, brace-style:0, no-return-assign:0, no-multi-spaces:0 */

   668 

   669 /**

   670  * Sizzle CSS Selector Engine v@VERSION

   671  * http://sizzlejs.com/

   672  *

   673  * Copyright 2008, 2014 jQuery Foundation, Inc. and other contributors

   674  * Released under the MIT license

   675  * http://jquery.org/license

   676  *

   677  * Date: @DATE

   678  */

   679 define("tinymce/dom/Sizzle", [], function() {

   680 var i,

   681 	support,

   682 	Expr,

   683 	getText,

   684 	isXML,

   685 	tokenize,

   686 	compile,

   687 	select,

   688 	outermostContext,

   689 	sortInput,

   690 	hasDuplicate,

   691 

   692 	// Local document vars

   693 	setDocument,

   694 	document,

   695 	docElem,

   696 	documentIsHTML,

   697 	rbuggyQSA,

   698 	rbuggyMatches,

   699 	matches,

   700 	contains,

   701 

   702 	// Instance-specific data

   703 	expando = "sizzle" + -(new Date()),

   704 	preferredDoc = window.document,

   705 	dirruns = 0,

   706 	done = 0,

   707 	classCache = createCache(),

   708 	tokenCache = createCache(),

   709 	compilerCache = createCache(),

   710 	sortOrder = function( a, b ) {

   711 		if ( a === b ) {

   712 			hasDuplicate = true;

   713 		}

   714 		return 0;

   715 	},

   716 

   717 	// General-purpose constants

   718 	strundefined = typeof undefined,

   719 	MAX_NEGATIVE = 1 << 31,

   720 

   721 	// Instance methods

   722 	hasOwn = ({}).hasOwnProperty,

   723 	arr = [],

   724 	pop = arr.pop,

   725 	push_native = arr.push,

   726 	push = arr.push,

   727 	slice = arr.slice,

   728 	// Use a stripped-down indexOf if we can't use a native one

   729 	indexOf = arr.indexOf || function( elem ) {

   730 		var i = 0,

   731 			len = this.length;

   732 		for ( ; i < len; i++ ) {

   733 			if ( this[i] === elem ) {

   734 				return i;

   735 			}

   736 		}

   737 		return -1;

   738 	},

   739 

   740 	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",

   741 

   742 	// Regular expressions

   743 

   744 	// http://www.w3.org/TR/css3-selectors/#whitespace

   745 	whitespace = "[\\x20\\t\\r\\n\\f]",

   746 

   747 	// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier

   748 	identifier = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",

   749 

   750 	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors

   751 	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +

   752 		// Operator (capture 2)

   753 		"*([*^$|!~]?=)" + whitespace +

   754 		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"

   755 		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +

   756 		"*\\]",

   757 

   758 	pseudos = ":(" + identifier + ")(?:\\((" +

   759 		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:

   760 		// 1. quoted (capture 3; capture 4 or capture 5)

   761 		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +

   762 		// 2. simple (capture 6)

   763 		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +

   764 		// 3. anything else (capture 2)

   765 		".*" +

   766 		")\\)|)",

   767 

   768 	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter

   769 	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),

   770 

   771 	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),

   772 	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),

   773 

   774 	rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),

   775 

   776 	rpseudo = new RegExp( pseudos ),

   777 	ridentifier = new RegExp( "^" + identifier + "$" ),

   778 

   779 	matchExpr = {

   780 		"ID": new RegExp( "^#(" + identifier + ")" ),

   781 		"CLASS": new RegExp( "^\\.(" + identifier + ")" ),

   782 		"TAG": new RegExp( "^(" + identifier + "|[*])" ),

   783 		"ATTR": new RegExp( "^" + attributes ),

   784 		"PSEUDO": new RegExp( "^" + pseudos ),

   785 		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +

   786 			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +

   787 			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),

   788 		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),

   789 		// For use in libraries implementing .is()

   790 		// We use this for POS matching in `select`

   791 		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +

   792 			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )

   793 	},

   794 

   795 	rinputs = /^(?:input|select|textarea|button)$/i,

   796 	rheader = /^h\d$/i,

   797 

   798 	rnative = /^[^{]+\{\s*\[native \w/,

   799 

   800 	// Easily-parseable/retrievable ID or TAG or CLASS selectors

   801 	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,

   802 

   803 	rsibling = /[+~]/,

   804 	rescape = /'|\\/g,

   805 

   806 	// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters

   807 	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),

   808 	funescape = function( _, escaped, escapedWhitespace ) {

   809 		var high = "0x" + escaped - 0x10000;

   810 		// NaN means non-codepoint

   811 		// Support: Firefox<24

   812 		// Workaround erroneous numeric interpretation of +"0x"

   813 		return high !== high || escapedWhitespace ?

   814 			escaped :

   815 			high < 0 ?

   816 				// BMP codepoint

   817 				String.fromCharCode( high + 0x10000 ) :

   818 				// Supplemental Plane codepoint (surrogate pair)

   819 				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );

   820 	};

   821 

   822 // Optimize for push.apply( _, NodeList )

   823 try {

   824 	push.apply(

   825 		(arr = slice.call( preferredDoc.childNodes )),

   826 		preferredDoc.childNodes

   827 	);

   828 	// Support: Android<4.0

   829 	// Detect silently failing push.apply

   830 	arr[ preferredDoc.childNodes.length ].nodeType;

   831 } catch ( e ) {

   832 	push = { apply: arr.length ?

   833 

   834 		// Leverage slice if possible

   835 		function( target, els ) {

   836 			push_native.apply( target, slice.call(els) );

   837 		} :

   838 

   839 		// Support: IE<9

   840 		// Otherwise append directly

   841 		function( target, els ) {

   842 			var j = target.length,

   843 				i = 0;

   844 			// Can't trust NodeList.length

   845 			while ( (target[j++] = els[i++]) ) {}

   846 			target.length = j - 1;

   847 		}

   848 	};

   849 }

   850 

   851 function Sizzle( selector, context, results, seed ) {

   852 	var match, elem, m, nodeType,

   853 		// QSA vars

   854 		i, groups, old, nid, newContext, newSelector;

   855 

   856 	if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {

   857 		setDocument( context );

   858 	}

   859 

   860 	context = context || document;

   861 	results = results || [];

   862 

   863 	if ( !selector || typeof selector !== "string" ) {

   864 		return results;

   865 	}

   866 

   867 	if ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) {

   868 		return [];

   869 	}

   870 

   871 	if ( documentIsHTML && !seed ) {

   872 

   873 		// Shortcuts

   874 		if ( (match = rquickExpr.exec( selector )) ) {

   875 			// Speed-up: Sizzle("#ID")

   876 			if ( (m = match[1]) ) {

   877 				if ( nodeType === 9 ) {

   878 					elem = context.getElementById( m );

   879 					// Check parentNode to catch when Blackberry 4.6 returns

   880 					// nodes that are no longer in the document (jQuery #6963)

   881 					if ( elem && elem.parentNode ) {

   882 						// Handle the case where IE, Opera, and Webkit return items

   883 						// by name instead of ID

   884 						if ( elem.id === m ) {

   885 							results.push( elem );

   886 							return results;

   887 						}

   888 					} else {

   889 						return results;

   890 					}

   891 				} else {

   892 					// Context is not a document

   893 					if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&

   894 						contains( context, elem ) && elem.id === m ) {

   895 						results.push( elem );

   896 						return results;

   897 					}

   898 				}

   899 

   900 			// Speed-up: Sizzle("TAG")

   901 			} else if ( match[2] ) {

   902 				push.apply( results, context.getElementsByTagName( selector ) );

   903 				return results;

   904 

   905 			// Speed-up: Sizzle(".CLASS")

   906 			} else if ( (m = match[3]) && support.getElementsByClassName ) {

   907 				push.apply( results, context.getElementsByClassName( m ) );

   908 				return results;

   909 			}

   910 		}

   911 

   912 		// QSA path

   913 		if ( support.qsa && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {

   914 			nid = old = expando;

   915 			newContext = context;

   916 			newSelector = nodeType === 9 && selector;

   917 

   918 			// qSA works strangely on Element-rooted queries

   919 			// We can work around this by specifying an extra ID on the root

   920 			// and working up from there (Thanks to Andrew Dupont for the technique)

   921 			// IE 8 doesn't work on object elements

   922 			if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {

   923 				groups = tokenize( selector );

   924 

   925 				if ( (old = context.getAttribute("id")) ) {

   926 					nid = old.replace( rescape, "\\$&" );

   927 				} else {

   928 					context.setAttribute( "id", nid );

   929 				}

   930 				nid = "[id='" + nid + "'] ";

   931 

   932 				i = groups.length;

   933 				while ( i-- ) {

   934 					groups[i] = nid + toSelector( groups[i] );

   935 				}

   936 				newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context;

   937 				newSelector = groups.join(",");

   938 			}

   939 

   940 			if ( newSelector ) {

   941 				try {

   942 					push.apply( results,

   943 						newContext.querySelectorAll( newSelector )

   944 					);

   945 					return results;

   946 				} catch(qsaError) {

   947 				} finally {

   948 					if ( !old ) {

   949 						context.removeAttribute("id");

   950 					}

   951 				}

   952 			}

   953 		}

   954 	}

   955 

   956 	// All others

   957 	return select( selector.replace( rtrim, "$1" ), context, results, seed );

   958 }

   959 

   960 /**

   961  * Create key-value caches of limited size

   962  * @returns {Function(string, Object)} Returns the Object data after storing it on itself with

   963  *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)

   964  *	deleting the oldest entry

   965  */

   966 function createCache() {

   967 	var keys = [];

   968 

   969 	function cache( key, value ) {

   970 		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)

   971 		if ( keys.push( key + " " ) > Expr.cacheLength ) {

   972 			// Only keep the most recent entries

   973 			delete cache[ keys.shift() ];

   974 		}

   975 		return (cache[ key + " " ] = value);

   976 	}

   977 	return cache;

   978 }

   979 

   980 /**

   981  * Mark a function for special use by Sizzle

   982  * @param {Function} fn The function to mark

   983  */

   984 function markFunction( fn ) {

   985 	fn[ expando ] = true;

   986 	return fn;

   987 }

   988 

   989 /**

   990  * Support testing using an element

   991  * @param {Function} fn Passed the created div and expects a boolean result

   992  */

   993 function assert( fn ) {

   994 	var div = document.createElement("div");

   995 

   996 	try {

   997 		return !!fn( div );

   998 	} catch (e) {

   999 		return false;

  1000 	} finally {

  1001 		// Remove from its parent by default

  1002 		if ( div.parentNode ) {

  1003 			div.parentNode.removeChild( div );

  1004 		}

  1005 		// release memory in IE

  1006 		div = null;

  1007 	}

  1008 }

  1009 

  1010 /**

  1011  * Adds the same handler for all of the specified attrs

  1012  * @param {String} attrs Pipe-separated list of attributes

  1013  * @param {Function} handler The method that will be applied

  1014  */

  1015 function addHandle( attrs, handler ) {

  1016 	var arr = attrs.split("|"),

  1017 		i = attrs.length;

  1018 

  1019 	while ( i-- ) {

  1020 		Expr.attrHandle[ arr[i] ] = handler;

  1021 	}

  1022 }

  1023 

  1024 /**

  1025  * Checks document order of two siblings

  1026  * @param {Element} a

  1027  * @param {Element} b

  1028  * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b

  1029  */

  1030 function siblingCheck( a, b ) {

  1031 	var cur = b && a,

  1032 		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&

  1033 			( ~b.sourceIndex || MAX_NEGATIVE ) -

  1034 			( ~a.sourceIndex || MAX_NEGATIVE );

  1035 

  1036 	// Use IE sourceIndex if available on both nodes

  1037 	if ( diff ) {

  1038 		return diff;

  1039 	}

  1040 

  1041 	// Check if b follows a

  1042 	if ( cur ) {

  1043 		while ( (cur = cur.nextSibling) ) {

  1044 			if ( cur === b ) {

  1045 				return -1;

  1046 			}

  1047 		}

  1048 	}

  1049 

  1050 	return a ? 1 : -1;

  1051 }

  1052 

  1053 /**

  1054  * Returns a function to use in pseudos for input types

  1055  * @param {String} type

  1056  */

  1057 function createInputPseudo( type ) {

  1058 	return function( elem ) {

  1059 		var name = elem.nodeName.toLowerCase();

  1060 		return name === "input" && elem.type === type;

  1061 	};

  1062 }

  1063 

  1064 /**

  1065  * Returns a function to use in pseudos for buttons

  1066  * @param {String} type

  1067  */

  1068 function createButtonPseudo( type ) {

  1069 	return function( elem ) {

  1070 		var name = elem.nodeName.toLowerCase();

  1071 		return (name === "input" || name === "button") && elem.type === type;

  1072 	};

  1073 }

  1074 

  1075 /**

  1076  * Returns a function to use in pseudos for positionals

  1077  * @param {Function} fn

  1078  */

  1079 function createPositionalPseudo( fn ) {

  1080 	return markFunction(function( argument ) {

  1081 		argument = +argument;

  1082 		return markFunction(function( seed, matches ) {

  1083 			var j,

  1084 				matchIndexes = fn( [], seed.length, argument ),

  1085 				i = matchIndexes.length;

  1086 

  1087 			// Match elements found at the specified indexes

  1088 			while ( i-- ) {

  1089 				if ( seed[ (j = matchIndexes[i]) ] ) {

  1090 					seed[j] = !(matches[j] = seed[j]);

  1091 				}

  1092 			}

  1093 		});

  1094 	});

  1095 }

  1096 

  1097 /**

  1098  * Checks a node for validity as a Sizzle context

  1099  * @param {Element|Object=} context

  1100  * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value

  1101  */

  1102 function testContext( context ) {

  1103 	return context && typeof context.getElementsByTagName !== strundefined && context;

  1104 }

  1105 

  1106 // Expose support vars for convenience

  1107 support = Sizzle.support = {};

  1108 

  1109 /**

  1110  * Detects XML nodes

  1111  * @param {Element|Object} elem An element or a document

  1112  * @returns {Boolean} True iff elem is a non-HTML XML node

  1113  */

  1114 isXML = Sizzle.isXML = function( elem ) {

  1115 	// documentElement is verified for cases where it doesn't yet exist

  1116 	// (such as loading iframes in IE - #4833)

  1117 	var documentElement = elem && (elem.ownerDocument || elem).documentElement;

  1118 	return documentElement ? documentElement.nodeName !== "HTML" : false;

  1119 };

  1120 

  1121 /**

  1122  * Sets document-related variables once based on the current document

  1123  * @param {Element|Object} [doc] An element or document object to use to set the document

  1124  * @returns {Object} Returns the current document

  1125  */

  1126 setDocument = Sizzle.setDocument = function( node ) {

  1127 	var hasCompare,

  1128 		doc = node ? node.ownerDocument || node : preferredDoc,

  1129 		parent = doc.defaultView;

  1130 

  1131 	// If no document and documentElement is available, return

  1132 	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {

  1133 		return document;

  1134 	}

  1135