You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@aurora.apache.org by ma...@apache.org on 2014/05/28 21:05:14 UTC
[05/29] Upgrade Aurora UI to bootstrap3
http://git-wip-us.apache.org/repos/asf/incubator-aurora/blob/3a992e2c/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-scenario.js
----------------------------------------------------------------------
diff --git a/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-scenario.js b/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-scenario.js
new file mode 100644
index 0000000..7fa75e9
--- /dev/null
+++ b/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-scenario.js
@@ -0,0 +1,26487 @@
+/*!
+ * jQuery JavaScript Library v1.7.2
+ * http://jquery.com/
+ *
+ * Copyright 2011, John Resig
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * Includes Sizzle.js
+ * http://sizzlejs.com/
+ * Copyright 2011, The Dojo Foundation
+ * Released under the MIT, BSD, and GPL Licenses.
+ *
+ * Date: Wed Mar 21 12:46:34 2012 -0700
+ */
+(function (window, undefined) {
+ 'use strict';
+
+// Use the correct document accordingly with window argument (sandbox)
+ var document = window.document,
+ navigator = window.navigator,
+ location = window.location;
+ var jQuery = (function () {
+
+// Define a local copy of jQuery
+ var jQuery = function (selector, context) {
+ // The jQuery object is actually just the init constructor 'enhanced'
+ return new jQuery.fn.init(selector, context, rootjQuery);
+ },
+
+ // Map over jQuery in case of overwrite
+ _jQuery = window.jQuery,
+
+ // Map over the $ in case of overwrite
+ _$ = window.$,
+
+ // A central reference to the root jQuery(document)
+ rootjQuery,
+
+ // A simple way to check for HTML strings or ID strings
+ // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
+ quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
+
+ // Check if a string has a non-whitespace character in it
+ rnotwhite = /\S/,
+
+ // Used for trimming whitespace
+ trimLeft = /^\s+/,
+ trimRight = /\s+$/,
+
+ // Match a standalone tag
+ rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
+
+ // JSON RegExp
+ rvalidchars = /^[\],:{}\s]*$/,
+ rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
+ rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
+ rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
+
+ // Useragent RegExp
+ rwebkit = /(webkit)[ \/]([\w.]+)/,
+ ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
+ rmsie = /(msie) ([\w.]+)/,
+ rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
+
+ // Matches dashed string for camelizing
+ rdashAlpha = /-([a-z]|[0-9])/ig,
+ rmsPrefix = /^-ms-/,
+
+ // Used by jQuery.camelCase as callback to replace()
+ fcamelCase = function (all, letter) {
+ return ( letter + "" ).toUpperCase();
+ },
+
+ // Keep a UserAgent string for use with jQuery.browser
+ userAgent = navigator.userAgent,
+
+ // For matching the engine and version of the browser
+ browserMatch,
+
+ // The deferred used on DOM ready
+ readyList,
+
+ // The ready event handler
+ DOMContentLoaded,
+
+ // Save a reference to some core methods
+ toString = Object.prototype.toString,
+ hasOwn = Object.prototype.hasOwnProperty,
+ push = Array.prototype.push,
+ slice = Array.prototype.slice,
+ trim = String.prototype.trim,
+ indexOf = Array.prototype.indexOf,
+
+ // [[Class]] -> type pairs
+ class2type = {};
+
+ jQuery.fn = jQuery.prototype = {
+ constructor: jQuery,
+ init: function (selector, context, rootjQuery) {
+ var match, elem, ret, doc;
+
+ // Handle $(""), $(null), or $(undefined)
+ if (!selector) {
+ return this;
+ }
+
+ // Handle $(DOMElement)
+ if (selector.nodeType) {
+ this.context = this[0] = selector;
+ this.length = 1;
+ return this;
+ }
+
+ // The body element only exists once, optimize finding it
+ if (selector === "body" && !context && document.body) {
+ this.context = document;
+ this[0] = document.body;
+ this.selector = selector;
+ this.length = 1;
+ return this;
+ }
+
+ // Handle HTML strings
+ if (typeof selector === "string") {
+ // Are we dealing with HTML string or an ID?
+ if (selector.charAt(0) === "<" && selector.charAt(selector.length - 1) === ">" && selector.length >= 3) {
+ // Assume that strings that start and end with <> are HTML and skip the regex check
+ match = [ null, selector, null ];
+
+ } else {
+ match = quickExpr.exec(selector);
+ }
+
+ // Verify a match, and that no context was specified for #id
+ if (match && (match[1] || !context)) {
+
+ // HANDLE: $(html) -> $(array)
+ if (match[1]) {
+ context = context instanceof jQuery ? context[0] : context;
+ doc = ( context ? context.ownerDocument || context : document );
+
+ // If a single string is passed in and it's a single tag
+ // just do a createElement and skip the rest
+ ret = rsingleTag.exec(selector);
+
+ if (ret) {
+ if (jQuery.isPlainObject(context)) {
+ selector = [ document.createElement(ret[1]) ];
+ jQuery.fn.attr.call(selector, context, true);
+
+ } else {
+ selector = [ doc.createElement(ret[1]) ];
+ }
+
+ } else {
+ ret = jQuery.buildFragment([ match[1] ], [ doc ]);
+ selector = ( ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment ).childNodes;
+ }
+
+ return jQuery.merge(this, selector);
+
+ // HANDLE: $("#id")
+ } else {
+ elem = document.getElementById(match[2]);
+
+ // Check parentNode to catch when Blackberry 4.6 returns
+ // nodes that are no longer in the document #6963
+ if (elem && elem.parentNode) {
+ // Handle the case where IE and Opera return items
+ // by name instead of ID
+ if (elem.id !== match[2]) {
+ return rootjQuery.find(selector);
+ }
+
+ // Otherwise, we inject the element directly into the jQuery object
+ this.length = 1;
+ this[0] = elem;
+ }
+
+ this.context = document;
+ this.selector = selector;
+ return this;
+ }
+
+ // HANDLE: $(expr, $(...))
+ } else if (!context || context.jquery) {
+ return ( context || rootjQuery ).find(selector);
+
+ // HANDLE: $(expr, context)
+ // (which is just equivalent to: $(context).find(expr)
+ } else {
+ return this.constructor(context).find(selector);
+ }
+
+ // HANDLE: $(function)
+ // Shortcut for document ready
+ } else if (jQuery.isFunction(selector)) {
+ return rootjQuery.ready(selector);
+ }
+
+ if (selector.selector !== undefined) {
+ this.selector = selector.selector;
+ this.context = selector.context;
+ }
+
+ return jQuery.makeArray(selector, this);
+ },
+
+ // Start with an empty selector
+ selector: "",
+
+ // The current version of jQuery being used
+ jquery: "1.7.2",
+
+ // The default length of a jQuery object is 0
+ length: 0,
+
+ // The number of elements contained in the matched element set
+ size: function () {
+ return this.length;
+ },
+
+ toArray: function () {
+ return slice.call(this, 0);
+ },
+
+ // Get the Nth element in the matched element set OR
+ // Get the whole matched element set as a clean array
+ get: function (num) {
+ return num == null ?
+
+ // Return a 'clean' array
+ this.toArray() :
+
+ // Return just the object
+ ( num < 0 ? this[ this.length + num ] : this[ num ] );
+ },
+
+ // Take an array of elements and push it onto the stack
+ // (returning the new matched element set)
+ pushStack: function (elems, name, selector) {
+ // Build a new jQuery matched element set
+ var ret = this.constructor();
+
+ if (jQuery.isArray(elems)) {
+ push.apply(ret, elems);
+
+ } else {
+ jQuery.merge(ret, elems);
+ }
+
+ // Add the old object onto the stack (as a reference)
+ ret.prevObject = this;
+
+ ret.context = this.context;
+
+ if (name === "find") {
+ ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
+ } else if (name) {
+ ret.selector = this.selector + "." + name + "(" + selector + ")";
+ }
+
+ // Return the newly-formed element set
+ return ret;
+ },
+
+ // Execute a callback for every element in the matched set.
+ // (You can seed the arguments with an array of args, but this is
+ // only used internally.)
+ each: function (callback, args) {
+ return jQuery.each(this, callback, args);
+ },
+
+ ready: function (fn) {
+ // Attach the listeners
+ jQuery.bindReady();
+
+ // Add the callback
+ readyList.add(fn);
+
+ return this;
+ },
+
+ eq: function (i) {
+ i = +i;
+ return i === -1 ?
+ this.slice(i) :
+ this.slice(i, i + 1);
+ },
+
+ first: function () {
+ return this.eq(0);
+ },
+
+ last: function () {
+ return this.eq(-1);
+ },
+
+ slice: function () {
+ return this.pushStack(slice.apply(this, arguments),
+ "slice", slice.call(arguments).join(","));
+ },
+
+ map: function (callback) {
+ return this.pushStack(jQuery.map(this, function (elem, i) {
+ return callback.call(elem, i, elem);
+ }));
+ },
+
+ end: function () {
+ return this.prevObject || this.constructor(null);
+ },
+
+ // For internal use only.
+ // Behaves like an Array's method, not like a jQuery method.
+ push: push,
+ sort: [].sort,
+ splice: [].splice
+ };
+
+// Give the init function the jQuery prototype for later instantiation
+ jQuery.fn.init.prototype = jQuery.fn;
+
+ jQuery.extend = jQuery.fn.extend = function () {
+ var options, name, src, copy, copyIsArray, clone,
+ target = arguments[0] || {},
+ i = 1,
+ length = arguments.length,
+ deep = false;
+
+ // Handle a deep copy situation
+ if (typeof target === "boolean") {
+ deep = target;
+ target = arguments[1] || {};
+ // skip the boolean and the target
+ i = 2;
+ }
+
+ // Handle case when target is a string or something (possible in deep copy)
+ if (typeof target !== "object" && !jQuery.isFunction(target)) {
+ target = {};
+ }
+
+ // extend jQuery itself if only one argument is passed
+ if (length === i) {
+ target = this;
+ --i;
+ }
+
+ for (; i < length; i++) {
+ // Only deal with non-null/undefined values
+ if ((options = arguments[ i ]) != null) {
+ // Extend the base object
+ for (name in options) {
+ src = target[ name ];
+ copy = options[ name ];
+
+ // Prevent never-ending loop
+ if (target === copy) {
+ continue;
+ }
+
+ // Recurse if we're merging plain objects or arrays
+ if (deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) )) {
+ if (copyIsArray) {
+ copyIsArray = false;
+ clone = src && jQuery.isArray(src) ? src : [];
+
+ } else {
+ clone = src && jQuery.isPlainObject(src) ? src : {};
+ }
+
+ // Never move original objects, clone them
+ target[ name ] = jQuery.extend(deep, clone, copy);
+
+ // Don't bring in undefined values
+ } else if (copy !== undefined) {
+ target[ name ] = copy;
+ }
+ }
+ }
+ }
+
+ // Return the modified object
+ return target;
+ };
+
+ jQuery.extend({
+ noConflict: function (deep) {
+ if (window.$ === jQuery) {
+ window.$ = _$;
+ }
+
+ if (deep && window.jQuery === jQuery) {
+ window.jQuery = _jQuery;
+ }
+
+ return jQuery;
+ },
+
+ // Is the DOM ready to be used? Set to true once it occurs.
+ isReady: false,
+
+ // A counter to track how many items to wait for before
+ // the ready event fires. See #6781
+ readyWait: 1,
+
+ // Hold (or release) the ready event
+ holdReady: function (hold) {
+ if (hold) {
+ jQuery.readyWait++;
+ } else {
+ jQuery.ready(true);
+ }
+ },
+
+ // Handle when the DOM is ready
+ ready: function (wait) {
+ // Either a released hold or an DOMready/load event and not yet ready
+ if ((wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady)) {
+ // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
+ if (!document.body) {
+ return setTimeout(jQuery.ready, 1);
+ }
+
+ // Remember that the DOM is ready
+ jQuery.isReady = true;
+
+ // If a normal DOM Ready event fired, decrement, and wait if need be
+ if (wait !== true && --jQuery.readyWait > 0) {
+ return;
+ }
+
+ // If there are functions bound, to execute
+ readyList.fireWith(document, [ jQuery ]);
+
+ // Trigger any bound ready events
+ if (jQuery.fn.trigger) {
+ jQuery(document).trigger("ready").off("ready");
+ }
+ }
+ },
+
+ bindReady: function () {
+ if (readyList) {
+ return;
+ }
+
+ readyList = jQuery.Callbacks("once memory");
+
+ // Catch cases where $(document).ready() is called after the
+ // browser event has already occurred.
+ if (document.readyState === "complete") {
+ // Handle it asynchronously to allow scripts the opportunity to delay ready
+ return setTimeout(jQuery.ready, 1);
+ }
+
+ // Mozilla, Opera and webkit nightlies currently support this event
+ if (document.addEventListener) {
+ // Use the handy event callback
+ document.addEventListener("DOMContentLoaded", DOMContentLoaded, false);
+
+ // A fallback to window.onload, that will always work
+ window.addEventListener("load", jQuery.ready, false);
+
+ // If IE event model is used
+ } else if (document.attachEvent) {
+ // ensure firing before onload,
+ // maybe late but safe also for iframes
+ document.attachEvent("onreadystatechange", DOMContentLoaded);
+
+ // A fallback to window.onload, that will always work
+ window.attachEvent("onload", jQuery.ready);
+
+ // If IE and not a frame
+ // continually check to see if the document is ready
+ var toplevel = false;
+
+ try {
+ toplevel = window.frameElement == null;
+ } catch (e) {
+ }
+
+ if (document.documentElement.doScroll && toplevel) {
+ doScrollCheck();
+ }
+ }
+ },
+
+ // See test/unit/core.js for details concerning isFunction.
+ // Since version 1.3, DOM methods and functions like alert
+ // aren't supported. They return false on IE (#2968).
+ isFunction: function (obj) {
+ return jQuery.type(obj) === "function";
+ },
+
+ isArray: Array.isArray || function (obj) {
+ return jQuery.type(obj) === "array";
+ },
+
+ isWindow: function (obj) {
+ return obj != null && obj == obj.window;
+ },
+
+ isNumeric: function (obj) {
+ return !isNaN(parseFloat(obj)) && isFinite(obj);
+ },
+
+ type: function (obj) {
+ return obj == null ?
+ String(obj) :
+ class2type[ toString.call(obj) ] || "object";
+ },
+
+ isPlainObject: function (obj) {
+ // Must be an Object.
+ // Because of IE, we also have to check the presence of the constructor property.
+ // Make sure that DOM nodes and window objects don't pass through, as well
+ if (!obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow(obj)) {
+ return false;
+ }
+
+ try {
+ // Not own constructor property must be Object
+ if (obj.constructor && !hasOwn.call(obj, "constructor") && !hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) {
+ return false;
+ }
+ } catch (e) {
+ // IE8,9 Will throw exceptions on certain host objects #9897
+ return false;
+ }
+
+ // Own properties are enumerated firstly, so to speed up,
+ // if last one is own, then all properties are own.
+
+ var key;
+ for (key in obj) {
+ }
+
+ return key === undefined || hasOwn.call(obj, key);
+ },
+
+ isEmptyObject: function (obj) {
+ for (var name in obj) {
+ return false;
+ }
+ return true;
+ },
+
+ error: function (msg) {
+ throw new Error(msg);
+ },
+
+ parseJSON: function (data) {
+ if (typeof data !== "string" || !data) {
+ return null;
+ }
+
+ // Make sure leading/trailing whitespace is removed (IE can't handle it)
+ data = jQuery.trim(data);
+
+ // Attempt to parse using the native JSON parser first
+ if (window.JSON && window.JSON.parse) {
+ return window.JSON.parse(data);
+ }
+
+ // Make sure the incoming data is actual JSON
+ // Logic borrowed from http://json.org/json2.js
+ if (rvalidchars.test(data.replace(rvalidescape, "@")
+ .replace(rvalidtokens, "]")
+ .replace(rvalidbraces, ""))) {
+
+ return ( new Function("return " + data) )();
+
+ }
+ jQuery.error("Invalid JSON: " + data);
+ },
+
+ // Cross-browser xml parsing
+ parseXML: function (data) {
+ if (typeof data !== "string" || !data) {
+ return null;
+ }
+ var xml, tmp;
+ try {
+ if (window.DOMParser) { // Standard
+ tmp = new DOMParser();
+ xml = tmp.parseFromString(data, "text/xml");
+ } else { // IE
+ xml = new ActiveXObject("Microsoft.XMLDOM");
+ xml.async = "false";
+ xml.loadXML(data);
+ }
+ } catch (e) {
+ xml = undefined;
+ }
+ if (!xml || !xml.documentElement || xml.getElementsByTagName("parsererror").length) {
+ jQuery.error("Invalid XML: " + data);
+ }
+ return xml;
+ },
+
+ noop: function () {
+ },
+
+ // Evaluates a script in a global context
+ // Workarounds based on findings by Jim Driscoll
+ // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
+ globalEval: function (data) {
+ if (data && rnotwhite.test(data)) {
+ // We use execScript on Internet Explorer
+ // We use an anonymous function so that context is window
+ // rather than jQuery in Firefox
+ ( window.execScript || function (data) {
+ window[ "eval" ].call(window, data);
+ } )(data);
+ }
+ },
+
+ // Convert dashed to camelCase; used by the css and data modules
+ // Microsoft forgot to hump their vendor prefix (#9572)
+ camelCase: function (string) {
+ return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase);
+ },
+
+ nodeName: function (elem, name) {
+ return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
+ },
+
+ // args is for internal usage only
+ each: function (object, callback, args) {
+ var name, i = 0,
+ length = object.length,
+ isObj = length === undefined || jQuery.isFunction(object);
+
+ if (args) {
+ if (isObj) {
+ for (name in object) {
+ if (callback.apply(object[ name ], args) === false) {
+ break;
+ }
+ }
+ } else {
+ for (; i < length;) {
+ if (callback.apply(object[ i++ ], args) === false) {
+ break;
+ }
+ }
+ }
+
+ // A special, fast, case for the most common use of each
+ } else {
+ if (isObj) {
+ for (name in object) {
+ if (callback.call(object[ name ], name, object[ name ]) === false) {
+ break;
+ }
+ }
+ } else {
+ for (; i < length;) {
+ if (callback.call(object[ i ], i, object[ i++ ]) === false) {
+ break;
+ }
+ }
+ }
+ }
+
+ return object;
+ },
+
+ // Use native String.trim function wherever possible
+ trim: trim ?
+ function (text) {
+ return text == null ?
+ "" :
+ trim.call(text);
+ } :
+
+ // Otherwise use our own trimming functionality
+ function (text) {
+ return text == null ?
+ "" :
+ text.toString().replace(trimLeft, "").replace(trimRight, "");
+ },
+
+ // results is for internal usage only
+ makeArray: function (array, results) {
+ var ret = results || [];
+
+ if (array != null) {
+ // The window, strings (and functions) also have 'length'
+ // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
+ var type = jQuery.type(array);
+
+ if (array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow(array)) {
+ push.call(ret, array);
+ } else {
+ jQuery.merge(ret, array);
+ }
+ }
+
+ return ret;
+ },
+
+ inArray: function (elem, array, i) {
+ var len;
+
+ if (array) {
+ if (indexOf) {
+ return indexOf.call(array, elem, i);
+ }
+
+ len = array.length;
+ i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
+
+ for (; i < len; i++) {
+ // Skip accessing in sparse arrays
+ if (i in array && array[ i ] === elem) {
+ return i;
+ }
+ }
+ }
+
+ return -1;
+ },
+
+ merge: function (first, second) {
+ var i = first.length,
+ j = 0;
+
+ if (typeof second.length === "number") {
+ for (var l = second.length; j < l; j++) {
+ first[ i++ ] = second[ j ];
+ }
+
+ } else {
+ while (second[j] !== undefined) {
+ first[ i++ ] = second[ j++ ];
+ }
+ }
+
+ first.length = i;
+
+ return first;
+ },
+
+ grep: function (elems, callback, inv) {
+ var ret = [], retVal;
+ inv = !!inv;
+
+ // Go through the array, only saving the items
+ // that pass the validator function
+ for (var i = 0, length = elems.length; i < length; i++) {
+ retVal = !!callback(elems[ i ], i);
+ if (inv !== retVal) {
+ ret.push(elems[ i ]);
+ }
+ }
+
+ return ret;
+ },
+
+ // arg is for internal usage only
+ map: function (elems, callback, arg) {
+ var value, key, ret = [],
+ i = 0,
+ length = elems.length,
+ // jquery objects are treated as arrays
+ isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length - 1 ] ) || length === 0 || jQuery.isArray(elems) );
+
+ // Go through the array, translating each of the items to their
+ if (isArray) {
+ for (; i < length; i++) {
+ value = callback(elems[ i ], i, arg);
+
+ if (value != null) {
+ ret[ ret.length ] = value;
+ }
+ }
+
+ // Go through every key on the object,
+ } else {
+ for (key in elems) {
+ value = callback(elems[ key ], key, arg);
+
+ if (value != null) {
+ ret[ ret.length ] = value;
+ }
+ }
+ }
+
+ // Flatten any nested arrays
+ return ret.concat.apply([], ret);
+ },
+
+ // A global GUID counter for objects
+ guid: 1,
+
+ // Bind a function to a context, optionally partially applying any
+ // arguments.
+ proxy: function (fn, context) {
+ if (typeof context === "string") {
+ var tmp = fn[ context ];
+ context = fn;
+ fn = tmp;
+ }
+
+ // Quick check to determine if target is callable, in the spec
+ // this throws a TypeError, but we will just return undefined.
+ if (!jQuery.isFunction(fn)) {
+ return undefined;
+ }
+
+ // Simulated bind
+ var args = slice.call(arguments, 2),
+ proxy = function () {
+ return fn.apply(context, args.concat(slice.call(arguments)));
+ };
+
+ // Set the guid of unique handler to the same of original handler, so it can be removed
+ proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
+
+ return proxy;
+ },
+
+ // Mutifunctional method to get and set values to a collection
+ // The value/s can optionally be executed if it's a function
+ access: function (elems, fn, key, value, chainable, emptyGet, pass) {
+ var exec,
+ bulk = key == null,
+ i = 0,
+ length = elems.length;
+
+ // Sets many values
+ if (key && typeof key === "object") {
+ for (i in key) {
+ jQuery.access(elems, fn, i, key[i], 1, emptyGet, value);
+ }
+ chainable = 1;
+
+ // Sets one value
+ } else if (value !== undefined) {
+ // Optionally, function values get executed if exec is true
+ exec = pass === undefined && jQuery.isFunction(value);
+
+ if (bulk) {
+ // Bulk operations only iterate when executing function values
+ if (exec) {
+ exec = fn;
+ fn = function (elem, key, value) {
+ return exec.call(jQuery(elem), value);
+ };
+
+ // Otherwise they run against the entire set
+ } else {
+ fn.call(elems, value);
+ fn = null;
+ }
+ }
+
+ if (fn) {
+ for (; i < length; i++) {
+ fn(elems[i], key, exec ? value.call(elems[i], i, fn(elems[i], key)) : value, pass);
+ }
+ }
+
+ chainable = 1;
+ }
+
+ return chainable ?
+ elems :
+
+ // Gets
+ bulk ?
+ fn.call(elems) :
+ length ? fn(elems[0], key) : emptyGet;
+ },
+
+ now: function () {
+ return ( new Date() ).getTime();
+ },
+
+ // Use of jQuery.browser is frowned upon.
+ // More details: http://docs.jquery.com/Utilities/jQuery.browser
+ uaMatch: function (ua) {
+ ua = ua.toLowerCase();
+
+ var match = rwebkit.exec(ua) ||
+ ropera.exec(ua) ||
+ rmsie.exec(ua) ||
+ ua.indexOf("compatible") < 0 && rmozilla.exec(ua) ||
+ [];
+
+ return { browser: match[1] || "", version: match[2] || "0" };
+ },
+
+ sub: function () {
+ function jQuerySub(selector, context) {
+ return new jQuerySub.fn.init(selector, context);
+ }
+
+ jQuery.extend(true, jQuerySub, this);
+ jQuerySub.superclass = this;
+ jQuerySub.fn = jQuerySub.prototype = this();
+ jQuerySub.fn.constructor = jQuerySub;
+ jQuerySub.sub = this.sub;
+ jQuerySub.fn.init = function init(selector, context) {
+ if (context && context instanceof jQuery && !(context instanceof jQuerySub)) {
+ context = jQuerySub(context);
+ }
+
+ return jQuery.fn.init.call(this, selector, context, rootjQuerySub);
+ };
+ jQuerySub.fn.init.prototype = jQuerySub.fn;
+ var rootjQuerySub = jQuerySub(document);
+ return jQuerySub;
+ },
+
+ browser: {}
+ });
+
+// Populate the class2type map
+ jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function (i, name) {
+ class2type[ "[object " + name + "]" ] = name.toLowerCase();
+ });
+
+ browserMatch = jQuery.uaMatch(userAgent);
+ if (browserMatch.browser) {
+ jQuery.browser[ browserMatch.browser ] = true;
+ jQuery.browser.version = browserMatch.version;
+ }
+
+// Deprecated, use jQuery.browser.webkit instead
+ if (jQuery.browser.webkit) {
+ jQuery.browser.safari = true;
+ }
+
+// IE doesn't match non-breaking spaces with \s
+ if (rnotwhite.test("\xA0")) {
+ trimLeft = /^[\s\xA0]+/;
+ trimRight = /[\s\xA0]+$/;
+ }
+
+// All jQuery objects should point back to these
+ rootjQuery = jQuery(document);
+
+// Cleanup functions for the document ready method
+ if (document.addEventListener) {
+ DOMContentLoaded = function () {
+ document.removeEventListener("DOMContentLoaded", DOMContentLoaded, false);
+ jQuery.ready();
+ };
+
+ } else if (document.attachEvent) {
+ DOMContentLoaded = function () {
+ // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
+ if (document.readyState === "complete") {
+ document.detachEvent("onreadystatechange", DOMContentLoaded);
+ jQuery.ready();
+ }
+ };
+ }
+
+// The DOM ready check for Internet Explorer
+ function doScrollCheck() {
+ if (jQuery.isReady) {
+ return;
+ }
+
+ try {
+ // If IE is used, use the trick by Diego Perini
+ // http://javascript.nwbox.com/IEContentLoaded/
+ document.documentElement.doScroll("left");
+ } catch (e) {
+ setTimeout(doScrollCheck, 1);
+ return;
+ }
+
+ // and execute any waiting functions
+ jQuery.ready();
+ }
+
+ return jQuery;
+
+ })();
+
+
+// String to Object flags format cache
+ var flagsCache = {};
+
+// Convert String-formatted flags into Object-formatted ones and store in cache
+ function createFlags(flags) {
+ var object = flagsCache[ flags ] = {},
+ i, length;
+ flags = flags.split(/\s+/);
+ for (i = 0, length = flags.length; i < length; i++) {
+ object[ flags[i] ] = true;
+ }
+ return object;
+ }
+
+ /*
+ * Create a callback list using the following parameters:
+ *
+ * flags: an optional list of space-separated flags that will change how
+ * the callback list behaves
+ *
+ * By default a callback list will act like an event callback list and can be
+ * "fired" multiple times.
+ *
+ * Possible flags:
+ *
+ * once: will ensure the callback list can only be fired once (like a Deferred)
+ *
+ * memory: will keep track of previous values and will call any callback added
+ * after the list has been fired right away with the latest "memorized"
+ * values (like a Deferred)
+ *
+ * unique: will ensure a callback can only be added once (no duplicate in the list)
+ *
+ * stopOnFalse: interrupt callings when a callback returns false
+ *
+ */
+ jQuery.Callbacks = function (flags) {
+
+ // Convert flags from String-formatted to Object-formatted
+ // (we check in cache first)
+ flags = flags ? ( flagsCache[ flags ] || createFlags(flags) ) : {};
+
+ var // Actual callback list
+ list = [],
+ // Stack of fire calls for repeatable lists
+ stack = [],
+ // Last fire value (for non-forgettable lists)
+ memory,
+ // Flag to know if list was already fired
+ fired,
+ // Flag to know if list is currently firing
+ firing,
+ // First callback to fire (used internally by add and fireWith)
+ firingStart,
+ // End of the loop when firing
+ firingLength,
+ // Index of currently firing callback (modified by remove if needed)
+ firingIndex,
+ // Add one or several callbacks to the list
+ add = function (args) {
+ var i,
+ length,
+ elem,
+ type,
+ actual;
+ for (i = 0, length = args.length; i < length; i++) {
+ elem = args[ i ];
+ type = jQuery.type(elem);
+ if (type === "array") {
+ // Inspect recursively
+ add(elem);
+ } else if (type === "function") {
+ // Add if not in unique mode and callback is not in
+ if (!flags.unique || !self.has(elem)) {
+ list.push(elem);
+ }
+ }
+ }
+ },
+ // Fire callbacks
+ fire = function (context, args) {
+ args = args || [];
+ memory = !flags.memory || [ context, args ];
+ fired = true;
+ firing = true;
+ firingIndex = firingStart || 0;
+ firingStart = 0;
+ firingLength = list.length;
+ for (; list && firingIndex < firingLength; firingIndex++) {
+ if (list[ firingIndex ].apply(context, args) === false && flags.stopOnFalse) {
+ memory = true; // Mark as halted
+ break;
+ }
+ }
+ firing = false;
+ if (list) {
+ if (!flags.once) {
+ if (stack && stack.length) {
+ memory = stack.shift();
+ self.fireWith(memory[ 0 ], memory[ 1 ]);
+ }
+ } else if (memory === true) {
+ self.disable();
+ } else {
+ list = [];
+ }
+ }
+ },
+ // Actual Callbacks object
+ self = {
+ // Add a callback or a collection of callbacks to the list
+ add: function () {
+ if (list) {
+ var length = list.length;
+ add(arguments);
+ // Do we need to add the callbacks to the
+ // current firing batch?
+ if (firing) {
+ firingLength = list.length;
+ // With memory, if we're not firing then
+ // we should call right away, unless previous
+ // firing was halted (stopOnFalse)
+ } else if (memory && memory !== true) {
+ firingStart = length;
+ fire(memory[ 0 ], memory[ 1 ]);
+ }
+ }
+ return this;
+ },
+ // Remove a callback from the list
+ remove: function () {
+ if (list) {
+ var args = arguments,
+ argIndex = 0,
+ argLength = args.length;
+ for (; argIndex < argLength; argIndex++) {
+ for (var i = 0; i < list.length; i++) {
+ if (args[ argIndex ] === list[ i ]) {
+ // Handle firingIndex and firingLength
+ if (firing) {
+ if (i <= firingLength) {
+ firingLength--;
+ if (i <= firingIndex) {
+ firingIndex--;
+ }
+ }
+ }
+ // Remove the element
+ list.splice(i--, 1);
+ // If we have some unicity property then
+ // we only need to do this once
+ if (flags.unique) {
+ break;
+ }
+ }
+ }
+ }
+ }
+ return this;
+ },
+ // Control if a given callback is in the list
+ has: function (fn) {
+ if (list) {
+ var i = 0,
+ length = list.length;
+ for (; i < length; i++) {
+ if (fn === list[ i ]) {
+ return true;
+ }
+ }
+ }
+ return false;
+ },
+ // Remove all callbacks from the list
+ empty: function () {
+ list = [];
+ return this;
+ },
+ // Have the list do nothing anymore
+ disable: function () {
+ list = stack = memory = undefined;
+ return this;
+ },
+ // Is it disabled?
+ disabled: function () {
+ return !list;
+ },
+ // Lock the list in its current state
+ lock: function () {
+ stack = undefined;
+ if (!memory || memory === true) {
+ self.disable();
+ }
+ return this;
+ },
+ // Is it locked?
+ locked: function () {
+ return !stack;
+ },
+ // Call all callbacks with the given context and arguments
+ fireWith: function (context, args) {
+ if (stack) {
+ if (firing) {
+ if (!flags.once) {
+ stack.push([ context, args ]);
+ }
+ } else if (!( flags.once && memory )) {
+ fire(context, args);
+ }
+ }
+ return this;
+ },
+ // Call all the callbacks with the given arguments
+ fire: function () {
+ self.fireWith(this, arguments);
+ return this;
+ },
+ // To know if the callbacks have already been called at least once
+ fired: function () {
+ return !!fired;
+ }
+ };
+
+ return self;
+ };
+
+
+ var // Static reference to slice
+ sliceDeferred = [].slice;
+
+ jQuery.extend({
+
+ Deferred: function (func) {
+ var doneList = jQuery.Callbacks("once memory"),
+ failList = jQuery.Callbacks("once memory"),
+ progressList = jQuery.Callbacks("memory"),
+ state = "pending",
+ lists = {
+ resolve: doneList,
+ reject: failList,
+ notify: progressList
+ },
+ promise = {
+ done: doneList.add,
+ fail: failList.add,
+ progress: progressList.add,
+
+ state: function () {
+ return state;
+ },
+
+ // Deprecated
+ isResolved: doneList.fired,
+ isRejected: failList.fired,
+
+ then: function (doneCallbacks, failCallbacks, progressCallbacks) {
+ deferred.done(doneCallbacks).fail(failCallbacks).progress(progressCallbacks);
+ return this;
+ },
+ always: function () {
+ deferred.done.apply(deferred, arguments).fail.apply(deferred, arguments);
+ return this;
+ },
+ pipe: function (fnDone, fnFail, fnProgress) {
+ return jQuery.Deferred(function (newDefer) {
+ jQuery.each({
+ done: [ fnDone, "resolve" ],
+ fail: [ fnFail, "reject" ],
+ progress: [ fnProgress, "notify" ]
+ }, function (handler, data) {
+ var fn = data[ 0 ],
+ action = data[ 1 ],
+ returned;
+ if (jQuery.isFunction(fn)) {
+ deferred[ handler ](function () {
+ returned = fn.apply(this, arguments);
+ if (returned && jQuery.isFunction(returned.promise)) {
+ returned.promise().then(newDefer.resolve, newDefer.reject, newDefer.notify);
+ } else {
+ newDefer[ action + "With" ](this === deferred ? newDefer : this, [ returned ]);
+ }
+ });
+ } else {
+ deferred[ handler ](newDefer[ action ]);
+ }
+ });
+ }).promise();
+ },
+ // Get a promise for this deferred
+ // If obj is provided, the promise aspect is added to the object
+ promise: function (obj) {
+ if (obj == null) {
+ obj = promise;
+ } else {
+ for (var key in promise) {
+ obj[ key ] = promise[ key ];
+ }
+ }
+ return obj;
+ }
+ },
+ deferred = promise.promise({}),
+ key;
+
+ for (key in lists) {
+ deferred[ key ] = lists[ key ].fire;
+ deferred[ key + "With" ] = lists[ key ].fireWith;
+ }
+
+ // Handle state
+ deferred.done(function () {
+ state = "resolved";
+ }, failList.disable, progressList.lock).fail(function () {
+ state = "rejected";
+ }, doneList.disable, progressList.lock);
+
+ // Call given func if any
+ if (func) {
+ func.call(deferred, deferred);
+ }
+
+ // All done!
+ return deferred;
+ },
+
+ // Deferred helper
+ when: function (firstParam) {
+ var args = sliceDeferred.call(arguments, 0),
+ i = 0,
+ length = args.length,
+ pValues = new Array(length),
+ count = length,
+ pCount = length,
+ deferred = length <= 1 && firstParam && jQuery.isFunction(firstParam.promise) ?
+ firstParam :
+ jQuery.Deferred(),
+ promise = deferred.promise();
+
+ function resolveFunc(i) {
+ return function (value) {
+ args[ i ] = arguments.length > 1 ? sliceDeferred.call(arguments, 0) : value;
+ if (!( --count )) {
+ deferred.resolveWith(deferred, args);
+ }
+ };
+ }
+
+ function progressFunc(i) {
+ return function (value) {
+ pValues[ i ] = arguments.length > 1 ? sliceDeferred.call(arguments, 0) : value;
+ deferred.notifyWith(promise, pValues);
+ };
+ }
+
+ if (length > 1) {
+ for (; i < length; i++) {
+ if (args[ i ] && args[ i ].promise && jQuery.isFunction(args[ i ].promise)) {
+ args[ i ].promise().then(resolveFunc(i), deferred.reject, progressFunc(i));
+ } else {
+ --count;
+ }
+ }
+ if (!count) {
+ deferred.resolveWith(deferred, args);
+ }
+ } else if (deferred !== firstParam) {
+ deferred.resolveWith(deferred, length ? [ firstParam ] : []);
+ }
+ return promise;
+ }
+ });
+
+
+ jQuery.support = (function () {
+
+ var support,
+ all,
+ a,
+ select,
+ opt,
+ input,
+ fragment,
+ tds,
+ events,
+ eventName,
+ i,
+ isSupported,
+ div = document.createElement("div"),
+ documentElement = document.documentElement;
+
+ // Preliminary tests
+ div.setAttribute("className", "t");
+ div.innerHTML = " <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
+
+ all = div.getElementsByTagName("*");
+ a = div.getElementsByTagName("a")[ 0 ];
+
+ // Can't get basic test support
+ if (!all || !all.length || !a) {
+ return {};
+ }
+
+ // First batch of supports tests
+ select = document.createElement("select");
+ opt = select.appendChild(document.createElement("option"));
+ input = div.getElementsByTagName("input")[ 0 ];
+
+ support = {
+ // IE strips leading whitespace when .innerHTML is used
+ leadingWhitespace: ( div.firstChild.nodeType === 3 ),
+
+ // Make sure that tbody elements aren't automatically inserted
+ // IE will insert them into empty tables
+ tbody: !div.getElementsByTagName("tbody").length,
+
+ // Make sure that link elements get serialized correctly by innerHTML
+ // This requires a wrapper element in IE
+ htmlSerialize: !!div.getElementsByTagName("link").length,
+
+ // Get the style information from getAttribute
+ // (IE uses .cssText instead)
+ style: /top/.test(a.getAttribute("style")),
+
+ // Make sure that URLs aren't manipulated
+ // (IE normalizes it by default)
+ hrefNormalized: ( a.getAttribute("href") === "/a" ),
+
+ // Make sure that element opacity exists
+ // (IE uses filter instead)
+ // Use a regex to work around a WebKit issue. See #5145
+ opacity: /^0.55/.test(a.style.opacity),
+
+ // Verify style float existence
+ // (IE uses styleFloat instead of cssFloat)
+ cssFloat: !!a.style.cssFloat,
+
+ // Make sure that if no value is specified for a checkbox
+ // that it defaults to "on".
+ // (WebKit defaults to "" instead)
+ checkOn: ( input.value === "on" ),
+
+ // Make sure that a selected-by-default option has a working selected property.
+ // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
+ optSelected: opt.selected,
+
+ // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
+ getSetAttribute: div.className !== "t",
+
+ // Tests for enctype support on a form(#6743)
+ enctype: !!document.createElement("form").enctype,
+
+ // Makes sure cloning an html5 element does not cause problems
+ // Where outerHTML is undefined, this still works
+ html5Clone: document.createElement("nav").cloneNode(true).outerHTML !== "<:nav></:nav>",
+
+ // Will be defined later
+ submitBubbles: true,
+ changeBubbles: true,
+ focusinBubbles: false,
+ deleteExpando: true,
+ noCloneEvent: true,
+ inlineBlockNeedsLayout: false,
+ shrinkWrapBlocks: false,
+ reliableMarginRight: true,
+ pixelMargin: true
+ };
+
+ // jQuery.boxModel DEPRECATED in 1.3, use jQuery.support.boxModel instead
+ jQuery.boxModel = support.boxModel = (document.compatMode === "CSS1Compat");
+
+ // Make sure checked status is properly cloned
+ input.checked = true;
+ support.noCloneChecked = input.cloneNode(true).checked;
+
+ // Make sure that the options inside disabled selects aren't marked as disabled
+ // (WebKit marks them as disabled)
+ select.disabled = true;
+ support.optDisabled = !opt.disabled;
+
+ // Test to see if it's possible to delete an expando from an element
+ // Fails in Internet Explorer
+ try {
+ delete div.test;
+ } catch (e) {
+ support.deleteExpando = false;
+ }
+
+ if (!div.addEventListener && div.attachEvent && div.fireEvent) {
+ div.attachEvent("onclick", function () {
+ // Cloning a node shouldn't copy over any
+ // bound event handlers (IE does this)
+ support.noCloneEvent = false;
+ });
+ div.cloneNode(true).fireEvent("onclick");
+ }
+
+ // Check if a radio maintains its value
+ // after being appended to the DOM
+ input = document.createElement("input");
+ input.value = "t";
+ input.setAttribute("type", "radio");
+ support.radioValue = input.value === "t";
+
+ input.setAttribute("checked", "checked");
+
+ // #11217 - WebKit loses check when the name is after the checked attribute
+ input.setAttribute("name", "t");
+
+ div.appendChild(input);
+ fragment = document.createDocumentFragment();
+ fragment.appendChild(div.lastChild);
+
+ // WebKit doesn't clone checked state correctly in fragments
+ support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked;
+
+ // Check if a disconnected checkbox will retain its checked
+ // value of true after appended to the DOM (IE6/7)
+ support.appendChecked = input.checked;
+
+ fragment.removeChild(input);
+ fragment.appendChild(div);
+
+ // Technique from Juriy Zaytsev
+ // http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
+ // We only care about the case where non-standard event systems
+ // are used, namely in IE. Short-circuiting here helps us to
+ // avoid an eval call (in setAttribute) which can cause CSP
+ // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
+ if (div.attachEvent) {
+ for (i in {
+ submit: 1,
+ change: 1,
+ focusin: 1
+ }) {
+ eventName = "on" + i;
+ isSupported = ( eventName in div );
+ if (!isSupported) {
+ div.setAttribute(eventName, "return;");
+ isSupported = ( typeof div[ eventName ] === "function" );
+ }
+ support[ i + "Bubbles" ] = isSupported;
+ }
+ }
+
+ fragment.removeChild(div);
+
+ // Null elements to avoid leaks in IE
+ fragment = select = opt = div = input = null;
+
+ // Run tests that need a body at doc ready
+ jQuery(function () {
+ var container, outer, inner, table, td, offsetSupport,
+ marginDiv, conMarginTop, style, html, positionTopLeftWidthHeight,
+ paddingMarginBorderVisibility, paddingMarginBorder,
+ body = document.getElementsByTagName("body")[0];
+
+ if (!body) {
+ // Return for frameset docs that don't have a body
+ return;
+ }
+
+ conMarginTop = 1;
+ paddingMarginBorder = "padding:0;margin:0;border:";
+ positionTopLeftWidthHeight = "position:absolute;top:0;left:0;width:1px;height:1px;";
+ paddingMarginBorderVisibility = paddingMarginBorder + "0;visibility:hidden;";
+ style = "style='" + positionTopLeftWidthHeight + paddingMarginBorder + "5px solid #000;";
+ html = "<div " + style + "display:block;'><div style='" + paddingMarginBorder + "0;display:block;overflow:hidden;'></div></div>" +
+ "<table " + style + "' cellpadding='0' cellspacing='0'>" +
+ "<tr><td></td></tr></table>";
+
+ container = document.createElement("div");
+ container.style.cssText = paddingMarginBorderVisibility + "width:0;height:0;position:static;top:0;margin-top:" + conMarginTop + "px";
+ body.insertBefore(container, body.firstChild);
+
+ // Construct the test element
+ div = document.createElement("div");
+ container.appendChild(div);
+
+ // Check if table cells still have offsetWidth/Height when they are set
+ // to display:none and there are still other visible table cells in a
+ // table row; if so, offsetWidth/Height are not reliable for use when
+ // determining if an element has been hidden directly using
+ // display:none (it is still safe to use offsets if a parent element is
+ // hidden; don safety goggles and see bug #4512 for more information).
+ // (only IE 8 fails this test)
+ div.innerHTML = "<table><tr><td style='" + paddingMarginBorder + "0;display:none'></td><td>t</td></tr></table>";
+ tds = div.getElementsByTagName("td");
+ isSupported = ( tds[ 0 ].offsetHeight === 0 );
+
+ tds[ 0 ].style.display = "";
+ tds[ 1 ].style.display = "none";
+
+ // Check if empty table cells still have offsetWidth/Height
+ // (IE <= 8 fail this test)
+ support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
+
+ // Check if div with explicit width and no margin-right incorrectly
+ // gets computed margin-right based on width of container. For more
+ // info see bug #3333
+ // Fails in WebKit before Feb 2011 nightlies
+ // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
+ if (window.getComputedStyle) {
+ div.innerHTML = "";
+ marginDiv = document.createElement("div");
+ marginDiv.style.width = "0";
+ marginDiv.style.marginRight = "0";
+ div.style.width = "2px";
+ div.appendChild(marginDiv);
+ support.reliableMarginRight =
+ ( parseInt(( window.getComputedStyle(marginDiv, null) || { marginRight: 0 } ).marginRight, 10) || 0 ) === 0;
+ }
+
+ if (typeof div.style.zoom !== "undefined") {
+ // Check if natively block-level elements act like inline-block
+ // elements when setting their display to 'inline' and giving
+ // them layout
+ // (IE < 8 does this)
+ div.innerHTML = "";
+ div.style.width = div.style.padding = "1px";
+ div.style.border = 0;
+ div.style.overflow = "hidden";
+ div.style.display = "inline";
+ div.style.zoom = 1;
+ support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
+
+ // Check if elements with layout shrink-wrap their children
+ // (IE 6 does this)
+ div.style.display = "block";
+ div.style.overflow = "visible";
+ div.innerHTML = "<div style='width:5px;'></div>";
+ support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
+ }
+
+ div.style.cssText = positionTopLeftWidthHeight + paddingMarginBorderVisibility;
+ div.innerHTML = html;
+
+ outer = div.firstChild;
+ inner = outer.firstChild;
+ td = outer.nextSibling.firstChild.firstChild;
+
+ offsetSupport = {
+ doesNotAddBorder: ( inner.offsetTop !== 5 ),
+ doesAddBorderForTableAndCells: ( td.offsetTop === 5 )
+ };
+
+ inner.style.position = "fixed";
+ inner.style.top = "20px";
+
+ // safari subtracts parent border width here which is 5px
+ offsetSupport.fixedPosition = ( inner.offsetTop === 20 || inner.offsetTop === 15 );
+ inner.style.position = inner.style.top = "";
+
+ outer.style.overflow = "hidden";
+ outer.style.position = "relative";
+
+ offsetSupport.subtractsBorderForOverflowNotVisible = ( inner.offsetTop === -5 );
+ offsetSupport.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== conMarginTop );
+
+ if (window.getComputedStyle) {
+ div.style.marginTop = "1%";
+ support.pixelMargin = ( window.getComputedStyle(div, null) || { marginTop: 0 } ).marginTop !== "1%";
+ }
+
+ if (typeof container.style.zoom !== "undefined") {
+ container.style.zoom = 1;
+ }
+
+ body.removeChild(container);
+ marginDiv = div = container = null;
+
+ jQuery.extend(support, offsetSupport);
+ });
+
+ return support;
+ })();
+
+
+ var rbrace = /^(?:\{.*\}|\[.*\])$/,
+ rmultiDash = /([A-Z])/g;
+
+ jQuery.extend({
+ cache: {},
+
+ // Please use with caution
+ uuid: 0,
+
+ // Unique for each copy of jQuery on the page
+ // Non-digits removed to match rinlinejQuery
+ expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace(/\D/g, ""),
+
+ // The following elements throw uncatchable exceptions if you
+ // attempt to add expando properties to them.
+ noData: {
+ "embed": true,
+ // Ban all objects except for Flash (which handle expandos)
+ "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
+ "applet": true
+ },
+
+ hasData: function (elem) {
+ elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
+ return !!elem && !isEmptyDataObject(elem);
+ },
+
+ data: function (elem, name, data, pvt /* Internal Use Only */) {
+ if (!jQuery.acceptData(elem)) {
+ return;
+ }
+
+ var privateCache, thisCache, ret,
+ internalKey = jQuery.expando,
+ getByName = typeof name === "string",
+
+ // We have to handle DOM nodes and JS objects differently because IE6-7
+ // can't GC object references properly across the DOM-JS boundary
+ isNode = elem.nodeType,
+
+ // Only DOM nodes need the global jQuery cache; JS object data is
+ // attached directly to the object so GC can occur automatically
+ cache = isNode ? jQuery.cache : elem,
+
+ // Only defining an ID for JS objects if its cache already exists allows
+ // the code to shortcut on the same path as a DOM node with no cache
+ id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey,
+ isEvents = name === "events";
+
+ // Avoid doing any more work than we need to when trying to get data on an
+ // object that has no data at all
+ if ((!id || !cache[id] || (!isEvents && !pvt && !cache[id].data)) && getByName && data === undefined) {
+ return;
+ }
+
+ if (!id) {
+ // Only DOM nodes need a new unique ID for each element since their data
+ // ends up in the global cache
+ if (isNode) {
+ elem[ internalKey ] = id = ++jQuery.uuid;
+ } else {
+ id = internalKey;
+ }
+ }
+
+ if (!cache[ id ]) {
+ cache[ id ] = {};
+
+ // Avoids exposing jQuery metadata on plain JS objects when the object
+ // is serialized using JSON.stringify
+ if (!isNode) {
+ cache[ id ].toJSON = jQuery.noop;
+ }
+ }
+
+ // An object can be passed to jQuery.data instead of a key/value pair; this gets
+ // shallow copied over onto the existing cache
+ if (typeof name === "object" || typeof name === "function") {
+ if (pvt) {
+ cache[ id ] = jQuery.extend(cache[ id ], name);
+ } else {
+ cache[ id ].data = jQuery.extend(cache[ id ].data, name);
+ }
+ }
+
+ privateCache = thisCache = cache[ id ];
+
+ // jQuery data() is stored in a separate object inside the object's internal data
+ // cache in order to avoid key collisions between internal data and user-defined
+ // data.
+ if (!pvt) {
+ if (!thisCache.data) {
+ thisCache.data = {};
+ }
+
+ thisCache = thisCache.data;
+ }
+
+ if (data !== undefined) {
+ thisCache[ jQuery.camelCase(name) ] = data;
+ }
+
+ // Users should not attempt to inspect the internal events object using jQuery.data,
+ // it is undocumented and subject to change. But does anyone listen? No.
+ if (isEvents && !thisCache[ name ]) {
+ return privateCache.events;
+ }
+
+ // Check for both converted-to-camel and non-converted data property names
+ // If a data property was specified
+ if (getByName) {
+
+ // First Try to find as-is property data
+ ret = thisCache[ name ];
+
+ // Test for null|undefined property data
+ if (ret == null) {
+
+ // Try to find the camelCased property
+ ret = thisCache[ jQuery.camelCase(name) ];
+ }
+ } else {
+ ret = thisCache;
+ }
+
+ return ret;
+ },
+
+ removeData: function (elem, name, pvt /* Internal Use Only */) {
+ if (!jQuery.acceptData(elem)) {
+ return;
+ }
+
+ var thisCache, i, l,
+
+ // Reference to internal data cache key
+ internalKey = jQuery.expando,
+
+ isNode = elem.nodeType,
+
+ // See jQuery.data for more information
+ cache = isNode ? jQuery.cache : elem,
+
+ // See jQuery.data for more information
+ id = isNode ? elem[ internalKey ] : internalKey;
+
+ // If there is already no cache entry for this object, there is no
+ // purpose in continuing
+ if (!cache[ id ]) {
+ return;
+ }
+
+ if (name) {
+
+ thisCache = pvt ? cache[ id ] : cache[ id ].data;
+
+ if (thisCache) {
+
+ // Support array or space separated string names for data keys
+ if (!jQuery.isArray(name)) {
+
+ // try the string as a key before any manipulation
+ if (name in thisCache) {
+ name = [ name ];
+ } else {
+
+ // split the camel cased version by spaces unless a key with the spaces exists
+ name = jQuery.camelCase(name);
+ if (name in thisCache) {
+ name = [ name ];
+ } else {
+ name = name.split(" ");
+ }
+ }
+ }
+
+ for (i = 0, l = name.length; i < l; i++) {
+ delete thisCache[ name[i] ];
+ }
+
+ // If there is no data left in the cache, we want to continue
+ // and let the cache object itself get destroyed
+ if (!( pvt ? isEmptyDataObject : jQuery.isEmptyObject )(thisCache)) {
+ return;
+ }
+ }
+ }
+
+ // See jQuery.data for more information
+ if (!pvt) {
+ delete cache[ id ].data;
+
+ // Don't destroy the parent cache unless the internal data object
+ // had been the only thing left in it
+ if (!isEmptyDataObject(cache[ id ])) {
+ return;
+ }
+ }
+
+ // Browsers that fail expando deletion also refuse to delete expandos on
+ // the window, but it will allow it on all other JS objects; other browsers
+ // don't care
+ // Ensure that `cache` is not a window object #10080
+ if (jQuery.support.deleteExpando || !cache.setInterval) {
+ delete cache[ id ];
+ } else {
+ cache[ id ] = null;
+ }
+
+ // We destroyed the cache and need to eliminate the expando on the node to avoid
+ // false lookups in the cache for entries that no longer exist
+ if (isNode) {
+ // IE does not allow us to delete expando properties from nodes,
+ // nor does it have a removeAttribute function on Document nodes;
+ // we must handle all of these cases
+ if (jQuery.support.deleteExpando) {
+ delete elem[ internalKey ];
+ } else if (elem.removeAttribute) {
+ elem.removeAttribute(internalKey);
+ } else {
+ elem[ internalKey ] = null;
+ }
+ }
+ },
+
+ // For internal use only.
+ _data: function (elem, name, data) {
+ return jQuery.data(elem, name, data, true);
+ },
+
+ // A method for determining if a DOM node can handle the data expando
+ acceptData: function (elem) {
+ if (elem.nodeName) {
+ var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
+
+ if (match) {
+ return !(match === true || elem.getAttribute("classid") !== match);
+ }
+ }
+
+ return true;
+ }
+ });
+
+ jQuery.fn.extend({
+ data: function (key, value) {
+ var parts, part, attr, name, l,
+ elem = this[0],
+ i = 0,
+ data = null;
+
+ // Gets all values
+ if (key === undefined) {
+ if (this.length) {
+ data = jQuery.data(elem);
+
+ if (elem.nodeType === 1 && !jQuery._data(elem, "parsedAttrs")) {
+ attr = elem.attributes;
+ for (l = attr.length; i < l; i++) {
+ name = attr[i].name;
+
+ if (name.indexOf("data-") === 0) {
+ name = jQuery.camelCase(name.substring(5));
+
+ dataAttr(elem, name, data[ name ]);
+ }
+ }
+ jQuery._data(elem, "parsedAttrs", true);
+ }
+ }
+
+ return data;
+ }
+
+ // Sets multiple values
+ if (typeof key === "object") {
+ return this.each(function () {
+ jQuery.data(this, key);
+ });
+ }
+
+ parts = key.split(".", 2);
+ parts[1] = parts[1] ? "." + parts[1] : "";
+ part = parts[1] + "!";
+
+ return jQuery.access(this, function (value) {
+
+ if (value === undefined) {
+ data = this.triggerHandler("getData" + part, [ parts[0] ]);
+
+ // Try to fetch any internally stored data first
+ if (data === undefined && elem) {
+ data = jQuery.data(elem, key);
+ data = dataAttr(elem, key, data);
+ }
+
+ return data === undefined && parts[1] ?
+ this.data(parts[0]) :
+ data;
+ }
+
+ parts[1] = value;
+ this.each(function () {
+ var self = jQuery(this);
+
+ self.triggerHandler("setData" + part, parts);
+ jQuery.data(this, key, value);
+ self.triggerHandler("changeData" + part, parts);
+ });
+ }, null, value, arguments.length > 1, null, false);
+ },
+
+ removeData: function (key) {
+ return this.each(function () {
+ jQuery.removeData(this, key);
+ });
+ }
+ });
+
+ function dataAttr(elem, key, data) {
+ // If nothing was found internally, try to fetch any
+ // data from the HTML5 data-* attribute
+ if (data === undefined && elem.nodeType === 1) {
+
+ var name = "data-" + key.replace(rmultiDash, "-$1").toLowerCase();
+
+ data = elem.getAttribute(name);
+
+ if (typeof data === "string") {
+ try {
+ data = data === "true" ? true :
+ data === "false" ? false :
+ data === "null" ? null :
+ jQuery.isNumeric(data) ? +data :
+ rbrace.test(data) ? jQuery.parseJSON(data) :
+ data;
+ } catch (e) {
+ }
+
+ // Make sure we set the data so it isn't changed later
+ jQuery.data(elem, key, data);
+
+ } else {
+ data = undefined;
+ }
+ }
+
+ return data;
+ }
+
+// checks a cache object for emptiness
+ function isEmptyDataObject(obj) {
+ for (var name in obj) {
+
+ // if the public data object is empty, the private is still empty
+ if (name === "data" && jQuery.isEmptyObject(obj[name])) {
+ continue;
+ }
+ if (name !== "toJSON") {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+
+ function handleQueueMarkDefer(elem, type, src) {
+ var deferDataKey = type + "defer",
+ queueDataKey = type + "queue",
+ markDataKey = type + "mark",
+ defer = jQuery._data(elem, deferDataKey);
+ if (defer &&
+ ( src === "queue" || !jQuery._data(elem, queueDataKey) ) &&
+ ( src === "mark" || !jQuery._data(elem, markDataKey) )) {
+ // Give room for hard-coded callbacks to fire first
+ // and eventually mark/queue something else on the element
+ setTimeout(function () {
+ if (!jQuery._data(elem, queueDataKey) && !jQuery._data(elem, markDataKey)) {
+ jQuery.removeData(elem, deferDataKey, true);
+ defer.fire();
+ }
+ }, 0);
+ }
+ }
+
+ jQuery.extend({
+
+ _mark: function (elem, type) {
+ if (elem) {
+ type = ( type || "fx" ) + "mark";
+ jQuery._data(elem, type, (jQuery._data(elem, type) || 0) + 1);
+ }
+ },
+
+ _unmark: function (force, elem, type) {
+ if (force !== true) {
+ type = elem;
+ elem = force;
+ force = false;
+ }
+ if (elem) {
+ type = type || "fx";
+ var key = type + "mark",
+ count = force ? 0 : ( (jQuery._data(elem, key) || 1) - 1 );
+ if (count) {
+ jQuery._data(elem, key, count);
+ } else {
+ jQuery.removeData(elem, key, true);
+ handleQueueMarkDefer(elem, type, "mark");
+ }
+ }
+ },
+
+ queue: function (elem, type, data) {
+ var q;
+ if (elem) {
+ type = ( type || "fx" ) + "queue";
+ q = jQuery._data(elem, type);
+
+ // Speed up dequeue by getting out quickly if this is just a lookup
+ if (data) {
+ if (!q || jQuery.isArray(data)) {
+ q = jQuery._data(elem, type, jQuery.makeArray(data));
+ } else {
+ q.push(data);
+ }
+ }
+ return q || [];
+ }
+ },
+
+ dequeue: function (elem, type) {
+ type = type || "fx";
+
+ var queue = jQuery.queue(elem, type),
+ fn = queue.shift(),
+ hooks = {};
+
+ // If the fx queue is dequeued, always remove the progress sentinel
+ if (fn === "inprogress") {
+ fn = queue.shift();
+ }
+
+ if (fn) {
+ // Add a progress sentinel to prevent the fx queue from being
+ // automatically dequeued
+ if (type === "fx") {
+ queue.unshift("inprogress");
+ }
+
+ jQuery._data(elem, type + ".run", hooks);
+ fn.call(elem, function () {
+ jQuery.dequeue(elem, type);
+ }, hooks);
+ }
+
+ if (!queue.length) {
+ jQuery.removeData(elem, type + "queue " + type + ".run", true);
+ handleQueueMarkDefer(elem, type, "queue");
+ }
+ }
+ });
+
+ jQuery.fn.extend({
+ queue: function (type, data) {
+ var setter = 2;
+
+ if (typeof type !== "string") {
+ data = type;
+ type = "fx";
+ setter--;
+ }
+
+ if (arguments.length < setter) {
+ return jQuery.queue(this[0], type);
+ }
+
+ return data === undefined ?
+ this :
+ this.each(function () {
+ var queue = jQuery.queue(this, type, data);
+
+ if (type === "fx" && queue[0] !== "inprogress") {
+ jQuery.dequeue(this, type);
+ }
+ });
+ },
+ dequeue: function (type) {
+ return this.each(function () {
+ jQuery.dequeue(this, type);
+ });
+ },
+ // Based off of the plugin by Clint Helfers, with permission.
+ // http://blindsignals.com/index.php/2009/07/jquery-delay/
+ delay: function (time, type) {
+ time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
+ type = type || "fx";
+
+ return this.queue(type, function (next, hooks) {
+ var timeout = setTimeout(next, time);
+ hooks.stop = function () {
+ clearTimeout(timeout);
+ };
+ });
+ },
+ clearQueue: function (type) {
+ return this.queue(type || "fx", []);
+ },
+ // Get a promise resolved when queues of a certain type
+ // are emptied (fx is the type by default)
+ promise: function (type, object) {
+ if (typeof type !== "string") {
+ object = type;
+ type = undefined;
+ }
+ type = type || "fx";
+ var defer = jQuery.Deferred(),
+ elements = this,
+ i = elements.length,
+ count = 1,
+ deferDataKey = type + "defer",
+ queueDataKey = type + "queue",
+ markDataKey = type + "mark",
+ tmp;
+
+ function resolve() {
+ if (!( --count )) {
+ defer.resolveWith(elements, [ elements ]);
+ }
+ }
+
+ while (i--) {
+ if (( tmp = jQuery.data(elements[ i ], deferDataKey, undefined, true) ||
+ ( jQuery.data(elements[ i ], queueDataKey, undefined, true) ||
+ jQuery.data(elements[ i ], markDataKey, undefined, true) ) &&
+ jQuery.data(elements[ i ], deferDataKey, jQuery.Callbacks("once memory"), true) )) {
+ count++;
+ tmp.add(resolve);
+ }
+ }
+ resolve();
+ return defer.promise(object);
+ }
+ });
+
+
+ var rclass = /[\n\t\r]/g,
+ rspace = /\s+/,
+ rreturn = /\r/g,
+ rtype = /^(?:button|input)$/i,
+ rfocusable = /^(?:button|input|object|select|textarea)$/i,
+ rclickable = /^a(?:rea)?$/i,
+ rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
+ getSetAttribute = jQuery.support.getSetAttribute,
+ nodeHook, boolHook, fixSpecified;
+
+ jQuery.fn.extend({
+ attr: function (name, value) {
+ return jQuery.access(this, jQuery.attr, name, value, arguments.length > 1);
+ },
+
+ removeAttr: function (name) {
+ return this.each(function () {
+ jQuery.removeAttr(this, name);
+ });
+ },
+
+ prop: function (name, value) {
+ return jQuery.access(this, jQuery.prop, name, value, arguments.length > 1);
+ },
+
+ removeProp: function (name) {
+ name = jQuery.propFix[ name ] || name;
+ return this.each(function () {
+ // try/catch handles cases where IE balks (such as removing a property on window)
+ try {
+ this[ name ] = undefined;
+ delete this[ name ];
+ } catch (e) {
+ }
+ });
+ },
+
+ addClass: function (value) {
+ var classNames, i, l, elem,
+ setClass, c, cl;
+
+ if (jQuery.isFunction(value)) {
+ return this.each(function (j) {
+ jQuery(this).addClass(value.call(this, j, this.className));
+ });
+ }
+
+ if (value && typeof value === "string") {
+ classNames = value.split(rspace);
+
+ for (i = 0, l = this.length; i < l; i++) {
+ elem = this[ i ];
+
+ if (elem.nodeType === 1) {
+ if (!elem.className && classNames.length === 1) {
+ elem.className = value;
+
+ } else {
+ setClass = " " + elem.className + " ";
+
+ for (c = 0, cl = classNames.length; c < cl; c++) {
+ if (!~setClass.indexOf(" " + classNames[ c ] + " ")) {
+ setClass += classNames[ c ] + " ";
+ }
+ }
+ elem.className = jQuery.trim(setClass);
+ }
+ }
+ }
+ }
+
+ return this;
+ },
+
+ removeClass: function (value) {
+ var classNames, i, l, elem, className, c, cl;
+
+ if (jQuery.isFunction(value)) {
+ return this.each(function (j) {
+ jQuery(this).removeClass(value.call(this, j, this.className));
+ });
+ }
+
+ if ((value && typeof value === "string") || value === undefined) {
+ classNames = ( value || "" ).split(rspace);
+
+ for (i = 0, l = this.length; i < l; i++) {
+ elem = this[ i ];
+
+ if (elem.nodeType === 1 && elem.className) {
+ if (value) {
+ className = (" " + elem.className + " ").replace(rclass, " ");
+ for (c = 0, cl = classNames.length; c < cl; c++) {
+ className = className.replace(" " + classNames[ c ] + " ", " ");
+ }
+ elem.className = jQuery.trim(className);
+
+ } else {
+ elem.className = "";
+ }
+ }
+ }
+
<TRUNCATED>