define([
|
"./var/deletedIds",
|
"./var/slice",
|
"./var/concat",
|
"./var/push",
|
"./var/indexOf",
|
"./var/class2type",
|
"./var/toString",
|
"./var/hasOwn",
|
"./var/support"
|
], function( deletedIds, slice, concat, push, indexOf, class2type, toString, hasOwn, support ) {
|
|
var
|
version = "@VERSION",
|
|
// Define a local copy of jQuery
|
jQuery = function( selector, context ) {
|
// The jQuery object is actually just the init constructor 'enhanced'
|
// Need init if jQuery is called (just allow error to be thrown if not included)
|
return new jQuery.fn.init( selector, context );
|
},
|
|
// Support: Android<4.1, IE<9
|
// Make sure we trim BOM and NBSP
|
rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/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();
|
};
|
|
jQuery.fn = jQuery.prototype = {
|
// The current version of jQuery being used
|
jquery: version,
|
|
constructor: jQuery,
|
|
// Start with an empty selector
|
selector: "",
|
|
// The default length of a jQuery object is 0
|
length: 0,
|
|
toArray: function() {
|
return 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 just the one element from the set
|
( num < 0 ? this[ num + this.length ] : this[ num ] ) :
|
|
// Return all the elements in a clean array
|
slice.call( this );
|
},
|
|
// 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 );
|
},
|
|
map: function( callback ) {
|
return this.pushStack( jQuery.map(this, function( elem, i ) {
|
return callback.call( elem, i, elem );
|
}));
|
},
|
|
slice: function() {
|
return this.pushStack( 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] ] : [] );
|
},
|
|
end: function() {
|
return this.prevObject || this.constructor(null);
|
},
|
|
// For internal use only.
|
// Behaves like an Array's method, not like a jQuery method.
|
push: push,
|
sort: deletedIds.sort,
|
splice: deletedIds.splice
|
};
|
|
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;
|
|
// skip the boolean and the target
|
target = arguments[ i ] || {};
|
i++;
|
}
|
|
// 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 ( i === length ) {
|
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({
|
// Unique for each copy of jQuery on the page
|
expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
|
|
// Assume jQuery is ready without the ready module
|
isReady: true,
|
|
error: function( msg ) {
|
throw new Error( msg );
|
},
|
|
noop: function() {},
|
|
// See test/unit/home.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 ) {
|
/* jshint eqeqeq: false */
|
return obj != null && obj == obj.window;
|
},
|
|
isNumeric: function( obj ) {
|
// parseFloat NaNs numeric-cast false positives (null|true|false|"")
|
// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
|
// subtraction forces infinities to NaN
|
// adding 1 corrects loss of precision from parseFloat (#15100)
|
return !jQuery.isArray( obj ) && (obj - parseFloat( obj ) + 1) >= 0;
|
},
|
|
isEmptyObject: function( obj ) {
|
var name;
|
for ( name in obj ) {
|
return false;
|
}
|
return true;
|
},
|
|
isPlainObject: function( obj ) {
|
var key;
|
|
// Must be an Object.
|
// Because of IE, we also have to check the presence of the constructor property.
|
// Make sure that DOM nodes and window objects don't pass through, as well
|
if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
|
return false;
|
}
|
|
try {
|
// Not own constructor property must be Object
|
if ( obj.constructor &&
|
!hasOwn.call(obj, "constructor") &&
|
!hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
|
return false;
|
}
|
} catch ( e ) {
|
// IE8,9 Will throw exceptions on certain host objects #9897
|
return false;
|
}
|
|
// Support: IE<9
|
// Handle iteration over inherited properties before own properties.
|
if ( support.ownLast ) {
|
for ( key in obj ) {
|
return hasOwn.call( obj, key );
|
}
|
}
|
|
// Own properties are enumerated firstly, so to speed up,
|
// if last one is own, then all properties are own.
|
for ( key in obj ) {}
|
|
return key === undefined || hasOwn.call( obj, key );
|
},
|
|
type: function( obj ) {
|
if ( obj == null ) {
|
return obj + "";
|
}
|
return typeof obj === "object" || typeof obj === "function" ?
|
class2type[ toString.call(obj) ] || "object" :
|
typeof obj;
|
},
|
|
// 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;
|
},
|
|
// Support: Android<4.1, IE<9
|
trim: 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 {
|
push.call( ret, arr );
|
}
|
}
|
|
return ret;
|
},
|
|
inArray: function( elem, arr, i ) {
|
var len;
|
|
if ( arr ) {
|
if ( indexOf ) {
|
return 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 len = +second.length,
|
j = 0,
|
i = first.length;
|
|
while ( j < len ) {
|
first[ i++ ] = second[ j++ ];
|
}
|
|
// Support: IE<9
|
// Workaround casting of .length to NaN on otherwise arraylike objects (e.g., NodeLists)
|
if ( len !== len ) {
|
while ( second[j] !== undefined ) {
|
first[ i++ ] = second[ j++ ];
|
}
|
}
|
|
first.length = i;
|
|
return first;
|
},
|
|
grep: function( elems, callback, invert ) {
|
var callbackInverse,
|
matches = [],
|
i = 0,
|
length = elems.length,
|
callbackExpect = !invert;
|
|
// Go through the array, only saving the items
|
// that pass the validator function
|
for ( ; i < length; i++ ) {
|
callbackInverse = !callback( elems[ i ], i );
|
if ( callbackInverse !== callbackExpect ) {
|
matches.push( elems[ i ] );
|
}
|
}
|
|
return matches;
|
},
|
|
// 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 new values
|
if ( isArray ) {
|
for ( ; i < length; i++ ) {
|
value = callback( elems[ i ], i, arg );
|
|
if ( value != null ) {
|
ret.push( value );
|
}
|
}
|
|
// Go through every key on the object,
|
} else {
|
for ( i in elems ) {
|
value = callback( elems[ i ], i, arg );
|
|
if ( value != null ) {
|
ret.push( value );
|
}
|
}
|
}
|
|
// Flatten any nested arrays
|
return 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 = slice.call( arguments, 2 );
|
proxy = function() {
|
return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
|
};
|
|
// Set the guid of unique handler to the same of original handler, so it can be removed
|
proxy.guid = fn.guid = fn.guid || jQuery.guid++;
|
|
return proxy;
|
},
|
|
now: function() {
|
return +( new Date() );
|
},
|
|
// jQuery.support is not used in Core but other projects attach their
|
// properties to it so it needs to exist.
|
support: support
|
});
|
|
// 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 ( type === "function" || jQuery.isWindow( obj ) ) {
|
return false;
|
}
|
|
if ( obj.nodeType === 1 && length ) {
|
return true;
|
}
|
|
return type === "array" || length === 0 ||
|
typeof length === "number" && length > 0 && ( length - 1 ) in obj;
|
}
|
|
return jQuery;
|
});
|
