/snf-cyclades-app/synnefo/ui/new_ui/ui/javascripts/jquery.js - Diff - Synnefo - Greek Research and Technology Network's projects

Revision d0fe8c12 snf-cyclades-app/synnefo/ui/new_ui/ui/javascripts/jquery.js

     /*!
      * jQuery JavaScript Library v1.9.1
      * http://jquery.com/
+     *
      * Includes Sizzle.js
      * http://sizzlejs.com/
+     *
      * Copyright 2005, 2012 jQuery Foundation, Inc. and other contributors
      * Released under the MIT license
      * http://jquery.org/license
+     *
      * Date: 2013-2-4
      */
     (function( window, undefined ) {
     // Can't do this because several apps including ASP.NET trace
     // the stack via arguments.caller.callee and Firefox dies if
     // you try to trace through "use strict" call chains. (#13335)
     // Support: Firefox 18+
     //"use strict";
     var
       // The deferred used on DOM ready
       readyList,
       // A central reference to the root jQuery(document)
       rootjQuery,
       // Support: IE<9
       // For `typeof node.method` instead of `node.method !== undefined`
       core_strundefined = typeof undefined,
       // Use the correct document accordingly with window argument (sandbox)
       document = window.document,
       location = window.location,
       // Map over jQuery in case of overwrite
       _jQuery = window.jQuery,
       // Map over the $ in case of overwrite
       _$ = window.$,
       // [[Class]] -> type pairs
       class2type = {},
       // List of deleted data cache ids, so we can reuse them
       core_deletedIds = [],
       core_version = "1.9.1",
       // Save a reference to some core methods
       core_concat = core_deletedIds.concat,
       core_push = core_deletedIds.push,
       core_slice = core_deletedIds.slice,
       core_indexOf = core_deletedIds.indexOf,
       core_toString = class2type.toString,
       core_hasOwn = class2type.hasOwnProperty,
       core_trim = core_version.trim,
       // Define a local copy of jQuery
       jQuery = function( selector, context ) {
         // The jQuery object is actually just the init constructor 'enhanced'
         return new jQuery.fn.init( selector, context, rootjQuery );
       },
       // Used for matching numbers
       core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,
       // Used for splitting on whitespace
       core_rnotwhite = /\S+/g,
       // Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
       rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
       // A simple way to check for HTML strings
       // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
       // Strict HTML recognition (#11290: must start with <)
       rquickExpr = /^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/,
       // Match a standalone tag
       rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
       // JSON RegExp
       rvalidchars = /^[\],:{}\s]*$/,
       rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
       rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
       rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g,
       // Matches dashed string for camelizing
       rmsPrefix = /^-ms-/,
       rdashAlpha = /-([\da-z])/gi,
       // Used by jQuery.camelCase as callback to replace()
       fcamelCase = function( all, letter ) {
         return letter.toUpperCase();
       },
       // The ready event handler
       completed = function( event ) {
         // readyState === "complete" is good enough for us to call the dom ready in oldIE
         if ( document.addEventListener || event.type === "load" || document.readyState === "complete" ) {
           detach();
           jQuery.ready();
+        }
       },
       // Clean-up method for dom ready events
       detach = function() {
         if ( document.addEventListener ) {
           document.removeEventListener( "DOMContentLoaded", completed, false );
           window.removeEventListener( "load", completed, false );
         } else {
           document.detachEvent( "onreadystatechange", completed );
           window.detachEvent( "onload", completed );
+        }
       };
     jQuery.fn = jQuery.prototype = {
       // The current version of jQuery being used
       jquery: core_version,
       constructor: jQuery,
       init: function( selector, context, rootjQuery ) {
         var match, elem;
         // HANDLE: $(""), $(null), $(undefined), $(false)
         if ( !selector ) {
           return this;
+        }
         // Handle HTML strings
         if ( typeof selector === "string" ) {
           if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
             // Assume that strings that start and end with <> are HTML and skip the regex check
             match = [ null, selector, null ];
           } else {
             match = rquickExpr.exec( selector );
+          }
           // Match html or make sure no context is specified for #id
           if ( match && (match[1] || !context) ) {
             // HANDLE: $(html) -> $(array)
             if ( match[1] ) {
               context = context instanceof jQuery ? context[0] : context;
               // scripts is true for back-compat
               jQuery.merge( this, jQuery.parseHTML(
                 match[1],
                 context && context.nodeType ? context.ownerDocument || context : document,
                 true
               ) );
               // HANDLE: $(html, props)
               if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
                 for ( match in context ) {
                   // Properties of context are called as methods if possible
                   if ( jQuery.isFunction( this[ match ] ) ) {
                     this[ match ]( context[ match ] );
                   // ...and otherwise set as attributes
                   } else {
                     this.attr( match, context[ match ] );
+                  }
+                }
+              }
               return this;
             // HANDLE: $(#id)
             } else {
               elem = document.getElementById( match[2] );
               // Check parentNode to catch when Blackberry 4.6 returns
               // nodes that are no longer in the document #6963
               if ( elem && elem.parentNode ) {
                 // Handle the case where IE and Opera return items
                 // by name instead of ID
                 if ( elem.id !== match[2] ) {
                   return rootjQuery.find( selector );
+                }
                 // Otherwise, we inject the element directly into the jQuery object
                 this.length = 1;
                 this[0] = elem;
+              }
               this.context = document;
               this.selector = selector;
               return this;
+            }
           // HANDLE: $(expr, $(...))
           } else if ( !context || context.jquery ) {
             return ( context || rootjQuery ).find( selector );
           // HANDLE: $(expr, context)
           // (which is just equivalent to: $(context).find(expr)
           } else {
             return this.constructor( context ).find( selector );
+          }
         // HANDLE: $(DOMElement)
         } else if ( selector.nodeType ) {
           this.context = this[0] = selector;
           this.length = 1;
           return this;
         // HANDLE: $(function)
         // Shortcut for document ready
         } else if ( jQuery.isFunction( selector ) ) {
           return rootjQuery.ready( selector );
+        }
         if ( selector.selector !== undefined ) {
           this.selector = selector.selector;
           this.context = selector.context;
+        }
         return jQuery.makeArray( selector, this );
       },
       // Start with an empty selector
       selector: "",
       // The default length of a jQuery object is 0
       length: 0,
       // The number of elements contained in the matched element set
       size: function() {
         return this.length;
       },
       toArray: function() {
         return core_slice.call( this );
       },
       // Get the Nth element in the matched element set OR
       // Get the whole matched element set as a clean array
       get: function( num ) {
         return num == null ?
           // Return a 'clean' array
           this.toArray() :
           // Return just the object
           ( num < 0 ? this[ this.length + num ] : this[ num ] );
       },
       // Take an array of elements and push it onto the stack
       // (returning the new matched element set)
       pushStack: function( elems ) {
         // Build a new jQuery matched element set
         var ret = jQuery.merge( this.constructor(), elems );
         // Add the old object onto the stack (as a reference)
         ret.prevObject = this;
         ret.context = this.context;
         // Return the newly-formed element set
         return ret;
       },
       // Execute a callback for every element in the matched set.
       // (You can seed the arguments with an array of args, but this is
       // only used internally.)
       each: function( callback, args ) {
         return jQuery.each( this, callback, args );
       },
       ready: function( fn ) {
         // Add the callback
         jQuery.ready.promise().done( fn );
         return this;
       },
       slice: function() {
         return this.pushStack( core_slice.apply( this, arguments ) );
       },
       first: function() {
         return this.eq( 0 );
       },
       last: function() {
         return this.eq( -1 );
       },
       eq: function( i ) {
         var len = this.length,
           j = +i + ( i < 0 ? len : 0 );
         return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
       },
       map: function( callback ) {
         return this.pushStack( jQuery.map(this, function( elem, i ) {
           return callback.call( elem, i, elem );
         }));
       },
       end: function() {
         return this.prevObject || this.constructor(null);
       },
       // For internal use only.
       // Behaves like an Array's method, not like a jQuery method.
       push: core_push,
       sort: [].sort,
       splice: [].splice
     };
     // Give the init function the jQuery prototype for later instantiation
     jQuery.fn.init.prototype = jQuery.fn;
     jQuery.extend = jQuery.fn.extend = function() {
       var src, copyIsArray, copy, name, options, clone,
         target = arguments[0] || {},
         i = 1,
         length = arguments.length,
         deep = false;
       // Handle a deep copy situation
       if ( typeof target === "boolean" ) {
         deep = target;
         target = arguments[1] || {};
         // skip the boolean and the target
         i = 2;
+      }
       // Handle case when target is a string or something (possible in deep copy)
       if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
         target = {};
+      }
       // extend jQuery itself if only one argument is passed
       if ( length === i ) {
         target = this;
         --i;
+      }
       for ( ; i < length; i++ ) {
         // Only deal with non-null/undefined values
         if ( (options = arguments[ i ]) != null ) {
           // Extend the base object
           for ( name in options ) {
             src = target[ name ];
             copy = options[ name ];
             // Prevent never-ending loop
             if ( target === copy ) {
               continue;
+            }
             // Recurse if we're merging plain objects or arrays
             if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
               if ( copyIsArray ) {
                 copyIsArray = false;
                 clone = src && jQuery.isArray(src) ? src : [];
               } else {
                 clone = src && jQuery.isPlainObject(src) ? src : {};
+              }
               // Never move original objects, clone them
               target[ name ] = jQuery.extend( deep, clone, copy );
             // Don't bring in undefined values
             } else if ( copy !== undefined ) {
               target[ name ] = copy;
+            }
+          }
+        }
+      }
       // Return the modified object
       return target;
     };
     jQuery.extend({
       noConflict: function( deep ) {
         if ( window.$ === jQuery ) {
           window.$ = _$;
+        }
         if ( deep && window.jQuery === jQuery ) {
           window.jQuery = _jQuery;
+        }
         return jQuery;
       },
       // Is the DOM ready to be used? Set to true once it occurs.
       isReady: false,
       // A counter to track how many items to wait for before
       // the ready event fires. See #6781
       readyWait: 1,
       // Hold (or release) the ready event
       holdReady: function( hold ) {
         if ( hold ) {
           jQuery.readyWait++;
         } else {
           jQuery.ready( true );
+        }
       },
       // Handle when the DOM is ready
       ready: function( wait ) {
         // Abort if there are pending holds or we're already ready
         if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
           return;
+        }
         // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
         if ( !document.body ) {
           return setTimeout( jQuery.ready );
+        }
         // Remember that the DOM is ready
         jQuery.isReady = true;
         // If a normal DOM Ready event fired, decrement, and wait if need be
         if ( wait !== true && --jQuery.readyWait > 0 ) {
           return;
+        }
         // If there are functions bound, to execute
         readyList.resolveWith( document, [ jQuery ] );
         // Trigger any bound ready events
         if ( jQuery.fn.trigger ) {
           jQuery( document ).trigger("ready").off("ready");
+        }
       },
       // See test/unit/core.js for details concerning isFunction.
       // Since version 1.3, DOM methods and functions like alert
       // aren't supported. They return false on IE (#2968).
       isFunction: function( obj ) {
         return jQuery.type(obj) === "function";
       },
       isArray: Array.isArray || function( obj ) {
         return jQuery.type(obj) === "array";
       },
       isWindow: function( obj ) {
         return obj != null && obj == obj.window;
       },
       isNumeric: function( obj ) {
         return !isNaN( parseFloat(obj) ) && isFinite( obj );
       },
       type: function( obj ) {
         if ( obj == null ) {
           return String( obj );
+        }
         return typeof obj === "object" || typeof obj === "function" ?
           class2type[ core_toString.call(obj) ] || "object" :
           typeof obj;
       },
       isPlainObject: function( obj ) {
         // Must be an Object.
         // Because of IE, we also have to check the presence of the constructor property.
         // Make sure that DOM nodes and window objects don't pass through, as well
         if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
           return false;
+        }
         try {
           // Not own constructor property must be Object
           if ( obj.constructor &&
             !core_hasOwn.call(obj, "constructor") &&
             !core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
             return false;
+          }
         } catch ( e ) {
           // IE8,9 Will throw exceptions on certain host objects #9897
           return false;
+        }
         // 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 || core_hasOwn.call( obj, key );
       },
       isEmptyObject: function( obj ) {
         var name;
         for ( name in obj ) {
           return false;
+        }
         return true;
       },
       error: function( msg ) {
         throw new Error( msg );
       },
       // data: string of html
       // context (optional): If specified, the fragment will be created in this context, defaults to document
       // keepScripts (optional): If true, will include scripts passed in the html string
       parseHTML: function( data, context, keepScripts ) {
         if ( !data || typeof data !== "string" ) {
           return null;
+        }
         if ( typeof context === "boolean" ) {
           keepScripts = context;
           context = false;
+        }
         context = context || document;
         var parsed = rsingleTag.exec( data ),
           scripts = !keepScripts && [];
         // Single tag
         if ( parsed ) {
           return [ context.createElement( parsed[1] ) ];
+        }
         parsed = jQuery.buildFragment( [ data ], context, scripts );
         if ( scripts ) {
           jQuery( scripts ).remove();
+        }
         return jQuery.merge( [], parsed.childNodes );
       },
       parseJSON: function( data ) {
         // Attempt to parse using the native JSON parser first
         if ( window.JSON && window.JSON.parse ) {
           return window.JSON.parse( data );
+        }
         if ( data === null ) {
           return data;
+        }
         if ( typeof data === "string" ) {
           // Make sure leading/trailing whitespace is removed (IE can't handle it)
           data = jQuery.trim( data );
           if ( data ) {
             // Make sure the incoming data is actual JSON
             // Logic borrowed from http://json.org/json2.js
             if ( rvalidchars.test( data.replace( rvalidescape, "@" )
               .replace( rvalidtokens, "]" )
               .replace( rvalidbraces, "")) ) {
               return ( new Function( "return " + data ) )();
+            }
+          }
+        }
         jQuery.error( "Invalid JSON: " + data );
       },
       // Cross-browser xml parsing
       parseXML: function( data ) {
         var xml, tmp;
         if ( !data || typeof data !== "string" ) {
           return null;
+        }
         try {
           if ( window.DOMParser ) { // Standard
             tmp = new DOMParser();
             xml = tmp.parseFromString( data , "text/xml" );
           } else { // IE
             xml = new ActiveXObject( "Microsoft.XMLDOM" );
             xml.async = "false";
             xml.loadXML( data );
+          }
         } catch( e ) {
           xml = undefined;
+        }
         if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
           jQuery.error( "Invalid XML: " + data );
+        }
         return xml;
       },
       noop: function() {},
       // Evaluates a script in a global context
       // Workarounds based on findings by Jim Driscoll
       // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
       globalEval: function( data ) {
         if ( data && jQuery.trim( data ) ) {
           // We use execScript on Internet Explorer
           // We use an anonymous function so that context is window
           // rather than jQuery in Firefox
           ( window.execScript || function( data ) {
             window[ "eval" ].call( window, data );
           } )( data );
+        }
       },
       // Convert dashed to camelCase; used by the css and data modules
       // Microsoft forgot to hump their vendor prefix (#9572)
       camelCase: function( string ) {
         return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
       },
       nodeName: function( elem, name ) {
         return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
       },
       // args is for internal usage only
       each: function( obj, callback, args ) {
         var value,
           i = 0,
           length = obj.length,
           isArray = isArraylike( obj );
         if ( args ) {
           if ( isArray ) {
             for ( ; i < length; i++ ) {
               value = callback.apply( obj[ i ], args );
               if ( value === false ) {
                 break;
+              }
+            }
           } else {
             for ( i in obj ) {
               value = callback.apply( obj[ i ], args );
               if ( value === false ) {
                 break;
+              }
+            }
+          }
         // A special, fast, case for the most common use of each
         } else {
           if ( isArray ) {
             for ( ; i < length; i++ ) {
               value = callback.call( obj[ i ], i, obj[ i ] );
               if ( value === false ) {
                 break;
+              }
+            }
           } else {
             for ( i in obj ) {
               value = callback.call( obj[ i ], i, obj[ i ] );
               if ( value === false ) {
                 break;
+              }
+            }
+          }
+        }
         return obj;
       },
       // Use native String.trim function wherever possible
       trim: core_trim && !core_trim.call("\uFEFF\xA0") ?
         function( text ) {
           return text == null ?
             "" :
             core_trim.call( text );
         } :
         // Otherwise use our own trimming functionality
         function( text ) {
           return text == null ?
             "" :
             ( text + "" ).replace( rtrim, "" );
         },
       // results is for internal usage only
       makeArray: function( arr, results ) {
         var ret = results || [];
         if ( arr != null ) {
           if ( isArraylike( Object(arr) ) ) {
             jQuery.merge( ret,
               typeof arr === "string" ?
               [ arr ] : arr
             );
           } else {
             core_push.call( ret, arr );
+          }
+        }
         return ret;
       },
       inArray: function( elem, arr, i ) {
         var len;
         if ( arr ) {
           if ( core_indexOf ) {
             return core_indexOf.call( arr, elem, i );
+          }
           len = arr.length;
           i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
           for ( ; i < len; i++ ) {
             // Skip accessing in sparse arrays
             if ( i in arr && arr[ i ] === elem ) {
               return i;
+            }
+          }
+        }
         return -1;
       },
       merge: function( first, second ) {
         var l = second.length,
           i = first.length,
           j = 0;
         if ( typeof l === "number" ) {
           for ( ; j < l; j++ ) {
             first[ i++ ] = second[ j ];
+          }
         } else {
           while ( second[j] !== undefined ) {
             first[ i++ ] = second[ j++ ];
+          }
+        }
         first.length = i;
         return first;
       },
       grep: function( elems, callback, inv ) {
         var retVal,
           ret = [],
           i = 0,
           length = elems.length;
         inv = !!inv;
         // Go through the array, only saving the items
         // that pass the validator function
         for ( ; i < length; i++ ) {
           retVal = !!callback( elems[ i ], i );
           if ( inv !== retVal ) {
             ret.push( elems[ i ] );
+          }
+        }
         return ret;
       },
       // arg is for internal usage only
       map: function( elems, callback, arg ) {
         var value,
           i = 0,
           length = elems.length,
           isArray = isArraylike( elems ),
           ret = [];
         // Go through the array, translating each of the items to their
         if ( isArray ) {
           for ( ; i < length; i++ ) {
             value = callback( elems[ i ], i, arg );
             if ( value != null ) {
               ret[ ret.length ] = value;
+            }
+          }
         // Go through every key on the object,
         } else {
           for ( i in elems ) {
             value = callback( elems[ i ], i, arg );
             if ( value != null ) {
               ret[ ret.length ] = value;
+            }
+          }
+        }
         // Flatten any nested arrays
         return core_concat.apply( [], ret );
       },
       // A global GUID counter for objects
       guid: 1,
       // Bind a function to a context, optionally partially applying any
       // arguments.
       proxy: function( fn, context ) {
         var args, proxy, tmp;
         if ( typeof context === "string" ) {
           tmp = fn[ context ];
           context = fn;
           fn = tmp;
+        }
         // Quick check to determine if target is callable, in the spec
         // this throws a TypeError, but we will just return undefined.
         if ( !jQuery.isFunction( fn ) ) {
           return undefined;
+        }
         // Simulated bind
         args = core_slice.call( arguments, 2 );
         proxy = function() {
           return fn.apply( context || this, args.concat( core_slice.call( arguments ) ) );
         };
         // Set the guid of unique handler to the same of original handler, so it can be removed
         proxy.guid = fn.guid = fn.guid || jQuery.guid++;
         return proxy;
       },
       // Multifunctional method to get and set values of a collection
       // The value/s can optionally be executed if it's a function
       access: function( elems, fn, key, value, chainable, emptyGet, raw ) {
         var i = 0,
           length = elems.length,
           bulk = key == null;
         // Sets many values
         if ( jQuery.type( key ) === "object" ) {
           chainable = true;
           for ( i in key ) {
             jQuery.access( elems, fn, i, key[i], true, emptyGet, raw );
+          }
         // Sets one value
         } else if ( value !== undefined ) {
           chainable = true;
           if ( !jQuery.isFunction( value ) ) {
             raw = true;
+          }
           if ( bulk ) {
             // Bulk operations run against the entire set
             if ( raw ) {
               fn.call( elems, value );
               fn = null;
             // ...except when executing function values
             } else {
               bulk = fn;
               fn = function( elem, key, value ) {
                 return bulk.call( jQuery( elem ), value );
               };
+            }
+          }
           if ( fn ) {
             for ( ; i < length; i++ ) {
               fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );
+            }
+          }
+        }
         return chainable ?
           elems :
           // Gets
           bulk ?
             fn.call( elems ) :
             length ? fn( elems[0], key ) : emptyGet;
       },
       now: function() {
         return ( new Date() ).getTime();
+      }
     });
     jQuery.ready.promise = function( obj ) {
       if ( !readyList ) {
         readyList = jQuery.Deferred();
         // Catch cases where $(document).ready() is called after the browser event has already occurred.
         // we once tried to use readyState "interactive" here, but it caused issues like the one
         // discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
         if ( document.readyState === "complete" ) {
           // Handle it asynchronously to allow scripts the opportunity to delay ready
           setTimeout( jQuery.ready );
         // Standards-based browsers support DOMContentLoaded
         } else if ( document.addEventListener ) {
           // Use the handy event callback
           document.addEventListener( "DOMContentLoaded", completed, false );
           // A fallback to window.onload, that will always work
           window.addEventListener( "load", completed, false );
         // If IE event model is used
         } else {
           // Ensure firing before onload, maybe late but safe also for iframes
           document.attachEvent( "onreadystatechange", completed );
           // A fallback to window.onload, that will always work
           window.attachEvent( "onload", completed );
           // If IE and not a frame
           // continually check to see if the document is ready
           var top = false;
           try {
             top = window.frameElement == null && document.documentElement;
           } catch(e) {}
           if ( top && top.doScroll ) {
             (function doScrollCheck() {
               if ( !jQuery.isReady ) {
                 try {
                   // Use the trick by Diego Perini
                   // http://javascript.nwbox.com/IEContentLoaded/
                   top.doScroll("left");
                 } catch(e) {
                   return setTimeout( doScrollCheck, 50 );
+                }
                 // detach all dom ready events
                 detach();
                 // and execute any waiting functions
                 jQuery.ready();
+              }
             })();
+          }
+        }
+      }
       return readyList.promise( obj );
     };
     // Populate the class2type map
     jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
       class2type[ "[object " + name + "]" ] = name.toLowerCase();
     });
     function isArraylike( obj ) {
       var length = obj.length,
         type = jQuery.type( obj );
       if ( jQuery.isWindow( obj ) ) {
         return false;
+      }
       if ( obj.nodeType === 1 && length ) {
         return true;
+      }
       return type === "array" || type !== "function" &&
         ( length === 0 ||
         typeof length === "number" && length > 0 && ( length - 1 ) in obj );
+    }
     // All jQuery objects should point back to these
     rootjQuery = jQuery(document);
     // String to Object options format cache
     var optionsCache = {};
     // Convert String-formatted options into Object-formatted ones and store in cache
     function createOptions( options ) {
       var object = optionsCache[ options ] = {};
       jQuery.each( options.match( core_rnotwhite ) || [], function( _, flag ) {
         object[ flag ] = true;
       });
       return object;
+    }
     /*
      * Create a callback list using the following parameters:
+     *
      *  options: an optional list of space-separated options that will change how
      *      the callback list behaves or a more traditional option object
+     *
      * By default a callback list will act like an event callback list and can be
      * "fired" multiple times.
+     *
      * Possible options:
+     *
      *  once:     will ensure the callback list can only be fired once (like a Deferred)
+     *
      *  memory:     will keep track of previous values and will call any callback added
      *          after the list has been fired right away with the latest "memorized"
      *          values (like a Deferred)
+     *
      *  unique:     will ensure a callback can only be added once (no duplicate in the list)
+     *
      *  stopOnFalse:  interrupt callings when a callback returns false
+     *
      */
     jQuery.Callbacks = function( options ) {
       // Convert options from String-formatted to Object-formatted if needed
       // (we check in cache first)
       options = typeof options === "string" ?
         ( optionsCache[ options ] || createOptions( options ) ) :
         jQuery.extend( {}, options );
       var // Flag to know if list is currently firing
         firing,
         // Last fire value (for non-forgettable lists)
         memory,
         // Flag to know if list was already fired
         fired,
         // End of the loop when firing
         firingLength,
         // Index of currently firing callback (modified by remove if needed)
         firingIndex,
         // First callback to fire (used internally by add and fireWith)
         firingStart,
         // Actual callback list
         list = [],
         // Stack of fire calls for repeatable lists
         stack = !options.once && [],
         // Fire callbacks
         fire = function( data ) {
           memory = options.memory && data;
           fired = true;
           firingIndex = firingStart || 0;
           firingStart = 0;
           firingLength = list.length;
           firing = true;
           for ( ; list && firingIndex < firingLength; firingIndex++ ) {
             if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
               memory = false; // To prevent further calls using add
               break;
+            }
+          }
           firing = false;
           if ( list ) {
             if ( stack ) {
               if ( stack.length ) {
                 fire( stack.shift() );
+              }
             } else if ( memory ) {
               list = [];
             } else {
               self.disable();
+            }
+          }
         },
         // Actual Callbacks object
         self = {
           // Add a callback or a collection of callbacks to the list
           add: function() {
             if ( list ) {
               // First, we save the current length
               var start = list.length;
               (function add( args ) {
                 jQuery.each( args, function( _, arg ) {
                   var type = jQuery.type( arg );
                   if ( type === "function" ) {
                     if ( !options.unique || !self.has( arg ) ) {
                       list.push( arg );
+                    }
                   } else if ( arg && arg.length && type !== "string" ) {
                     // Inspect recursively
                     add( arg );
+                  }
                 });
               })( arguments );
               // Do we need to add the callbacks to the
               // current firing batch?
               if ( firing ) {
                 firingLength = list.length;
               // With memory, if we're not firing then
               // we should call right away
               } else if ( memory ) {
                 firingStart = start;
                 fire( memory );
+              }
+            }
             return this;
           },
           // Remove a callback from the list
           remove: function() {
             if ( list ) {
               jQuery.each( arguments, function( _, arg ) {
                 var index;
                 while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
                   list.splice( index, 1 );
                   // Handle firing indexes
                   if ( firing ) {
                     if ( index <= firingLength ) {
                       firingLength--;
+                    }
                     if ( index <= firingIndex ) {
                       firingIndex--;
+                    }
+                  }
+                }
               });
+            }
             return this;
           },
           // Check if a given callback is in the list.
           // If no argument is given, return whether or not list has callbacks attached.
           has: function( fn ) {
             return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );
           },
           // Remove all callbacks from the list
           empty: function() {
             list = [];
             return this;
           },
           // Have the list do nothing anymore
           disable: function() {
             list = stack = memory = undefined;
             return this;
           },
           // Is it disabled?
           disabled: function() {
             return !list;
           },
           // Lock the list in its current state
           lock: function() {
             stack = undefined;
             if ( !memory ) {
               self.disable();
+            }
             return this;
           },
           // Is it locked?
           locked: function() {
             return !stack;
           },
           // Call all callbacks with the given context and arguments
           fireWith: function( context, args ) {
             args = args || [];
             args = [ context, args.slice ? args.slice() : args ];
             if ( list && ( !fired || stack ) ) {
               if ( firing ) {
                 stack.push( args );
               } else {
                 fire( args );
+              }
+            }
             return this;
           },
           // Call all the callbacks with the given arguments
           fire: function() {
             self.fireWith( this, arguments );
             return this;
           },
           // To know if the callbacks have already been called at least once
           fired: function() {
             return !!fired;
+          }
         };
       return self;
     };
     jQuery.extend({
       Deferred: function( func ) {
         var tuples = [
             // action, add listener, listener list, final state
             [ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
             [ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
             [ "notify", "progress", jQuery.Callbacks("memory") ]
           ],
           state = "pending",
           promise = {
             state: function() {
               return state;
             },
             always: function() {
               deferred.done( arguments ).fail( arguments );
               return this;
             },
             then: function( /* fnDone, fnFail, fnProgress */ ) {
               var fns = arguments;
               return jQuery.Deferred(function( newDefer ) {
                 jQuery.each( tuples, function( i, tuple ) {
                   var action = tuple[ 0 ],
                     fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
                   // deferred[ done | fail | progress ] for forwarding actions to newDefer
                   deferred[ tuple[1] ](function() {
                     var returned = fn && fn.apply( this, arguments );
                     if ( returned && jQuery.isFunction( returned.promise ) ) {
                       returned.promise()
                         .done( newDefer.resolve )
                         .fail( newDefer.reject )
                         .progress( newDefer.notify );
                     } else {
                       newDefer[ action + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
+                    }
                   });
                 });
                 fns = null;
               }).promise();
             },
             // Get a promise for this deferred
             // If obj is provided, the promise aspect is added to the object
             promise: function( obj ) {
               return obj != null ? jQuery.extend( obj, promise ) : promise;
+            }
           },
           deferred = {};
         // Keep pipe for back-compat
         promise.pipe = promise.then;
         // Add list-specific methods
         jQuery.each( tuples, function( i, tuple ) {
           var list = tuple[ 2 ],
             stateString = tuple[ 3 ];
           // promise[ done | fail | progress ] = list.add
           promise[ tuple[1] ] = list.add;
           // Handle state
           if ( stateString ) {
             list.add(function() {
               // state = [ resolved | rejected ]
               state = stateString;
             // [ reject_list | resolve_list ].disable; progress_list.lock
             }, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
+          }
           // deferred[ resolve | reject | notify ]
           deferred[ tuple[0] ] = function() {
             deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
             return this;
           };
           deferred[ tuple[0] + "With" ] = list.fireWith;
         });
         // Make the deferred a promise
         promise.promise( deferred );
         // Call given func if any
         if ( func ) {
           func.call( deferred, deferred );
+        }
         // All done!
         return deferred;
       },
       // Deferred helper
       when: function( subordinate /* , ..., subordinateN */ ) {
         var i = 0,
           resolveValues = core_slice.call( arguments ),
           length = resolveValues.length,
           // the count of uncompleted subordinates
           remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
           // the master Deferred. If resolveValues consist of only a single Deferred, just use that.
           deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
           // Update function for both resolve and progress values
           updateFunc = function( i, contexts, values ) {
             return function( value ) {
               contexts[ i ] = this;
               values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;
               if( values === progressValues ) {
                 deferred.notifyWith( contexts, values );
               } else if ( !( --remaining ) ) {
                 deferred.resolveWith( contexts, values );
+              }
             };
           },
           progressValues, progressContexts, resolveContexts;
         // add listeners to Deferred subordinates; treat others as resolved
         if ( length > 1 ) {
           progressValues = new Array( length );
           progressContexts = new Array( length );
           resolveContexts = new Array( length );
           for ( ; i < length; i++ ) {
             if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
               resolveValues[ i ].promise()
                 .done( updateFunc( i, resolveContexts, resolveValues ) )
                 .fail( deferred.reject )
                 .progress( updateFunc( i, progressContexts, progressValues ) );
             } else {
               --remaining;
+            }
+          }
+        }
         // if we're not waiting on anything, resolve the master
         if ( !remaining ) {
           deferred.resolveWith( resolveContexts, resolveValues );
+        }
         return deferred.promise();
+      }
     });
     jQuery.support = (function() {
       var support, all, a,
         input, select, fragment,
         opt, eventName, isSupported, i,
         div = document.createElement("div");
       // Setup
       div.setAttribute( "className", "t" );
       div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
       // Support tests won't run in some limited or non-browser environments
       all = div.getElementsByTagName("*");
       a = div.getElementsByTagName("a")[ 0 ];
       if ( !all || !a || !all.length ) {
         return {};
+      }
       // First batch of tests
       select = document.createElement("select");
       opt = select.appendChild( document.createElement("option") );
       input = div.getElementsByTagName("input")[ 0 ];
       a.style.cssText = "top:1px;float:left;opacity:.5";
       support = {
         // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
         getSetAttribute: div.className !== "t",
         // 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.5/.test( a.style.opacity ),
         // Verify style float existence
         // (IE uses styleFloat instead of cssFloat)
         cssFloat: !!a.style.cssFloat,
         // Check the default checkbox/radio value ("" on WebKit; "on" elsewhere)
         checkOn: !!input.value,
         // Make sure that a selected-by-default option has a working selected property.
         // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
         optSelected: opt.selected,
         // 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>",
         // jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode
         boxModel: document.compatMode === "CSS1Compat",
         // Will be defined later
         deleteExpando: true,
         noCloneEvent: true,
         inlineBlockNeedsLayout: false,
         shrinkWrapBlocks: false,
         reliableMarginRight: true,
         boxSizingReliable: true,
         pixelPosition: false
       };
       // Make sure checked status is properly cloned
       input.checked = true;
       support.noCloneChecked = input.cloneNode( true ).checked;
       // Make sure that the options inside disabled selects aren't marked as disabled
       // (WebKit marks them as disabled)
       select.disabled = true;
       support.optDisabled = !opt.disabled;
       // Support: IE<9
       try {
         delete div.test;
       } catch( e ) {
         support.deleteExpando = false;
+      }
       // Check if we can trust getAttribute("value")
       input = document.createElement("input");
       input.setAttribute( "value", "" );
       support.input = input.getAttribute( "value" ) === "";
       // Check if an input maintains its value after becoming a radio
       input.value = "t";
       input.setAttribute( "type", "radio" );
       support.radioValue = input.value === "t";
       // #11217 - WebKit loses check when the name is after the checked attribute
       input.setAttribute( "checked", "t" );
       input.setAttribute( "name", "t" );
       fragment = document.createDocumentFragment();
       fragment.appendChild( input );
       // Check if a disconnected checkbox will retain its checked
       // value of true after appended to the DOM (IE6/7)
       support.appendChecked = input.checked;
       // WebKit doesn't clone checked state correctly in fragments
       support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
       // Support: IE<9
       // Opera does not clone events (and typeof div.attachEvent === undefined).
       // IE9-10 clones events bound via attachEvent, but they don't trigger with .click()
       if ( div.attachEvent ) {
         div.attachEvent( "onclick", function() {
           support.noCloneEvent = false;
         });
         div.cloneNode( true ).click();
+      }
       // Support: IE<9 (lack submit/change bubble), Firefox 17+ (lack focusin event)
       // Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP), test/csp.php
       for ( i in { submit: true, change: true, focusin: true }) {
         div.setAttribute( eventName = "on" + i, "t" );
         support[ i + "Bubbles" ] = eventName in window || div.attributes[ eventName ].expando === false;
+      }
       div.style.backgroundClip = "content-box";
       div.cloneNode( true ).style.backgroundClip = "";
       support.clearCloneStyle = div.style.backgroundClip === "content-box";
       // Run tests that need a body at doc ready
       jQuery(function() {
         var container, marginDiv, tds,
           divReset = "padding:0;margin:0;border:0;display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;",
           body = document.getElementsByTagName("body")[0];
         if ( !body ) {
           // Return for frameset docs that don't have a body
           return;
+        }
         container = document.createElement("div");
         container.style.cssText = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px";
         body.appendChild( container ).appendChild( div );
         // Support: IE8
         // Check if table cells still have offsetWidth/Height when they are set
         // to display:none and there are still other visible table cells in a
         // table row; if so, offsetWidth/Height are not reliable for use when
         // determining if an element has been hidden directly using
         // display:none (it is still safe to use offsets if a parent element is
         // hidden; don safety goggles and see bug #4512 for more information).
         div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
         tds = div.getElementsByTagName("td");
         tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none";
         isSupported = ( tds[ 0 ].offsetHeight === 0 );
         tds[ 0 ].style.display = "";
         tds[ 1 ].style.display = "none";
         // Support: IE8
         // Check if empty table cells still have offsetWidth/Height
         support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
         // Check box-sizing and margin behavior
         div.innerHTML = "";

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff