ambari-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nc...@apache.org
Subject [08/50] [abbrv] ambari git commit: AMBARI-18573. Migration to Bootstrap3 framework (akovalenko)
Date Wed, 19 Oct 2016 16:47:19 GMT
http://git-wip-us.apache.org/repos/asf/ambari/blob/2a77e39c/ambari-web/vendor/scripts/jquery-1.9.1.js
----------------------------------------------------------------------
diff --git a/ambari-web/vendor/scripts/jquery-1.9.1.js b/ambari-web/vendor/scripts/jquery-1.9.1.js
new file mode 100644
index 0000000..bed4ee0
--- /dev/null
+++ b/ambari-web/vendor/scripts/jquery-1.9.1.js
@@ -0,0 +1,9597 @@
+/*!
+ * 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 = "";
+      div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;";
+      support.boxSizing = ( div.offsetWidth === 4 );
+      support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 );
+
+      // Use window.getComputedStyle because jsdom on node.js will break without it.
+      if ( window.getComputedStyle ) {
+        support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%";
+        support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px";
+
+        // Check if div with explicit width and no margin-right incorrectly
+        // gets computed margin-right based on width of container. (#3333)
+        // Fails in WebKit before Feb 2011 nightlies
+        // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
+        marginDiv = div.appendChild( document.createElement("div") );
+        marginDiv.style.cssText = div.style.cssText = divReset;
+        marginDiv.style.marginRight = marginDiv.style.width = "0";
+        div.style.width = "1px";
+
+        support.reliableMarginRight =
+          !parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight );
+      }
+
+      if ( typeof div.style.zoom !== core_strundefined ) {
+        // Support: IE<8
+        // Check if natively block-level elements act like inline-block
+        // elements when setting their display to 'inline' and giving
+        // them layout
+        div.innerHTML = "";
+        div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1";
+        support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
+
+        // Support: IE6
+        // Check if elements with layout shrink-wrap their children
+        div.style.display = "block";
+        div.innerHTML = "<div></div>";
+        div.firstChild.style.width = "5px";
+        support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
+
+        if ( support.inlineBlockNeedsLayout ) {
+          // Prevent IE 6 from affecting layout for positioned elements #11048
+          // Prevent IE from shrinking the body in IE 7 mode #12869
+          // Support: IE<8
+          body.style.zoom = 1;
+        }
+      }
+
+      body.removeChild( container );
+
+      // Null elements to avoid leaks in IE
+      container = div = tds = marginDiv = null;
+    });
+
+    // Null elements to avoid leaks in IE
+    all = select = fragment = opt = a = input = null;
+
+    return support;
+  })();
+
+  var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
+    rmultiDash = /([A-Z])/g;
+
+  function internalData( elem, name, data, pvt /* Internal Use Only */ ){
+    if ( !jQuery.acceptData( elem ) ) {
+      return;
+    }
+
+    var 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;
+
+    // Avoid doing any more work than we need to when trying to get data on an
+    // object that has no data at all
+    if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && 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 = core_deletedIds.pop() || jQuery.guid++;
+      } 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 );
+      }
+    }
+
+    thisCache = cache[ id ];
+
+    // jQuery data() is stored in a separate object inside the object's internal data
+    // cache in order to avoid key collisions between internal data and user-defined
+    // data.
+    if ( !pvt ) {
+      if ( !thisCache.data ) {
+        thisCache.data = {};
+      }
+
+      thisCache = thisCache.data;
+    }
+
+    if ( data !== undefined ) {
+      thisCache[ jQuery.camelCase( name ) ] = data;
+    }
+
+    // Check for both converted-to-camel and non-converted data property names
+    // If a data property was specified
+    if ( 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;
+  }
+
+  function internalRemoveData( elem, name, pvt ) {
+    if ( !jQuery.acceptData( elem ) ) {
+      return;
+    }
+
+    var i, l, thisCache,
+      isNode = elem.nodeType,
+
+    // See jQuery.data for more information
+      cache = isNode ? jQuery.cache : elem,
+      id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
+
+    // If there is already no cache entry for this object, there is no
+    // purpose in continuing
+    if ( !cache[ id ] ) {
+      return;
+    }
+
+    if ( name ) {
+
+      thisCache = pvt ? cache[ id ] : cache[ id ].data;
+
+      if ( thisCache ) {
+
+        // Support array or space separated string names for data keys
+        if ( !jQuery.isArray( name ) ) {
+
+          // try the string as a key before any manipulation
+          if ( name in thisCache ) {
+            name = [ name ];
+          } else {
+
+            // split the camel cased version by spaces unless a key with the spaces exists
+            name = jQuery.camelCase( name );
+            if ( name in thisCache ) {
+              name = [ name ];
+            } else {
+              name = name.split(" ");
+            }
+          }
+        } else {
+          // If "name" is an array of keys...
+          // When data is initially created, via ("key", "val") signature,
+          // keys will be converted to camelCase.
+          // Since there is no way to tell _how_ a key was added, remove
+          // both plain key and camelCase key. #12786
+          // This will only penalize the array argument path.
+          name = name.concat( jQuery.map( name, jQuery.camelCase ) );
+        }
+
+        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;
+      }
+    }
+
+    // Destroy the cache
+    if ( isNode ) {
+      jQuery.cleanData( [ elem ], true );
+
+      // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
+    } else if ( jQuery.support.deleteExpando || cache != cache.window ) {
+      delete cache[ id ];
+
+      // When all else fails, null
+    } else {
+      cache[ id ] = null;
+    }
+  }
+
+  jQuery.extend({
+    cache: {},
+
+    // Unique for each copy of jQuery on the page
+    // Non-digits removed to match rinlinejQuery
+    expando: "jQuery" + ( core_version + 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 ) {
+      return internalData( elem, name, data );
+    },
+
+    removeData: function( elem, name ) {
+      return internalRemoveData( elem, name );
+    },
+
+    // For internal use only.
+    _data: function( elem, name, data ) {
+      return internalData( elem, name, data, true );
+    },
+
+    _removeData: function( elem, name ) {
+      return internalRemoveData( elem, name, true );
+    },
+
+    // A method for determining if a DOM node can handle the data expando
+    acceptData: function( elem ) {
+      // Do not set data on non-element because it will not be cleared (#8335).
+      if ( elem.nodeType && elem.nodeType !== 1 && elem.nodeType !== 9 ) {
+        return false;
+      }
+
+      var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ];
+
+      // nodes accept data unless otherwise specified; rejection can be conditional
+      return !noData || noData !== true && elem.getAttribute("classid") === noData;
+    }
+  });
+
+  jQuery.fn.extend({
+    data: function( key, value ) {
+      var attrs, name,
+        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" ) ) {
+            attrs = elem.attributes;
+            for ( ; i < attrs.length; i++ ) {
+              name = attrs[i].name;
+
+              if ( !name.indexOf( "data-" ) ) {
+                name = jQuery.camelCase( name.slice(5) );
+
+                dataAttr( elem, name, data[ name ] );
+              }
+            }
+            jQuery._data( elem, "parsedAttrs", true );
+          }
+        }
+
+        return data;
+      }
+
+      // Sets multiple values
+      if ( typeof key === "object" ) {
+        return this.each(function() {
+          jQuery.data( this, key );
+        });
+      }
+
+      return jQuery.access( this, function( value ) {
+
+        if ( value === undefined ) {
+          // Try to fetch any internally stored data first
+          return elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : null;
+        }
+
+        this.each(function() {
+          jQuery.data( this, key, value );
+        });
+      }, null, value, arguments.length > 1, null, true );
+    },
+
+    removeData: function( key ) {
+      return this.each(function() {
+        jQuery.removeData( this, key );
+      });
+    }
+  });
+
+  function dataAttr( elem, key, data ) {
+    // If nothing was found internally, try to fetch any
+    // data from the HTML5 data-* attribute
+    if ( data === undefined && elem.nodeType === 1 ) {
+
+      var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
+
+      data = elem.getAttribute( name );
+
+      if ( typeof data === "string" ) {
+        try {
+          data = data === "true" ? true :
+            data === "false" ? false :
+              data === "null" ? null :
+                // Only convert to a number if it doesn't change the string
+                +data + "" === data ? +data :
+                  rbrace.test( data ) ? jQuery.parseJSON( data ) :
+                    data;
+        } catch( e ) {}
+
+        // Make sure we set the data so it isn't changed later
+        jQuery.data( elem, key, data );
+
+      } else {
+        data = undefined;
+      }
+    }
+
+    return data;
+  }
+
+// checks a cache object for emptiness
+  function isEmptyDataObject( obj ) {
+    var name;
+    for ( name in obj ) {
+
+      // if the public data object is empty, the private is still empty
+      if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
+        continue;
+      }
+      if ( name !== "toJSON" ) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+  jQuery.extend({
+    queue: function( elem, type, data ) {
+      var queue;
+
+      if ( elem ) {
+        type = ( type || "fx" ) + "queue";
+        queue = jQuery._data( elem, type );
+
+        // Speed up dequeue by getting out quickly if this is just a lookup
+        if ( data ) {
+          if ( !queue || jQuery.isArray(data) ) {
+            queue = jQuery._data( elem, type, jQuery.makeArray(data) );
+          } else {
+            queue.push( data );
+          }
+        }
+        return queue || [];
+      }
+    },
+
+    dequeue: function( elem, type ) {
+      type = type || "fx";
+
+      var queue = jQuery.queue( elem, type ),
+        startLength = queue.length,
+        fn = queue.shift(),
+        hooks = jQuery._queueHooks( elem, type ),
+        next = function() {
+          jQuery.dequeue( elem, type );
+        };
+
+      // If the fx queue is dequeued, always remove the progress sentinel
+      if ( fn === "inprogress" ) {
+        fn = queue.shift();
+        startLength--;
+      }
+
+      hooks.cur = fn;
+      if ( fn ) {
+
+        // Add a progress sentinel to prevent the fx queue from being
+        // automatically dequeued
+        if ( type === "fx" ) {
+          queue.unshift( "inprogress" );
+        }
+
+        // clear up the last queue stop function
+        delete hooks.stop;
+        fn.call( elem, next, hooks );
+      }
+
+      if ( !startLength && hooks ) {
+        hooks.empty.fire();
+      }
+    },
+
+    // not intended for public consumption - generates a queueHooks object, or returns the current one
+    _queueHooks: function( elem, type ) {
+      var key = type + "queueHooks";
+      return jQuery._data( elem, key ) || jQuery._data( elem, key, {
+          empty: jQuery.Callbacks("once memory").add(function() {
+            jQuery._removeData( elem, type + "queue" );
+            jQuery._removeData( elem, key );
+          })
+        });
+    }
+  });
+
+  jQuery.fn.extend({
+    queue: function( type, data ) {
+      var setter = 2;
+
+      if ( typeof type !== "string" ) {
+        data = type;
+        type = "fx";
+        setter--;
+      }
+
+      if ( arguments.length < setter ) {
+        return jQuery.queue( this[0], type );
+      }
+
+      return data === undefined ?
+        this :
+        this.each(function() {
+          var queue = jQuery.queue( this, type, data );
+
+          // ensure a hooks for this queue
+          jQuery._queueHooks( this, type );
+
+          if ( type === "fx" && queue[0] !== "inprogress" ) {
+            jQuery.dequeue( this, type );
+          }
+        });
+    },
+    dequeue: function( type ) {
+      return this.each(function() {
+        jQuery.dequeue( this, type );
+      });
+    },
+    // Based off of the plugin by Clint Helfers, with permission.
+    // http://blindsignals.com/index.php/2009/07/jquery-delay/
+    delay: function( time, type ) {
+      time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
+      type = type || "fx";
+
+      return this.queue( type, function( next, hooks ) {
+        var timeout = setTimeout( next, time );
+        hooks.stop = function() {
+          clearTimeout( timeout );
+        };
+      });
+    },
+    clearQueue: function( type ) {
+      return this.queue( type || "fx", [] );
+    },
+    // Get a promise resolved when queues of a certain type
+    // are emptied (fx is the type by default)
+    promise: function( type, obj ) {
+      var tmp,
+        count = 1,
+        defer = jQuery.Deferred(),
+        elements = this,
+        i = this.length,
+        resolve = function() {
+          if ( !( --count ) ) {
+            defer.resolveWith( elements, [ elements ] );
+          }
+        };
+
+      if ( typeof type !== "string" ) {
+        obj = type;
+        type = undefined;
+      }
+      type = type || "fx";
+
+      while( i-- ) {
+        tmp = jQuery._data( elements[ i ], type + "queueHooks" );
+        if ( tmp && tmp.empty ) {
+          count++;
+          tmp.empty.add( resolve );
+        }
+      }
+      resolve();
+      return defer.promise( obj );
+    }
+  });
+  var nodeHook, boolHook,
+    rclass = /[\t\r\n]/g,
+    rreturn = /\r/g,
+    rfocusable = /^(?:input|select|textarea|button|object)$/i,
+    rclickable = /^(?:a|area)$/i,
+    rboolean = /^(?:checked|selected|autofocus|autoplay|async|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped)$/i,
+    ruseDefault = /^(?:checked|selected)$/i,
+    getSetAttribute = jQuery.support.getSetAttribute,
+    getSetInput = jQuery.support.input;
+
+  jQuery.fn.extend({
+    attr: function( name, value ) {
+      return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
+    },
+
+    removeAttr: function( name ) {
+      return this.each(function() {
+        jQuery.removeAttr( this, name );
+      });
+    },
+
+    prop: function( name, value ) {
+      return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
+    },
+
+    removeProp: function( name ) {
+      name = jQuery.propFix[ name ] || name;
+      return this.each(function() {
+        // try/catch handles cases where IE balks (such as removing a property on window)
+        try {
+          this[ name ] = undefined;
+          delete this[ name ];
+        } catch( e ) {}
+      });
+    },
+
+    addClass: function( value ) {
+      var classes, elem, cur, clazz, j,
+        i = 0,
+        len = this.length,
+        proceed = typeof value === "string" && value;
+
+      if ( jQuery.isFunction( value ) ) {
+        return this.each(function( j ) {
+          jQuery( this ).addClass( value.call( this, j, this.className ) );
+        });
+      }
+
+      if ( proceed ) {
+        // The disjunction here is for better compressibility (see removeClass)
+        classes = ( value || "" ).match( core_rnotwhite ) || [];
+
+        for ( ; i < len; i++ ) {
+          elem = this[ i ];
+          cur = elem.nodeType === 1 && ( elem.className ?
+            ( " " + elem.className + " " ).replace( rclass, " " ) :
+            " "
+          );
+
+          if ( cur ) {
+            j = 0;
+            while ( (clazz = classes[j++]) ) {
+              if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
+                cur += clazz + " ";
+              }
+            }
+            elem.className = jQuery.trim( cur );
+
+          }
+        }
+      }
+
+      return this;
+    },
+
+    removeClass: function( value ) {
+      var classes, elem, cur, clazz, j,
+        i = 0,
+        len = this.length,
+        proceed = arguments.length === 0 || typeof value === "string" && value;
+
+      if ( jQuery.isFunction( value ) ) {
+        return this.each(function( j ) {
+          jQuery( this ).removeClass( value.call( this, j, this.className ) );
+        });
+      }
+      if ( proceed ) {
+        classes = ( value || "" ).match( core_rnotwhite ) || [];
+
+        for ( ; i < len; i++ ) {
+          elem = this[ i ];
+          // This expression is here for better compressibility (see addClass)
+          cur = elem.nodeType === 1 && ( elem.className ?
+            ( " " + elem.className + " " ).replace( rclass, " " ) :
+            ""
+          );
+
+          if ( cur ) {
+            j = 0;
+            while ( (clazz = classes[j++]) ) {
+              // Remove *all* instances
+              while ( cur.indexOf( " " + clazz + " " ) >= 0 ) {
+                cur = cur.replace( " " + clazz + " ", " " );
+              }
+            }
+            elem.className = value ? jQuery.trim( cur ) : "";
+          }
+        }
+      }
+
+      return this;
+    },
+
+    toggleClass: function( value, stateVal ) {
+      var type = typeof value,
+        isBool = typeof stateVal === "boolean";
+
+      if ( jQuery.isFunction( value ) ) {
+        return this.each(function( i ) {
+          jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
+        });
+      }
+
+      return this.each(function() {
+        if ( type === "string" ) {
+          // toggle individual class names
+          var className,
+            i = 0,
+            self = jQuery( this ),
+            state = stateVal,
+            classNames = value.match( core_rnotwhite ) || [];
+
+          while ( (className = classNames[ i++ ]) ) {
+            // check each className given, space separated list
+            state = isBool ? state : !self.hasClass( className );
+            self[ state ? "addClass" : "removeClass" ]( className );
+          }
+
+          // Toggle whole class name
+        } else if ( type === core_strundefined || type === "boolean" ) {
+          if ( this.className ) {
+            // store className if set
+            jQuery._data( this, "__className__", this.className );
+          }
+
+          // If the element has a class name or if we're passed "false",
+          // then remove the whole classname (if there was one, the above saved it).
+          // Otherwise bring back whatever was previously saved (if anything),
+          // falling back to the empty string if nothing was stored.
+          this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
+        }
+      });
+    },
+
+    hasClass: function( selector ) {
+      var className = " " + selector + " ",
+        i = 0,
+        l = this.length;
+      for ( ; i < l; i++ ) {
+        if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) {
+          return true;
+        }
+      }
+
+      return false;
+    },
+
+    val: function( value ) {
+      var ret, hooks, isFunction,
+        elem = this[0];
+
+      if ( !arguments.length ) {
+        if ( elem ) {
+          hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];
+
+          if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
+            return ret;
+          }
+
+          ret = elem.value;
+
+          return typeof ret === "string" ?
+            // handle most common string cases
+            ret.replace(rreturn, "") :
+            // handle cases where value is null/undef or number
+            ret == null ? "" : ret;
+        }
+
+        return;
+      }
+
+      isFunction = jQuery.isFunction( value );
+
+      return this.each(function( i ) {
+        var val,
+          self = jQuery(this);
+
+        if ( this.nodeType !== 1 ) {
+          return;
+        }
+
+        if ( isFunction ) {
+          val = value.call( this, i, self.val() );
+        } else {
+          val = value;
+        }
+
+        // Treat null/undefined as ""; convert numbers to string
+        if ( val == null ) {
+          val = "";
+        } else if ( typeof val === "number" ) {
+          val += "";
+        } else if ( jQuery.isArray( val ) ) {
+          val = jQuery.map(val, function ( value ) {
+            return value == null ? "" : value + "";
+          });
+        }
+
+        hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
+
+        // If set returns undefined, fall back to normal setting
+        if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
+          this.value = val;
+        }
+      });
+    }
+  });
+
+  jQuery.extend({
+    valHooks: {
+      option: {
+        get: function( elem ) {
+          // attributes.value is undefined in Blackberry 4.7 but
+          // uses .value. See #6932
+          var val = elem.attributes.value;
+          return !val || val.specified ? elem.value : elem.text;
+        }
+      },
+      select: {
+        get: function( elem ) {
+          var value, option,
+            options = elem.options,
+            index = elem.selectedIndex,
+            one = elem.type === "select-one" || index < 0,
+            values = one ? null : [],
+            max = one ? index + 1 : options.length,
+            i = index < 0 ?
+              max :
+              one ? index : 0;
+
+          // Loop through all the selected options
+          for ( ; i < max; i++ ) {
+            option = options[ i ];
+
+            // oldIE doesn't update selected after form reset (#2551)
+            if ( ( option.selected || i === index ) &&
+                // Don't return options that are disabled or in a disabled optgroup
+              ( jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null ) &&
+              ( !option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {
+
+              // Get the specific value for the option
+              value = jQuery( option ).val();
+
+              // We don't need an array for one selects
+              if ( one ) {
+                return value;
+              }
+
+              // Multi-Selects return an array
+              values.push( value );
+            }
+          }
+
+          return values;
+        },
+
+        set: function( elem, value ) {
+          var values = jQuery.makeArray( value );
+
+          jQuery(elem).find("option").each(function() {
+            this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
+          });
+
+          if ( !values.length ) {
+            elem.selectedIndex = -1;
+          }
+          return values;
+        }
+      }
+    },
+
+    attr: function( elem, name, value ) {
+      var hooks, notxml, ret,
+        nType = elem.nodeType;
+
+      // don't get/set attributes on text, comment and attribute nodes
+      if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
+        return;
+      }
+
+      // Fallback to prop when attributes are not supported
+      if ( typeof elem.getAttribute === core_strundefined ) {
+        return jQuery.prop( elem, name, value );
+      }
+
+      notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
+
+      // All attributes are lowercase
+      // Grab necessary hook if one is defined
+      if ( notxml ) {
+        name = name.toLowerCase();
+        hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
+      }
+
+      if ( value !== undefined ) {
+
+        if ( value === null ) {
+          jQuery.removeAttr( elem, name );
+
+        } else if ( hooks && notxml && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
+          return ret;
+
+        } else {
+          elem.setAttribute( name, value + "" );
+          return value;
+        }
+
+      } else if ( hooks && notxml && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
+        return ret;
+
+      } else {
+
+        // In IE9+, Flash objects don't have .getAttribute (#12945)
+        // Support: IE9+
+        if ( typeof elem.getAttribute !== core_strundefined ) {
+          ret =  elem.getAttribute( name );
+        }
+
+        // Non-existent attributes return null, we normalize to undefined
+        return ret == null ?
+          undefined :
+          ret;
+      }
+    },
+
+    removeAttr: function( elem, value ) {
+      var name, propName,
+        i = 0,
+        attrNames = value && value.match( core_rnotwhite );
+
+      if ( attrNames && elem.nodeType === 1 ) {
+        while ( (name = attrNames[i++]) ) {
+          propName = jQuery.propFix[ name ] || name;
+
+          // Boolean attributes get special treatment (#10870)
+          if ( rboolean.test( name ) ) {
+            // Set corresponding property to false for boolean attributes
+            // Also clear defaultChecked/defaultSelected (if appropriate) for IE<8
+            if ( !getSetAttribute && ruseDefault.test( name ) ) {
+              elem[ jQuery.camelCase( "default-" + name ) ] =
+                elem[ propName ] = false;
+            } else {
+              elem[ propName ] = false;
+            }
+
+            // See #9699 for explanation of this approach (setting first, then removal)
+          } else {
+            jQuery.attr( elem, name, "" );
+          }
+
+          elem.removeAttribute( getSetAttribute ? name : propName );
+        }
+      }
+    },
+
+    attrHooks: {
+      type: {
+        set: function( elem, value ) {
+          if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
+            // Setting the type on a radio button after the value resets the value in IE6-9
+            // Reset value to default in case type is set after value during creation
+            var val = elem.value;
+            elem.setAttribute( "type", value );
+            if ( val ) {
+              elem.value = val;
+            }
+            return value;
+          }
+        }
+      }
+    },
+
+    propFix: {
+      tabindex: "tabIndex",
+      readonly: "readOnly",
+      "for": "htmlFor",
+      "class": "className",
+      maxlength: "maxLength",
+      cellspacing: "cellSpacing",
+      cellpadding: "cellPadding",
+      rowspan: "rowSpan",
+      colspan: "colSpan",
+      usemap: "useMap",
+      frameborder: "frameBorder",
+      contenteditable: "contentEditable"
+    },
+
+    prop: function( elem, name, value ) {
+      var ret, hooks, notxml,
+        nType = elem.nodeType;
+
+      // don't get/set properties on text, comment and attribute nodes
+      if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
+        return;
+      }
+
+      notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
+
+      if ( notxml ) {
+        // Fix name and attach hooks
+        name = jQuery.propFix[ name ] || name;
+        hooks = jQuery.propHooks[ name ];
+      }
+
+      if ( value !== undefined ) {
+        if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
+          return ret;
+
+        } else {
+          return ( elem[ name ] = value );
+        }
+
+      } else {
+        if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
+          return ret;
+
+        } else {
+          return elem[ name ];
+        }
+      }
+    },
+
+    propHooks: {
+      tabIndex: {
+        get: function( elem ) {
+          // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
+          // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
+          var attributeNode = elem.getAttributeNode("tabindex");
+
+          return attributeNode && attributeNode.specified ?
+            parseInt( attributeNode.value, 10 ) :
+            rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
+              0 :
+              undefined;
+        }
+      }
+    }
+  });
+
+// Hook for boolean attributes
+  boolHook = {
+    get: function( elem, name ) {
+      var
+      // Use .prop to determine if this attribute is understood as boolean
+        prop = jQuery.prop( elem, name ),
+
+      // Fetch it accordingly
+        attr = typeof prop === "boolean" && elem.getAttribute( name ),
+        detail = typeof prop === "boolean" ?
+
+          getSetInput && getSetAttribute ?
+          attr != null :
+            // oldIE fabricates an empty string for missing boolean attributes
+            // and conflates checked/selected into attroperties
+            ruseDefault.test( name ) ?
+              elem[ jQuery.camelCase( "default-" + name ) ] :
+              !!attr :
+
+          // fetch an attribute node for properties not recognized as boolean
+          elem.getAttributeNode( name );
+
+      return detail && detail.value !== false ?
+        name.toLowerCase() :
+        undefined;
+    },
+    set: function( elem, value, name ) {
+      if ( value === false ) {
+        // Remove boolean attributes when set to false
+        jQuery.removeAttr( elem, name );
+      } else if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {
+        // IE<8 needs the *property* name
+        elem.setAttribute( !getSetAttribute && jQuery.propFix[ name ] || name, name );
+
+        // Use defaultChecked and defaultSelected for oldIE
+      } else {
+        elem[ jQuery.camelCase( "default-" + name ) ] = elem[ name ] = true;
+      }
+
+      return name;
+    }
+  };
+
+// fix oldIE value attroperty
+  if ( !getSetInput || !getSetAttribute ) {
+    jQuery.attrHooks.value = {
+      get: function( elem, name ) {
+        var ret = elem.getAttributeNode( name );
+        return jQuery.nodeName( elem, "input" ) ?
+
+          // Ignore the value *property* by using defaultValue
+          elem.defaultValue :
+
+          ret && ret.specified ? ret.value : undefined;
+      },
+      set: function( elem, value, name ) {
+        if ( jQuery.nodeName( elem, "input" ) ) {
+          // Does not return so that setAttribute is also used
+          elem.defaultValue = value;
+        } else {
+          // Use nodeHook if defined (#1954); otherwise setAttribute is fine
+          return nodeHook && nodeHook.set( elem, value, name );
+        }
+      }
+    };
+  }
+
+// IE6/7 do not support getting/setting some attributes with get/setAttribute
+  if ( !getSetAttribute ) {
+
+    // Use this for any attribute in IE6/7
+    // This fixes almost every IE6/7 issue
+    nodeHook = jQuery.valHooks.button = {
+      get: function( elem, name ) {
+        var ret = elem.getAttributeNode( name );
+        return ret && ( name === "id" || name === "name" || name === "coords" ? ret.value !== "" : ret.specified ) ?
+          ret.value :
+          undefined;
+      },
+      set: function( elem, value, name ) {
+        // Set the existing or create a new attribute node
+        var ret = elem.getAttributeNode( name );
+        if ( !ret ) {
+          elem.setAttributeNode(
+            (ret = elem.ownerDocument.createAttribute( name ))
+          );
+        }
+
+        ret.value = value += "";
+
+        // Break association with cloned elements by also using setAttribute (#9646)
+        return name === "value" || value === elem.getAttribute( name ) ?
+          value :
+          undefined;
+      }
+    };
+
+    // Set contenteditable to false on removals(#10429)
+    // Setting to empty string throws an error as an invalid value
+    jQuery.attrHooks.contenteditable = {
+      get: nodeHook.get,
+      set: function( elem, value, name ) {
+        nodeHook.set( elem, value === "" ? false : value, name );
+      }
+    };
+
+    // Set width and height to auto instead of 0 on empty string( Bug #8150 )
+    // This is for removals
+    jQuery.each([ "width", "height" ], function( i, name ) {
+      jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
+        set: function( elem, value ) {
+          if ( value === "" ) {
+            elem.setAttribute( name, "auto" );
+            return value;
+          }
+        }
+      });
+    });
+  }
+
+
+// Some attributes require a special call on IE
+// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
+  if ( !jQuery.support.hrefNormalized ) {
+    jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
+      jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
+        get: function( elem ) {
+          var ret = elem.getAttribute( name, 2 );
+          return ret == null ? undefined : ret;
+        }
+      });
+    });
+
+    // href/src property should get the full normalized URL (#10299/#12915)
+    jQuery.each([ "href", "src" ], function( i, name ) {
+      jQuery.propHooks[ name ] = {
+        get: function( elem ) {
+          return elem.getAttribute( name, 4 );
+        }
+      };
+    });
+  }
+
+  if ( !jQuery.support.style ) {
+    jQuery.attrHooks.style = {
+      get: function( elem ) {
+        // Return undefined in the case of empty string
+        // Note: IE uppercases css property names, but if we were to .toLowerCase()
+        // .cssText, that would destroy case senstitivity in URL's, like in "background"
+        return elem.style.cssText || undefined;
+      },
+      set: function( elem, value ) {
+        return ( elem.style.cssText = value + "" );
+      }
+    };
+  }
+
+// Safari mis-reports the default selected property of an option
+// Accessing the parent's selectedIndex property fixes it
+  if ( !jQuery.support.optSelected ) {
+    jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
+      get: function( elem ) {
+        var parent = elem.parentNode;
+
+        if ( parent ) {
+          parent.selectedIndex;
+
+          // Make sure that it also works with optgroups, see #5701
+          if ( parent.parentNode ) {
+            parent.parentNode.selectedIndex;
+          }
+        }
+        return null;
+      }
+    });
+  }
+
+// IE6/7 call enctype encoding
+  if ( !jQuery.support.enctype ) {
+    jQuery.propFix.enctype = "encoding";
+  }
+
+// Radios and checkboxes getter/setter
+  if ( !jQuery.support.checkOn ) {
+    jQuery.each([ "radio", "checkbox" ], function() {
+      jQuery.valHooks[ this ] = {
+        get: function( elem ) {
+          // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
+          return elem.getAttribute("value") === null ? "on" : elem.value;
+        }
+      };
+    });
+  }
+  jQuery.each([ "radio", "checkbox" ], function() {
+    jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
+      set: function( elem, value ) {
+        if ( jQuery.isArray( value ) ) {
+          return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
+        }
+      }
+    });
+  });
+  var rformElems = /^(?:input|select|textarea)$/i,
+    rkeyEvent = /^key/,
+    rmouseEvent = /^(?:mouse|contextmenu)|click/,
+    rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
+    rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;
+
+  function returnTrue() {
+    return true;
+  }
+
+  function returnFalse() {
+    return false;
+  }
+
+  /*
+   * Helper functions for managing events -- not part of the public interface.
+   * Props to Dean Edwards' addEvent library for many of the ideas.
+   */
+  jQuery.event = {
+
+    global: {},
+
+    add: function( elem, types, handler, data, selector ) {
+      var tmp, events, t, handleObjIn,
+        special, eventHandle, handleObj,
+        handlers, type, namespaces, origType,
+        elemData = jQuery._data( elem );
+
+      // Don't attach events to noData or text/comment nodes (but allow plain objects)
+      if ( !elemData ) {
+        return;
+      }
+
+      // Caller can pass in an object of custom data in lieu of the handler
+      if ( handler.handler ) {
+        handleObjIn = handler;
+        handler = handleObjIn.handler;
+        selector = handleObjIn.selector;
+      }
+
+      // Make sure that the handler has a unique ID, used to find/remove it later
+      if ( !handler.guid ) {
+        handler.guid = jQuery.guid++;
+      }
+
+      // Init the element's event structure and main handler, if this is the first
+      if ( !(events = elemData.events) ) {
+        events = elemData.events = {};
+      }
+      if ( !(eventHandle = elemData.handle) ) {
+        eventHandle = elemData.handle = function( e ) {
+          // Discard the second event of a jQuery.event.trigger() and
+          // when an event is called after a page has unloaded
+          return typeof jQuery !== core_strundefined && (!e || jQuery.event.triggered !== e.type) ?
+            jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
+            undefined;
+        };
+        // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
+        eventHandle.elem = elem;
+      }
+
+      // Handle multiple events separated by a space
+      // jQuery(...).bind("mouseover mouseout", fn);
+      types = ( types || "" ).match( core_rnotwhite ) || [""];
+      t = types.length;
+      while ( t-- ) {
+        tmp = rtypenamespace.exec( types[t] ) || [];
+        type = origType = tmp[1];
+        namespaces = ( tmp[2] || "" ).split( "." ).sort();
+
+        // If event changes its type, use the special event handlers for the changed type
+        special = jQuery.event.special[ type ] || {};
+
+        // If selector defined, determine special event api type, otherwise given type
+        type = ( selector ? special.delegateType : special.bindType ) || type;
+
+        // Update special based on newly reset type
+        special = jQuery.event.special[ type ] || {};
+
+        // handleObj is passed to all event handlers
+        handleObj = jQuery.extend({
+          type: type,
+          origType: origType,
+          data: data,
+          handler: handler,
+          guid: handler.guid,
+     

<TRUNCATED>

Mime
View raw message