├── outro.js
├── .gitignore
├── selector.js
├── var
    ├── arr.js
    ├── rnotwhite.js
    ├── push.js
    ├── class2type.js
    ├── concat.js
    ├── indexOf.js
    ├── slice.js
    ├── pnum.js
    ├── toString.js
    ├── hasOwn.js
    └── support.js
├── ajax
    ├── var
    │   ├── rquery.js
    │   └── nonce.js
    ├── parseJSON.js
    ├── parseXML.js
    ├── script.js
    ├── load.js
    ├── jsonp.js
    └── xhr.js
├── css
    ├── var
    │   ├── rmargin.js
    │   ├── cssExpand.js
    │   ├── rnumnonpx.js
    │   ├── isHidden.js
    │   └── getStyles.js
    ├── hiddenVisibleSelectors.js
    ├── addGetHookIf.js
    ├── swap.js
    ├── curCSS.js
    ├── defaultDisplay.js
    └── support.js
├── README.md
├── data
    ├── var
    │   ├── dataPriv.js
    │   └── dataUser.js
    ├── accepts.js
    └── Data.js
├── manipulation
    ├── var
    │   └── rcheckableType.js
    ├── _evalUrl.js
    └── support.js
├── traversing
    ├── var
    │   └── rneedsContext.js
    └── findFilter.js
├── core
    ├── var
    │   └── rsingleTag.js
    ├── parseHTML.js
    ├── access.js
    ├── ready.js
    └── init.js
├── event
    ├── support.js
    ├── ajax.js
    └── alias.js
├── attributes.js
├── effects
    ├── animatedSelector.js
    └── Tween.js
├── deprecated.js
├── selector-sizzle.js
├── .jshintrc
├── queue
    └── delay.js
├── exports
    ├── global.js
    └── amd.js
├── jquery.js
├── attributes
    ├── support.js
    ├── prop.js
    ├── attr.js
    ├── val.js
    └── classes.js
├── LICENSE
├── intro.js
├── wrap.js
├── dimensions.js
├── queue.js
├── serialize.js
├── traversing.js
├── selector-native.js
├── offset.js
├── deferred.js
├── data.js
├── callbacks.js
├── css.js
├── effects.js
├── manipulation.js
└── core.js


/outro.js:
--------------------------------------------------------------------------------
1 | }));
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # 只忽略dbg目录，不忽略dbg文件
2 | 
3 | .idea/


--------------------------------------------------------------------------------
/selector.js:
--------------------------------------------------------------------------------
1 | define([ "./selector-sizzle" ]);
2 | 


--------------------------------------------------------------------------------
/var/arr.js:
--------------------------------------------------------------------------------
1 | define(function() {
2 | 	return [];
3 | });
4 | 


--------------------------------------------------------------------------------
/ajax/var/rquery.js:
--------------------------------------------------------------------------------
1 | define(function() {
2 | 	return (/\?/);
3 | });
4 | 


--------------------------------------------------------------------------------
/css/var/rmargin.js:
--------------------------------------------------------------------------------
1 | define(function() {
2 | 	return (/^margin/);
3 | });
4 | 


--------------------------------------------------------------------------------
/var/rnotwhite.js:
--------------------------------------------------------------------------------
1 | define(function() {
2 | 	// 匹配空白字符
3 | 	return (/\S+/g);
4 | });
5 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | jQuery_analysis_Chinese
2 | =======================
3 | 
4 | jQuery 2.1.1 源码分析
5 | 


--------------------------------------------------------------------------------
/var/push.js:
--------------------------------------------------------------------------------
1 | define([
2 | 	"./arr"
3 | ], function( arr ) {
4 | 	return arr.push;
5 | });
6 | 


--------------------------------------------------------------------------------
/var/class2type.js:
--------------------------------------------------------------------------------
1 | define(function() {
2 | 	// [[Class]] -> type pairs
3 | 	return {};
4 | });
5 | 


--------------------------------------------------------------------------------
/var/concat.js:
--------------------------------------------------------------------------------
1 | define([
2 | 	"./arr"
3 | ], function( arr ) {
4 | 	return arr.concat;
5 | });
6 | 


--------------------------------------------------------------------------------
/var/indexOf.js:
--------------------------------------------------------------------------------
1 | define([
2 | 	"./arr"
3 | ], function( arr ) {
4 | 	return arr.indexOf;
5 | });
6 | 


--------------------------------------------------------------------------------
/var/slice.js:
--------------------------------------------------------------------------------
1 | define([
2 | 	"./arr"
3 | ], function( arr ) {
4 | 	return arr.slice;
5 | });
6 | 


--------------------------------------------------------------------------------
/css/var/cssExpand.js:
--------------------------------------------------------------------------------
1 | define(function() {
2 | 	return [ "Top", "Right", "Bottom", "Left" ];
3 | });
4 | 


--------------------------------------------------------------------------------
/var/pnum.js:
--------------------------------------------------------------------------------
1 | define(function() {
2 | 	return (/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/).source;
3 | });
4 | 


--------------------------------------------------------------------------------
/data/var/dataPriv.js:
--------------------------------------------------------------------------------
1 | define([
2 | 	"../Data"
3 | ], function( Data ) {
4 | 	return new Data();
5 | });
6 | 


--------------------------------------------------------------------------------
/data/var/dataUser.js:
--------------------------------------------------------------------------------
1 | define([
2 | 	"../Data"
3 | ], function( Data ) {
4 | 	return new Data();
5 | });
6 | 


--------------------------------------------------------------------------------
/manipulation/var/rcheckableType.js:
--------------------------------------------------------------------------------
1 | define(function() {
2 | 	return (/^(?:checkbox|radio)$/i);
3 | });
4 | 


--------------------------------------------------------------------------------
/ajax/var/nonce.js:
--------------------------------------------------------------------------------
1 | define([
2 | 	"../../core"
3 | ], function( jQuery ) {
4 | 	return jQuery.now();
5 | });
6 | 


--------------------------------------------------------------------------------
/var/toString.js:
--------------------------------------------------------------------------------
1 | define([
2 | 	"./class2type"
3 | ], function( class2type ) {
4 | 	return class2type.toString;
5 | });
6 | 


--------------------------------------------------------------------------------
/var/hasOwn.js:
--------------------------------------------------------------------------------
1 | define([
2 | 	"./class2type"
3 | ], function( class2type ) {
4 | 	return class2type.hasOwnProperty;
5 | });
6 | 


--------------------------------------------------------------------------------
/var/support.js:
--------------------------------------------------------------------------------
1 | define(function() {
2 | 	// All support tests are defined in their respective modules.
3 | 	return {};
4 | });
5 | 


--------------------------------------------------------------------------------
/css/var/rnumnonpx.js:
--------------------------------------------------------------------------------
1 | define([
2 | 	"../../var/pnum"
3 | ], function( pnum ) {
4 | 	return new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
5 | });
6 | 


--------------------------------------------------------------------------------
/traversing/var/rneedsContext.js:
--------------------------------------------------------------------------------
1 | define([
2 | 	"../../core",
3 | 	"../../selector"
4 | ], function( jQuery ) {
5 | 	return jQuery.expr.match.needsContext;
6 | });
7 | 


--------------------------------------------------------------------------------
/core/var/rsingleTag.js:
--------------------------------------------------------------------------------
1 | define(function() {
2 | 	// Match a standalone tag
3 |     // 匹配独立的标签
4 |     // 类似<div /> 或者 <div></div>
5 | 	return (/^<(\w+)\s*\/?>(?:<\/\1>|)$/);
6 | });
7 | 


--------------------------------------------------------------------------------
/event/support.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../var/support"
 3 | ], function( support ) {
 4 | 
 5 | support.focusinBubbles = "onfocusin" in window;
 6 | 
 7 | return support;
 8 | 
 9 | });
10 | 


--------------------------------------------------------------------------------
/attributes.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"./core",
 3 | 	"./attributes/attr",
 4 | 	"./attributes/prop",
 5 | 	"./attributes/classes",
 6 | 	"./attributes/val"
 7 | ], function( jQuery ) {
 8 | 
 9 | // Return jQuery for attributes-only inclusion
10 | return jQuery;
11 | });
12 | 


--------------------------------------------------------------------------------
/ajax/parseJSON.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../core"
 3 | ], function( jQuery ) {
 4 | 
 5 | // Support: Android 2.3
 6 | // Workaround failure to string-cast null input
 7 | jQuery.parseJSON = function( data ) {
 8 | 	return JSON.parse( data + "" );
 9 | };
10 | 
11 | return jQuery.parseJSON;
12 | 
13 | });
14 | 


--------------------------------------------------------------------------------
/effects/animatedSelector.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../core",
 3 | 	"../selector",
 4 | 	"../effects"
 5 | ], function( jQuery ) {
 6 | 
 7 | jQuery.expr.filters.animated = function( elem ) {
 8 | 	return jQuery.grep(jQuery.timers, function( fn ) {
 9 | 		return elem === fn.elem;
10 | 	}).length;
11 | };
12 | 
13 | });
14 | 


--------------------------------------------------------------------------------
/deprecated.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"./core",
 3 | 	"./traversing"
 4 | ], function( jQuery ) {
 5 | 
 6 | // The number of elements contained in the matched element set
 7 | // 匹配的元素集合中包含的元素数量
 8 | jQuery.fn.size = function() {
 9 | 	return this.length;
10 | };
11 | 
12 | jQuery.fn.andSelf = jQuery.fn.addBack;
13 | 
14 | });
15 | 


--------------------------------------------------------------------------------
/manipulation/_evalUrl.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../ajax"
 3 | ], function( jQuery ) {
 4 | 
 5 | jQuery._evalUrl = function( url ) {
 6 | 	return jQuery.ajax({
 7 | 		url: url,
 8 | 		type: "GET",
 9 | 		dataType: "script",
10 | 		async: false,
11 | 		global: false,
12 | 		"throws": true
13 | 	});
14 | };
15 | 
16 | return jQuery._evalUrl;
17 | 
18 | });
19 | 


--------------------------------------------------------------------------------
/selector-sizzle.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"./core",
 3 | 	"sizzle"
 4 | ], function( jQuery, Sizzle ) {
 5 | 
 6 | jQuery.find = Sizzle;
 7 | jQuery.expr = Sizzle.selectors;
 8 | jQuery.expr[":"] = jQuery.expr.pseudos;
 9 | jQuery.unique = Sizzle.uniqueSort;
10 | jQuery.text = Sizzle.getText;
11 | jQuery.isXMLDoc = Sizzle.isXML;
12 | jQuery.contains = Sizzle.contains;
13 | 
14 | });
15 | 


--------------------------------------------------------------------------------
/event/ajax.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../core",
 3 | 	"../event"
 4 | ], function( jQuery ) {
 5 | 
 6 | // Attach a bunch of functions for handling common AJAX events
 7 | jQuery.each([
 8 | 	"ajaxStart",
 9 | 	"ajaxStop",
10 | 	"ajaxComplete",
11 | 	"ajaxError",
12 | 	"ajaxSuccess",
13 | 	"ajaxSend"
14 | ], function( i, type ) {
15 | 	jQuery.fn[ type ] = function( fn ) {
16 | 		return this.on( type, fn );
17 | 	};
18 | });
19 | 
20 | });
21 | 


--------------------------------------------------------------------------------
/css/var/isHidden.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../../core",
 3 | 	"../../selector"
 4 | 	// css is assumed
 5 | ], function( jQuery ) {
 6 | 
 7 | 	return function( elem, el ) {
 8 | 		// isHidden might be called from jQuery#filter function;
 9 | 		// in that case, element will be second argument
10 | 		elem = el || elem;
11 | 		return jQuery.css( elem, "display" ) === "none" ||
12 | 			!jQuery.contains( elem.ownerDocument, elem );
13 | 	};
14 | });
15 | 


--------------------------------------------------------------------------------
/.jshintrc:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"boss": true,
 3 | 	"curly": true,
 4 | 	"eqeqeq": true,
 5 | 	"eqnull": true,
 6 | 	"expr": true,
 7 | 	"immed": true,
 8 | 	"noarg": true,
 9 | 	"onevar": true,
10 | 	"quotmark": "double",
11 | 	"smarttabs": true,
12 | 	"trailing": true,
13 | 	"undef": true,
14 | 	"unused": true,
15 | 
16 | 	"sub": true,
17 | 
18 | 	"browser": true,
19 | 
20 | 	"globals": {
21 | 		"jQuery": true,
22 | 		"define": true,
23 | 		"module": true,
24 | 		"noGlobal": true
25 | 	}
26 | }
27 | 


--------------------------------------------------------------------------------
/css/var/getStyles.js:
--------------------------------------------------------------------------------
 1 | define(function() {
 2 | 	return function( elem ) {
 3 | 		// Support: IE<=11+, Firefox<=30+ (#15098, #14150)
 4 | 		// IE throws on elements created in popups
 5 | 		// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
 6 | 		if ( elem.ownerDocument.defaultView.opener ) {
 7 | 			return elem.ownerDocument.defaultView.getComputedStyle( elem, null );
 8 | 		}
 9 | 
10 | 		return window.getComputedStyle( elem, null );
11 | 	};
12 | });
13 | 


--------------------------------------------------------------------------------
/data/accepts.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../core"
 3 | ], function( jQuery ) {
 4 | 
 5 | /**
 6 |  * Determines whether an object can have data
 7 |  * 确定一个对象是否可以添加数据缓存
 8 |  */
 9 | jQuery.acceptData = function( owner ) {
10 | 	// Accepts only:
11 | 	//  - Node
12 | 	//    - Node.ELEMENT_NODE
13 | 	//    - Node.DOCUMENT_NODE
14 | 	//  - Object
15 | 	//    - Any
16 | 	/* jshint -W018 */
17 | 
18 | 	// 仅接受 元素对象，文档对象以及js对象
19 | 	return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
20 | };
21 | 
22 | return jQuery.acceptData;
23 | });
24 | 


--------------------------------------------------------------------------------
/css/hiddenVisibleSelectors.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../core",
 3 | 	"../selector"
 4 | ], function( jQuery ) {
 5 | 
 6 | jQuery.expr.filters.hidden = function( elem ) {
 7 | 	// Support: Opera <= 12.12
 8 | 	// Opera reports offsetWidths and offsetHeights less than zero on some elements
 9 | 	// Use OR instead of AND as the element is not visible if either is true
10 | 	// See tickets #10406 and #13132
11 | 	return elem.offsetWidth <= 0 || elem.offsetHeight <= 0;
12 | };
13 | jQuery.expr.filters.visible = function( elem ) {
14 | 	return !jQuery.expr.filters.hidden( elem );
15 | };
16 | 
17 | });
18 | 


--------------------------------------------------------------------------------
/ajax/parseXML.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../core"
 3 | ], function( jQuery ) {
 4 | 
 5 | // Cross-browser xml parsing
 6 | jQuery.parseXML = function( data ) {
 7 | 	var xml, tmp;
 8 | 	if ( !data || typeof data !== "string" ) {
 9 | 		return null;
10 | 	}
11 | 
12 | 	// Support: IE9
13 | 	try {
14 | 		tmp = new DOMParser();
15 | 		xml = tmp.parseFromString( data, "text/xml" );
16 | 	} catch ( e ) {
17 | 		xml = undefined;
18 | 	}
19 | 
20 | 	if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) {
21 | 		jQuery.error( "Invalid XML: " + data );
22 | 	}
23 | 	return xml;
24 | };
25 | 
26 | return jQuery.parseXML;
27 | 
28 | });
29 | 


--------------------------------------------------------------------------------
/css/addGetHookIf.js:
--------------------------------------------------------------------------------
 1 | define(function() {
 2 | 
 3 | function addGetHookIf( conditionFn, hookFn ) {
 4 | 	// Define the hook, we'll check on the first run if it's really needed.
 5 | 	return {
 6 | 		get: function() {
 7 | 			if ( conditionFn() ) {
 8 | 				// Hook not needed (or it's not possible to use it due
 9 | 				// to missing dependency), remove it.
10 | 				delete this.get;
11 | 				return;
12 | 			}
13 | 
14 | 			// Hook needed; redefine it so that the support test is not executed again.
15 | 			return (this.get = hookFn).apply( this, arguments );
16 | 		}
17 | 	};
18 | }
19 | 
20 | return addGetHookIf;
21 | 
22 | });
23 | 


--------------------------------------------------------------------------------
/queue/delay.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../core",
 3 | 	"../queue",
 4 | 	"../effects" // Delay is optional because of this dependency
 5 | ], function( jQuery ) {
 6 | 
 7 | // Based off of the plugin by Clint Helfers, with permission.
 8 | // http://blindsignals.com/index.php/2009/07/jquery-delay/
 9 | jQuery.fn.delay = function( time, type ) {
10 | 	time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
11 | 	type = type || "fx";
12 | 
13 | 	return this.queue( type, function( next, hooks ) {
14 | 		var timeout = setTimeout( next, time );
15 | 		hooks.stop = function() {
16 | 			clearTimeout( timeout );
17 | 		};
18 | 	});
19 | };
20 | 
21 | return jQuery.fn.delay;
22 | });
23 | 


--------------------------------------------------------------------------------
/css/swap.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../core"
 3 | ], function( jQuery ) {
 4 | 
 5 | // A method for quickly swapping in/out CSS properties to get correct calculations.
 6 | jQuery.swap = function( elem, options, callback, args ) {
 7 | 	var ret, name,
 8 | 		old = {};
 9 | 
10 | 	// Remember the old values, and insert the new ones
11 | 	for ( name in options ) {
12 | 		old[ name ] = elem.style[ name ];
13 | 		elem.style[ name ] = options[ name ];
14 | 	}
15 | 
16 | 	ret = callback.apply( elem, args || [] );
17 | 
18 | 	// Revert the old values
19 | 	for ( name in options ) {
20 | 		elem.style[ name ] = old[ name ];
21 | 	}
22 | 
23 | 	return ret;
24 | };
25 | 
26 | return jQuery.swap;
27 | 
28 | });
29 | 


--------------------------------------------------------------------------------
/exports/global.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../core"
 3 | ], function( jQuery ) {
 4 | 
 5 | var
 6 | 	// Map over jQuery in case of overwrite
 7 | 	_jQuery = window.jQuery,
 8 | 
 9 | 	// Map over the $ in case of overwrite
10 | 	_$ = window.$;
11 | 
12 | jQuery.noConflict = function( deep ) {
13 | 	if ( window.$ === jQuery ) {
14 | 		window.$ = _$;
15 | 	}
16 | 
17 | 	if ( deep && window.jQuery === jQuery ) {
18 | 		window.jQuery = _jQuery;
19 | 	}
20 | 
21 | 	return jQuery;
22 | };
23 | 
24 | // Expose jQuery and $ identifiers, even in AMD
25 | // (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
26 | // and CommonJS for browser emulators (#13566)
27 | if ( !noGlobal ) {
28 | 	window.jQuery = window.$ = jQuery;
29 | }
30 | 
31 | });
32 | 


--------------------------------------------------------------------------------
/jquery.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"./core",
 3 | 	"./selector",
 4 | 	"./traversing",
 5 | 	"./callbacks",
 6 | 	"./deferred",
 7 | 	"./core/ready",
 8 | 	"./data",
 9 | 	"./queue",
10 | 	"./queue/delay",
11 | 	"./attributes",
12 | 	"./event",
13 | 	"./event/alias",
14 | 	"./manipulation",
15 | 	"./manipulation/_evalUrl",
16 | 	"./wrap",
17 | 	"./css",
18 | 	"./css/hiddenVisibleSelectors",
19 | 	"./serialize",
20 | 	"./ajax",
21 | 	"./ajax/xhr",
22 | 	"./ajax/script",
23 | 	"./ajax/jsonp",
24 | 	"./ajax/load",
25 | 	"./event/ajax",
26 | 	"./effects",
27 | 	"./effects/animatedSelector",
28 | 	"./offset",
29 | 	"./dimensions",
30 | 	"./deprecated",
31 | 	"./exports/amd",
32 | 	"./exports/global"
33 | ], function( jQuery ) {
34 | 
35 | return jQuery;
36 | 
37 | });
38 | 


--------------------------------------------------------------------------------
/attributes/support.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../var/support"
 3 | ], function( support ) {
 4 | 
 5 | (function() {
 6 | 	var input = document.createElement( "input" ),
 7 | 		select = document.createElement( "select" ),
 8 | 		opt = select.appendChild( document.createElement( "option" ) );
 9 | 
10 | 	input.type = "checkbox";
11 | 
12 | 	// Support: iOS<=5.1, Android<=4.2+
13 | 	// Default value for a checkbox should be "on"
14 | 	support.checkOn = input.value !== "";
15 | 
16 | 	// Support: IE<=11+
17 | 	// Must access selectedIndex to make default options select
18 | 	support.optSelected = opt.selected;
19 | 
20 | 	// Support: Android<=2.3
21 | 	// Options inside disabled selects are incorrectly marked as disabled
22 | 	select.disabled = true;
23 | 	support.optDisabled = !opt.disabled;
24 | 
25 | 	// Support: IE<=11+
26 | 	// An input loses its value after becoming a radio
27 | 	input = document.createElement( "input" );
28 | 	input.value = "t";
29 | 	input.type = "radio";
30 | 	support.radioValue = input.value === "t";
31 | })();
32 | 
33 | return support;
34 | 
35 | });
36 | 


--------------------------------------------------------------------------------
/exports/amd.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../core"
 3 | ], function( jQuery ) {
 4 | 
 5 | // Register as a named AMD module, since jQuery can be concatenated with other
 6 | // files that may use define, but not via a proper concatenation script that
 7 | // understands anonymous AMD modules. A named AMD is safest and most robust
 8 | // way to register. Lowercase jquery is used because AMD module names are
 9 | // derived from file names, and jQuery is normally delivered in a lowercase
10 | // file name. Do this after creating the global so that if an AMD module wants
11 | // to call noConflict to hide this version of jQuery, it will work.
12 | 
13 | // Note that for maximum portability, libraries that are not jQuery should
14 | // declare themselves as anonymous modules, and avoid setting a global if an
15 | // AMD loader is present. jQuery is a special case. For more information, see
16 | // https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
17 | 
18 | if ( typeof define === "function" && define.amd ) {
19 | 	define( "jquery", [], function() {
20 | 		return jQuery;
21 | 	});
22 | }
23 | 
24 | });
25 | 


--------------------------------------------------------------------------------
/manipulation/support.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../var/support"
 3 | ], function( support ) {
 4 | 
 5 | (function() {
 6 | 	var fragment = document.createDocumentFragment(),
 7 | 		div = fragment.appendChild( document.createElement( "div" ) ),
 8 | 		input = document.createElement( "input" );
 9 | 
10 | 	// Support: Safari<=5.1
11 | 	// Check state lost if the name is set (#11217)
12 | 	// Support: Windows Web Apps (WWA)
13 | 	// `name` and `type` must use .setAttribute for WWA (#14901)
14 | 	input.setAttribute( "type", "radio" );
15 | 	input.setAttribute( "checked", "checked" );
16 | 	input.setAttribute( "name", "t" );
17 | 
18 | 	div.appendChild( input );
19 | 
20 | 	// Support: Safari<=5.1, Android<4.2
21 | 	// Older WebKit doesn't clone checked state correctly in fragments
22 | 	support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
23 | 
24 | 	// Support: IE<=11+
25 | 	// Make sure textarea (and checkbox) defaultValue is properly cloned
26 | 	div.innerHTML = "<textarea>x</textarea>";
27 | 	support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
28 | })();
29 | 
30 | return support;
31 | 
32 | });
33 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 bailnl
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/event/alias.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../core",
 3 | 	"../event"
 4 | ], function( jQuery ) {
 5 | 
 6 | jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
 7 | 	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
 8 | 	"change select submit keydown keypress keyup error contextmenu").split(" "),
 9 | 	function( i, name ) {
10 | 
11 | 	// Handle event binding
12 | 	jQuery.fn[ name ] = function( data, fn ) {
13 | 		return arguments.length > 0 ?
14 | 			this.on( name, null, data, fn ) :
15 | 			this.trigger( name );
16 | 	};
17 | });
18 | 
19 | jQuery.fn.extend({
20 | 	hover: function( fnOver, fnOut ) {
21 | 		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
22 | 	},
23 | 
24 | 	bind: function( types, data, fn ) {
25 | 		return this.on( types, null, data, fn );
26 | 	},
27 | 	unbind: function( types, fn ) {
28 | 		return this.off( types, null, fn );
29 | 	},
30 | 
31 | 	delegate: function( selector, types, data, fn ) {
32 | 		return this.on( types, selector, data, fn );
33 | 	},
34 | 	undelegate: function( selector, types, fn ) {
35 | 		// ( namespace ) or ( selector, types [, fn] )
36 | 		return arguments.length === 1 ?
37 | 			this.off( selector, "**" ) :
38 | 			this.off( types, selector || "**", fn );
39 | 	}
40 | });
41 | 
42 | });
43 | 


--------------------------------------------------------------------------------
/ajax/script.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../core",
 3 | 	"../ajax"
 4 | ], function( jQuery ) {
 5 | 
 6 | // Install script dataType
 7 | jQuery.ajaxSetup({
 8 | 	accepts: {
 9 | 		script: "text/javascript, application/javascript, " +
10 | 			"application/ecmascript, application/x-ecmascript"
11 | 	},
12 | 	contents: {
13 | 		script: /(?:java|ecma)script/
14 | 	},
15 | 	converters: {
16 | 		"text script": function( text ) {
17 | 			jQuery.globalEval( text );
18 | 			return text;
19 | 		}
20 | 	}
21 | });
22 | 
23 | // Handle cache's special case and crossDomain
24 | jQuery.ajaxPrefilter( "script", function( s ) {
25 | 	if ( s.cache === undefined ) {
26 | 		s.cache = false;
27 | 	}
28 | 	if ( s.crossDomain ) {
29 | 		s.type = "GET";
30 | 	}
31 | });
32 | 
33 | // Bind script tag hack transport
34 | jQuery.ajaxTransport( "script", function( s ) {
35 | 	// This transport only deals with cross domain requests
36 | 	if ( s.crossDomain ) {
37 | 		var script, callback;
38 | 		return {
39 | 			send: function( _, complete ) {
40 | 				script = jQuery("<script>").prop({
41 | 					async: true,
42 | 					charset: s.scriptCharset,
43 | 					src: s.url
44 | 				}).on(
45 | 					"load error",
46 | 					callback = function( evt ) {
47 | 						script.remove();
48 | 						callback = null;
49 | 						if ( evt ) {
50 | 							complete( evt.type === "error" ? 404 : 200, evt.type );
51 | 						}
52 | 					}
53 | 				);
54 | 				document.head.appendChild( script[ 0 ] );
55 | 			},
56 | 			abort: function() {
57 | 				if ( callback ) {
58 | 					callback();
59 | 				}
60 | 			}
61 | 		};
62 | 	}
63 | });
64 | 
65 | });
66 | 


--------------------------------------------------------------------------------
/intro.js:
--------------------------------------------------------------------------------
 1 | /*!
 2 |  * jQuery JavaScript Library v@VERSION
 3 |  * http://jquery.com/
 4 |  *
 5 |  * Includes Sizzle.js
 6 |  * http://sizzlejs.com/
 7 |  *
 8 |  * Copyright 2005, 2014 jQuery Foundation, Inc. and other contributors
 9 |  * Released under the MIT license
10 |  * http://jquery.org/license
11 |  *
12 |  * Date: @DATE
13 |  */
14 | 
15 | (function( global, factory ) {
16 | 
17 | 	if ( typeof module === "object" && typeof module.exports === "object" ) {
18 | 		// For CommonJS and CommonJS-like environments where a proper `window`
19 | 		// is present, execute the factory and get jQuery.
20 | 		// For environments that do not have a `window` with a `document`
21 | 		// (such as Node.js), expose a factory as module.exports.
22 | 		// This accentuates the need for the creation of a real `window`.
23 | 		// e.g. var jQuery = require("jquery")(window);
24 | 		// See ticket #14549 for more info.
25 | 		module.exports = global.document ?
26 | 			factory( global, true ) :
27 | 			function( w ) {
28 | 				if ( !w.document ) {
29 | 					throw new Error( "jQuery requires a window with a document" );
30 | 				}
31 | 				return factory( w );
32 | 			};
33 | 	} else {
34 | 		factory( global );
35 | 	}
36 | 
37 | // Pass this if window is not defined yet
38 | }(typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
39 | 
40 | // Support: Firefox 18+
41 | // Can't be in strict mode, several libs including ASP.NET trace
42 | // the stack via arguments.caller.callee and Firefox dies if
43 | // you try to trace through "use strict" call chains. (#13335)
44 | //"use strict";
45 | 


--------------------------------------------------------------------------------
/core/parseHTML.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../core",
 3 | 	"./var/rsingleTag",
 4 | 	"../manipulation" // buildFragment
 5 | ], function( jQuery, rsingleTag ) {
 6 | 
 7 | // data: string of html
 8 | // data: html字符串
 9 | // context (optional): If specified, the fragment will be created in this context,
10 | // context (可选): 指定那么文档碎片创建的上下文
11 | // defaults to document
12 | // 默认为document
13 | // keepScripts (optional): If true, will include scripts passed in the html string
14 | // keepScripts (可选): 如果为真，html字符串将包含 script标签
15 | jQuery.parseHTML = function( data, context, keepScripts ) {
16 | 	// 如果data不存在或者 data不是string类型
17 | 	if ( !data || typeof data !== "string" ) {
18 | 		// 直接返回null
19 | 		return null;
20 | 	}
21 | 	// 如果 context 为boolean 那么就是 ( data, keepScripts ) 情况
22 | 	if ( typeof context === "boolean" ) {
23 | 		// 将 context 赋值给 keepScripts
24 | 		keepScripts = context;
25 | 		// context 赋值为 false
26 | 		context = false;
27 | 	}
28 | 	// context 为 false 时, context 默认 document
29 | 	context = context || document;
30 | 
31 | 	// 用正则 rsingleTag 匹配 data 判断是否为 简单的标签
32 | 	var parsed = rsingleTag.exec( data ),
33 | 		// 当 keepScripts 不为 true 时，用 [] 来存放 script标签
34 | 		scripts = !keepScripts && [];
35 | 
36 | 	// Single tag
37 | 	// 简单的标签
38 | 	if ( parsed ) {
39 | 		// 直接用createElement创建标签放进数组里并返回
40 | 		return [ context.createElement( parsed[1] ) ];
41 | 	}
42 | 
43 | 	// 处理复杂标签的情况
44 | 	parsed = jQuery.buildFragment( [ data ], context, scripts );
45 | 
46 | 	// 处理不需要script标签的情况
47 | 	if ( scripts && scripts.length ) {
48 | 		// 将 script 标签在 html中删除
49 | 		jQuery( scripts ).remove();
50 | 	}
51 | 
52 | 	//  返回dom元素数组
53 | 	return jQuery.merge( [], parsed.childNodes );
54 | };
55 | 
56 | return jQuery.parseHTML;
57 | 
58 | });
59 | 


--------------------------------------------------------------------------------
/css/curCSS.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../core",
 3 | 	"./var/rnumnonpx",
 4 | 	"./var/rmargin",
 5 | 	"./var/getStyles",
 6 | 	"../selector" // contains
 7 | ], function( jQuery, rnumnonpx, rmargin, getStyles ) {
 8 | 
 9 | function curCSS( elem, name, computed ) {
10 | 	var width, minWidth, maxWidth, ret,
11 | 		style = elem.style;
12 | 
13 | 	computed = computed || getStyles( elem );
14 | 
15 | 	// Support: IE9
16 | 	// getPropertyValue is only needed for .css('filter') (#12537)
17 | 	if ( computed ) {
18 | 		ret = computed.getPropertyValue( name ) || computed[ name ];
19 | 	}
20 | 
21 | 	if ( computed ) {
22 | 
23 | 		if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) {
24 | 			ret = jQuery.style( elem, name );
25 | 		}
26 | 
27 | 		// Support: iOS < 6
28 | 		// A tribute to the "awesome hack by Dean Edwards"
29 | 		// iOS < 6 (at least) returns percentage for a larger set of values,
30 | 		// but width seems to be reliably pixels
31 | 		// this is against the CSSOM draft spec:
32 | 		// http://dev.w3.org/csswg/cssom/#resolved-values
33 | 		if ( rnumnonpx.test( ret ) && rmargin.test( name ) ) {
34 | 
35 | 			// Remember the original values
36 | 			width = style.width;
37 | 			minWidth = style.minWidth;
38 | 			maxWidth = style.maxWidth;
39 | 
40 | 			// Put in the new values to get a computed value out
41 | 			style.minWidth = style.maxWidth = style.width = ret;
42 | 			ret = computed.width;
43 | 
44 | 			// Revert the changed values
45 | 			style.width = width;
46 | 			style.minWidth = minWidth;
47 | 			style.maxWidth = maxWidth;
48 | 		}
49 | 	}
50 | 
51 | 	return ret !== undefined ?
52 | 		// Support: IE
53 | 		// IE returns zIndex value as an integer.
54 | 		ret + "" :
55 | 		ret;
56 | }
57 | 
58 | return curCSS;
59 | });
60 | 


--------------------------------------------------------------------------------
/wrap.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"./core",
 3 | 	"./core/init",
 4 | 	"./manipulation", // clone
 5 | 	"./traversing" // parent, contents
 6 | ], function( jQuery ) {
 7 | 
 8 | jQuery.fn.extend({
 9 | 	wrapAll: function( html ) {
10 | 		var wrap;
11 | 
12 | 		if ( jQuery.isFunction( html ) ) {
13 | 			return this.each(function( i ) {
14 | 				jQuery( this ).wrapAll( html.call(this, i) );
15 | 			});
16 | 		}
17 | 
18 | 		if ( this[ 0 ] ) {
19 | 
20 | 			// The elements to wrap the target around
21 | 			wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
22 | 
23 | 			if ( this[ 0 ].parentNode ) {
24 | 				wrap.insertBefore( this[ 0 ] );
25 | 			}
26 | 
27 | 			wrap.map(function() {
28 | 				var elem = this;
29 | 
30 | 				while ( elem.firstElementChild ) {
31 | 					elem = elem.firstElementChild;
32 | 				}
33 | 
34 | 				return elem;
35 | 			}).append( this );
36 | 		}
37 | 
38 | 		return this;
39 | 	},
40 | 
41 | 	wrapInner: function( html ) {
42 | 		if ( jQuery.isFunction( html ) ) {
43 | 			return this.each(function( i ) {
44 | 				jQuery( this ).wrapInner( html.call(this, i) );
45 | 			});
46 | 		}
47 | 
48 | 		return this.each(function() {
49 | 			var self = jQuery( this ),
50 | 				contents = self.contents();
51 | 
52 | 			if ( contents.length ) {
53 | 				contents.wrapAll( html );
54 | 
55 | 			} else {
56 | 				self.append( html );
57 | 			}
58 | 		});
59 | 	},
60 | 
61 | 	wrap: function( html ) {
62 | 		var isFunction = jQuery.isFunction( html );
63 | 
64 | 		return this.each(function( i ) {
65 | 			jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html );
66 | 		});
67 | 	},
68 | 
69 | 	unwrap: function() {
70 | 		return this.parent().each(function() {
71 | 			if ( !jQuery.nodeName( this, "body" ) ) {
72 | 				jQuery( this ).replaceWith( this.childNodes );
73 | 			}
74 | 		}).end();
75 | 	}
76 | });
77 | 
78 | return jQuery;
79 | });
80 | 


--------------------------------------------------------------------------------
/css/defaultDisplay.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../core",
 3 | 	"../manipulation" // appendTo
 4 | ], function( jQuery ) {
 5 | 
 6 | var iframe,
 7 | 	elemdisplay = {
 8 | 
 9 | 		// Support: Firefox
10 | 		// We have to pre-define these values for FF (#10227)
11 | 		HTML: "block",
12 | 		BODY: "block"
13 | 	};
14 | 
15 | /**
16 |  * Retrieve the actual display of a element
17 |  * @param {String} name nodeName of the element
18 |  * @param {Object} doc Document object
19 |  */
20 | // Called only from within defaultDisplay
21 | function actualDisplay( name, doc ) {
22 | 	var elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),
23 | 
24 | 		display = jQuery.css( elem[ 0 ], "display" );
25 | 
26 | 	// We don't have any data stored on the element,
27 | 	// so use "detach" method as fast way to get rid of the element
28 | 	elem.detach();
29 | 
30 | 	return display;
31 | }
32 | 
33 | /**
34 |  * Try to determine the default display value of an element
35 |  * @param {String} nodeName
36 |  */
37 | function defaultDisplay( nodeName ) {
38 | 	var doc = document,
39 | 		display = elemdisplay[ nodeName ];
40 | 
41 | 	if ( !display ) {
42 | 		display = actualDisplay( nodeName, doc );
43 | 
44 | 		// If the simple way fails, read from inside an iframe
45 | 		if ( display === "none" || !display ) {
46 | 
47 | 			// Use the already-created iframe if possible
48 | 			iframe = (iframe || jQuery( "<iframe frameborder='0' width='0' height='0'/>" ))
49 | 				.appendTo( doc.documentElement );
50 | 
51 | 			// Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
52 | 			doc = ( iframe[ 0 ].contentWindow || iframe[ 0 ].contentDocument ).document;
53 | 
54 | 			// Support: IE
55 | 			doc.write();
56 | 			doc.close();
57 | 
58 | 			display = actualDisplay( nodeName, doc );
59 | 			iframe.detach();
60 | 		}
61 | 
62 | 		// Store the correct default display
63 | 		elemdisplay[ nodeName ] = display;
64 | 	}
65 | 
66 | 	return display;
67 | }
68 | 
69 | return defaultDisplay;
70 | });
71 | 


--------------------------------------------------------------------------------
/dimensions.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"./core",
 3 | 	"./core/access",
 4 | 	"./css"
 5 | ], function( jQuery, access ) {
 6 | 
 7 | // Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
 8 | jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
 9 | 	jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name },
10 | 		function( defaultExtra, funcName ) {
11 | 
12 | 		// Margin is only for outerHeight, outerWidth
13 | 		jQuery.fn[ funcName ] = function( margin, value ) {
14 | 			var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
15 | 				extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
16 | 
17 | 			return access( this, function( elem, type, value ) {
18 | 				var doc;
19 | 
20 | 				if ( jQuery.isWindow( elem ) ) {
21 | 					// As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
22 | 					// isn't a whole lot we can do. See pull request at this URL for discussion:
23 | 					// https://github.com/jquery/jquery/pull/764
24 | 					return elem.document.documentElement[ "client" + name ];
25 | 				}
26 | 
27 | 				// Get document width or height
28 | 				if ( elem.nodeType === 9 ) {
29 | 					doc = elem.documentElement;
30 | 
31 | 					// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
32 | 					// whichever is greatest
33 | 					return Math.max(
34 | 						elem.body[ "scroll" + name ], doc[ "scroll" + name ],
35 | 						elem.body[ "offset" + name ], doc[ "offset" + name ],
36 | 						doc[ "client" + name ]
37 | 					);
38 | 				}
39 | 
40 | 				return value === undefined ?
41 | 					// Get width or height on the element, requesting but not forcing parseFloat
42 | 					jQuery.css( elem, type, extra ) :
43 | 
44 | 					// Set width or height on the element
45 | 					jQuery.style( elem, type, value, extra );
46 | 			}, type, chainable ? margin : undefined, chainable, null );
47 | 		};
48 | 	});
49 | });
50 | 
51 | return jQuery;
52 | });
53 | 


--------------------------------------------------------------------------------
/ajax/load.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../core",
 3 | 	"../core/parseHTML",
 4 | 	"../ajax",
 5 | 	"../traversing",
 6 | 	"../manipulation",
 7 | 	"../selector",
 8 | 	// Optional event/alias dependency
 9 | 	"../event/alias"
10 | ], function( jQuery ) {
11 | 
12 | // Keep a copy of the old load method
13 | var _load = jQuery.fn.load;
14 | 
15 | /**
16 |  * Load a url into a page
17 |  */
18 | jQuery.fn.load = function( url, params, callback ) {
19 | 	if ( typeof url !== "string" && _load ) {
20 | 		return _load.apply( this, arguments );
21 | 	}
22 | 
23 | 	var selector, type, response,
24 | 		self = this,
25 | 		off = url.indexOf(" ");
26 | 
27 | 	if ( off >= 0 ) {
28 | 		selector = jQuery.trim( url.slice( off ) );
29 | 		url = url.slice( 0, off );
30 | 	}
31 | 
32 | 	// If it's a function
33 | 	if ( jQuery.isFunction( params ) ) {
34 | 
35 | 		// We assume that it's the callback
36 | 		callback = params;
37 | 		params = undefined;
38 | 
39 | 	// Otherwise, build a param string
40 | 	} else if ( params && typeof params === "object" ) {
41 | 		type = "POST";
42 | 	}
43 | 
44 | 	// If we have elements to modify, make the request
45 | 	if ( self.length > 0 ) {
46 | 		jQuery.ajax({
47 | 			url: url,
48 | 
49 | 			// if "type" variable is undefined, then "GET" method will be used
50 | 			type: type,
51 | 			dataType: "html",
52 | 			data: params
53 | 		}).done(function( responseText ) {
54 | 
55 | 			// Save response for use in complete callback
56 | 			response = arguments;
57 | 
58 | 			self.html( selector ?
59 | 
60 | 				// If a selector was specified, locate the right elements in a dummy div
61 | 				// Exclude scripts to avoid IE 'Permission Denied' errors
62 | 				jQuery("<div>").append( jQuery.parseHTML( responseText ) ).find( selector ) :
63 | 
64 | 				// Otherwise use the full result
65 | 				responseText );
66 | 
67 | 		}).complete( callback && function( jqXHR, status ) {
68 | 			self.each( callback, response || [ jqXHR.responseText, status, jqXHR ] );
69 | 		});
70 | 	}
71 | 
72 | 	return this;
73 | };
74 | 
75 | });
76 | 


--------------------------------------------------------------------------------
/attributes/prop.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../core",
 3 | 	"../core/access",
 4 | 	"./support"
 5 | ], function( jQuery, access, support ) {
 6 | 
 7 | var rfocusable = /^(?:input|select|textarea|button)$/i;
 8 | 
 9 | jQuery.fn.extend({
10 | 	prop: function( name, value ) {
11 | 		return access( this, jQuery.prop, name, value, arguments.length > 1 );
12 | 	},
13 | 
14 | 	removeProp: function( name ) {
15 | 		return this.each(function() {
16 | 			delete this[ jQuery.propFix[ name ] || name ];
17 | 		});
18 | 	}
19 | });
20 | 
21 | jQuery.extend({
22 | 	propFix: {
23 | 		"for": "htmlFor",
24 | 		"class": "className"
25 | 	},
26 | 
27 | 	prop: function( elem, name, value ) {
28 | 		var ret, hooks, notxml,
29 | 			nType = elem.nodeType;
30 | 
31 | 		// Don't get/set properties on text, comment and attribute nodes
32 | 		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
33 | 			return;
34 | 		}
35 | 
36 | 		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
37 | 
38 | 		if ( notxml ) {
39 | 			// Fix name and attach hooks
40 | 			name = jQuery.propFix[ name ] || name;
41 | 			hooks = jQuery.propHooks[ name ];
42 | 		}
43 | 
44 | 		if ( value !== undefined ) {
45 | 			return hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ?
46 | 				ret :
47 | 				( elem[ name ] = value );
48 | 
49 | 		} else {
50 | 			return hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ?
51 | 				ret :
52 | 				elem[ name ];
53 | 		}
54 | 	},
55 | 
56 | 	propHooks: {
57 | 		tabIndex: {
58 | 			get: function( elem ) {
59 | 				return elem.hasAttribute( "tabindex" ) ||
60 | 					rfocusable.test( elem.nodeName ) || elem.href ?
61 | 						elem.tabIndex :
62 | 						-1;
63 | 			}
64 | 		}
65 | 	}
66 | });
67 | 
68 | if ( !support.optSelected ) {
69 | 	jQuery.propHooks.selected = {
70 | 		get: function( elem ) {
71 | 			var parent = elem.parentNode;
72 | 			if ( parent && parent.parentNode ) {
73 | 				parent.parentNode.selectedIndex;
74 | 			}
75 | 			return null;
76 | 		}
77 | 	};
78 | }
79 | 
80 | jQuery.each([
81 | 	"tabIndex",
82 | 	"readOnly",
83 | 	"maxLength",
84 | 	"cellSpacing",
85 | 	"cellPadding",
86 | 	"rowSpan",
87 | 	"colSpan",
88 | 	"useMap",
89 | 	"frameBorder",
90 | 	"contentEditable"
91 | ], function() {
92 | 	jQuery.propFix[ this.toLowerCase() ] = this;
93 | });
94 | 
95 | });
96 | 


--------------------------------------------------------------------------------
/ajax/jsonp.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../core",
 3 | 	"./var/nonce",
 4 | 	"./var/rquery",
 5 | 	"../ajax"
 6 | ], function( jQuery, nonce, rquery ) {
 7 | 
 8 | var oldCallbacks = [],
 9 | 	rjsonp = /(=)\?(?=&|$)|\?\?/;
10 | 
11 | // Default jsonp settings
12 | jQuery.ajaxSetup({
13 | 	jsonp: "callback",
14 | 	jsonpCallback: function() {
15 | 		var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
16 | 		this[ callback ] = true;
17 | 		return callback;
18 | 	}
19 | });
20 | 
21 | // Detect, normalize options and install callbacks for jsonp requests
22 | jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
23 | 
24 | 	var callbackName, overwritten, responseContainer,
25 | 		jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
26 | 			"url" :
27 | 			typeof s.data === "string" &&
28 | 				!( s.contentType || "" ).indexOf("application/x-www-form-urlencoded") &&
29 | 				rjsonp.test( s.data ) && "data"
30 | 		);
31 | 
32 | 	// Handle iff the expected data type is "jsonp" or we have a parameter to set
33 | 	if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
34 | 
35 | 		// Get callback name, remembering preexisting value associated with it
36 | 		callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
37 | 			s.jsonpCallback() :
38 | 			s.jsonpCallback;
39 | 
40 | 		// Insert callback into url or form data
41 | 		if ( jsonProp ) {
42 | 			s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
43 | 		} else if ( s.jsonp !== false ) {
44 | 			s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
45 | 		}
46 | 
47 | 		// Use data converter to retrieve json after script execution
48 | 		s.converters["script json"] = function() {
49 | 			if ( !responseContainer ) {
50 | 				jQuery.error( callbackName + " was not called" );
51 | 			}
52 | 			return responseContainer[ 0 ];
53 | 		};
54 | 
55 | 		// force json dataType
56 | 		s.dataTypes[ 0 ] = "json";
57 | 
58 | 		// Install callback
59 | 		overwritten = window[ callbackName ];
60 | 		window[ callbackName ] = function() {
61 | 			responseContainer = arguments;
62 | 		};
63 | 
64 | 		// Clean-up function (fires after converters)
65 | 		jqXHR.always(function() {
66 | 			// Restore preexisting value
67 | 			window[ callbackName ] = overwritten;
68 | 
69 | 			// Save back as free
70 | 			if ( s[ callbackName ] ) {
71 | 				// make sure that re-using the options doesn't screw things around
72 | 				s.jsonpCallback = originalSettings.jsonpCallback;
73 | 
74 | 				// save the callback name for future use
75 | 				oldCallbacks.push( callbackName );
76 | 			}
77 | 
78 | 			// Call if it was a function and we have a response
79 | 			if ( responseContainer && jQuery.isFunction( overwritten ) ) {
80 | 				overwritten( responseContainer[ 0 ] );
81 | 			}
82 | 
83 | 			responseContainer = overwritten = undefined;
84 | 		});
85 | 
86 | 		// Delegate to script
87 | 		return "script";
88 | 	}
89 | });
90 | 
91 | });
92 | 


--------------------------------------------------------------------------------
/traversing/findFilter.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"../core",
  3 | 	"../var/indexOf",
  4 | 	"./var/rneedsContext",
  5 | 	"../selector"
  6 | ], function( jQuery, indexOf, rneedsContext ) {
  7 | 
  8 | var risSimple = /^.[^:#\[\.,]*$/;
  9 | 
 10 | // Implement the identical functionality for filter and not
 11 | function winnow( elements, qualifier, not ) {
 12 | 	if ( jQuery.isFunction( qualifier ) ) {
 13 | 		return jQuery.grep( elements, function( elem, i ) {
 14 | 			/* jshint -W018 */
 15 | 			return !!qualifier.call( elem, i, elem ) !== not;
 16 | 		});
 17 | 
 18 | 	}
 19 | 
 20 | 	if ( qualifier.nodeType ) {
 21 | 		return jQuery.grep( elements, function( elem ) {
 22 | 			return ( elem === qualifier ) !== not;
 23 | 		});
 24 | 
 25 | 	}
 26 | 
 27 | 	if ( typeof qualifier === "string" ) {
 28 | 		if ( risSimple.test( qualifier ) ) {
 29 | 			return jQuery.filter( qualifier, elements, not );
 30 | 		}
 31 | 
 32 | 		qualifier = jQuery.filter( qualifier, elements );
 33 | 	}
 34 | 
 35 | 	return jQuery.grep( elements, function( elem ) {
 36 | 		return ( indexOf.call( qualifier, elem ) >= 0 ) !== not;
 37 | 	});
 38 | }
 39 | 
 40 | jQuery.filter = function( expr, elems, not ) {
 41 | 	var elem = elems[ 0 ];
 42 | 
 43 | 	if ( not ) {
 44 | 		expr = ":not(" + expr + ")";
 45 | 	}
 46 | 
 47 | 	return elems.length === 1 && elem.nodeType === 1 ?
 48 | 		jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :
 49 | 		jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
 50 | 			return elem.nodeType === 1;
 51 | 		}));
 52 | };
 53 | 
 54 | jQuery.fn.extend({
 55 | 	find: function( selector ) {
 56 | 		var i,
 57 | 			len = this.length,
 58 | 			ret = [],
 59 | 			self = this;
 60 | 
 61 | 		if ( typeof selector !== "string" ) {
 62 | 			return this.pushStack( jQuery( selector ).filter(function() {
 63 | 				for ( i = 0; i < len; i++ ) {
 64 | 					if ( jQuery.contains( self[ i ], this ) ) {
 65 | 						return true;
 66 | 					}
 67 | 				}
 68 | 			}) );
 69 | 		}
 70 | 
 71 | 		for ( i = 0; i < len; i++ ) {
 72 | 			jQuery.find( selector, self[ i ], ret );
 73 | 		}
 74 | 
 75 | 		// Needed because $( selector, context ) becomes $( context ).find( selector )
 76 | 		ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret );
 77 | 		ret.selector = this.selector ? this.selector + " " + selector : selector;
 78 | 		return ret;
 79 | 	},
 80 | 	filter: function( selector ) {
 81 | 		return this.pushStack( winnow(this, selector || [], false) );
 82 | 	},
 83 | 	not: function( selector ) {
 84 | 		return this.pushStack( winnow(this, selector || [], true) );
 85 | 	},
 86 | 	is: function( selector ) {
 87 | 		return !!winnow(
 88 | 			this,
 89 | 
 90 | 			// If this is a positional/relative selector, check membership in the returned set
 91 | 			// so $("p:first").is("p:last") won't return true for a doc with two "p".
 92 | 			typeof selector === "string" && rneedsContext.test( selector ) ?
 93 | 				jQuery( selector ) :
 94 | 				selector || [],
 95 | 			false
 96 | 		).length;
 97 | 	}
 98 | });
 99 | 
100 | });
101 | 


--------------------------------------------------------------------------------
/core/access.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"../core"
  3 | ], function( jQuery ) {
  4 | 
  5 | // Multifunctional method to get and set values of a collection
  6 | // The value/s can optionally be executed if it's a function
  7 | // 多功能的方法来获取和设置值的集合
  8 | // 如果 value 是一个执行的函数 (可选)
  9 | 
 10 | // elems 元素
 11 | // fn 功能处理函数  比如 jQuery.attr jQuery.prop
 12 | // key 键
 13 | // value 值
 14 | // chainable 链式操作
 15 | // emptyGet  没有选中到元素的返回值
 16 | // raw 标识 value 是否为原始数据，如果raw是true，说明 value 是原始数据，如果是false，说明 value 是个函数
 17 | var access = jQuery.access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
 18 | 	var i = 0,
 19 | 		len = elems.length,
 20 |         // key 是否为空
 21 | 		bulk = key == null;
 22 | 
 23 | 	// Sets many values
 24 | 	// 设置多个值
 25 |     // 如果 key 是对象
 26 | 	if ( jQuery.type( key ) === "object" ) {
 27 |         // 可链式操作
 28 | 		chainable = true;
 29 |         // 迭代对象
 30 | 		for ( i in key ) {
 31 |             // 递归调用jQuery.access 设置值
 32 | 			access( elems, fn, i, key[i], true, emptyGet, raw );
 33 | 		}
 34 | 
 35 | 	// Sets one value
 36 |     // 设置 单个值
 37 |     // value 不为空
 38 |     // 是一个设置的操作
 39 | 	}
 40 |     else if ( value !== undefined ) {
 41 |         // 可链式操作
 42 | 		chainable = true;
 43 | 
 44 |         // 如果 value 不是函数
 45 | 		if ( !jQuery.isFunction( value ) ) {
 46 |             // 那么 value 就是原始数据
 47 | 			raw = true;
 48 | 		}
 49 | 
 50 |         // bulk为true，那么 key的为 空
 51 |         // 如果key为空的处理
 52 | 		if ( bulk ) {
 53 | 			// Bulk operations run against the entire set
 54 |             // 如果 value 不是函数 或者 强制 raw 为 true
 55 |             // 说明 value 是原始数据
 56 |             // $('body').attr(null,{ a:1, b:2 })
 57 |             // data.js 走这里
 58 |             if ( raw ) {
 59 |                 // 改变处理函数fn并把 value传入
 60 | 				fn.call( elems, value );
 61 |                 // 注销掉 fn
 62 | 				fn = null;
 63 | 
 64 | 			// ...except when executing function values
 65 |             // 如果 value 是一个函数
 66 | 			} else {
 67 |                 // 保存一下处理函数
 68 | 				bulk = fn;
 69 | 				fn = function( elem, key, value ) {
 70 |                     // 改变一下上下文
 71 | 					return bulk.call( jQuery( elem ), value );
 72 | 				};
 73 | 			}
 74 | 		}
 75 | 
 76 |         // 如果 fn 存在，调用每一个元素
 77 |         // data.js 不走这里
 78 | 		if ( fn ) {
 79 | 			for ( ; i < len; i++ ) {
 80 | 				fn( elems[i], key,
 81 |                     // value 是否为 原始值
 82 |                     raw ?
 83 |                         // 如果是 直接传入 原始值
 84 |                         value :
 85 |                         // 否则为每个元素调用 value 函数
 86 |                         // 例如 $('body').attr('a',function(i,v){ })
 87 |                         // 但是 会先调用 jQuery.attr( elems[i], key ) 返回 value 并传入 回调
 88 |                         value.call( elems[i], i, fn( elems[i], key ) )
 89 |                 );
 90 | 			}
 91 | 		}
 92 | 	}
 93 | 
 94 |     // 如果 chainable 为 true，那么就是set操作
 95 | 	return chainable ?
 96 |         // 返回元素为后续的链式操作
 97 | 		elems :
 98 | 		// Gets
 99 |         // 获取操作
100 | 		bulk ?
101 |             // 如果 bulk 为true ，改成 处理函数fn 的上下文
102 | 			fn.call( elems ) :
103 |             // 否则根据元素的长度做操作
104 | 			len ?
105 |                 // 当 elems 的长度 大于 0 时，获取第一个元素
106 |                 fn( elems[0], key ) :
107 |                 // 否则返回 emptyGet (没有元素的返回值)
108 |                 emptyGet;
109 | };
110 | 
111 | return access;
112 | 
113 | });
114 | 


--------------------------------------------------------------------------------
/css/support.js:
--------------------------------------------------------------------------------
 1 | define([
 2 | 	"../core",
 3 | 	"../var/support"
 4 | ], function( jQuery, support ) {
 5 | 
 6 | (function() {
 7 | 	var pixelPositionVal, boxSizingReliableVal,
 8 | 		docElem = document.documentElement,
 9 | 		container = document.createElement( "div" ),
10 | 		div = document.createElement( "div" );
11 | 
12 | 	if ( !div.style ) {
13 | 		return;
14 | 	}
15 | 
16 | 	// Support: IE9-11+
17 | 	// Style of cloned element affects source element cloned (#8908)
18 | 	div.style.backgroundClip = "content-box";
19 | 	div.cloneNode( true ).style.backgroundClip = "";
20 | 	support.clearCloneStyle = div.style.backgroundClip === "content-box";
21 | 
22 | 	container.style.cssText = "border:0;width:0;height:0;top:0;left:-9999px;margin-top:1px;" +
23 | 		"position:absolute";
24 | 	container.appendChild( div );
25 | 
26 | 	// Executing both pixelPosition & boxSizingReliable tests require only one layout
27 | 	// so they're executed at the same time to save the second computation.
28 | 	function computePixelPositionAndBoxSizingReliable() {
29 | 		div.style.cssText =
30 | 			// Support: Firefox<29, Android 2.3
31 | 			// Vendor-prefix box-sizing
32 | 			"-webkit-box-sizing:border-box;-moz-box-sizing:border-box;" +
33 | 			"box-sizing:border-box;display:block;margin-top:1%;top:1%;" +
34 | 			"border:1px;padding:1px;width:4px;position:absolute";
35 | 		div.innerHTML = "";
36 | 		docElem.appendChild( container );
37 | 
38 | 		var divStyle = window.getComputedStyle( div, null );
39 | 		pixelPositionVal = divStyle.top !== "1%";
40 | 		boxSizingReliableVal = divStyle.width === "4px";
41 | 
42 | 		docElem.removeChild( container );
43 | 	}
44 | 
45 | 	// Support: node.js jsdom
46 | 	// Don't assume that getComputedStyle is a property of the global object
47 | 	if ( window.getComputedStyle ) {
48 | 		jQuery.extend( support, {
49 | 			pixelPosition: function() {
50 | 
51 | 				// This test is executed only once but we still do memoizing
52 | 				// since we can use the boxSizingReliable pre-computing.
53 | 				// No need to check if the test was already performed, though.
54 | 				computePixelPositionAndBoxSizingReliable();
55 | 				return pixelPositionVal;
56 | 			},
57 | 			boxSizingReliable: function() {
58 | 				if ( boxSizingReliableVal == null ) {
59 | 					computePixelPositionAndBoxSizingReliable();
60 | 				}
61 | 				return boxSizingReliableVal;
62 | 			},
63 | 			reliableMarginRight: function() {
64 | 
65 | 				// Support: Android 2.3
66 | 				// Check if div with explicit width and no margin-right incorrectly
67 | 				// gets computed margin-right based on width of container. (#3333)
68 | 				// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
69 | 				// This support function is only executed once so no memoizing is needed.
70 | 				var ret,
71 | 					marginDiv = div.appendChild( document.createElement( "div" ) );
72 | 
73 | 				// Reset CSS: box-sizing; display; margin; border; padding
74 | 				marginDiv.style.cssText = div.style.cssText =
75 | 					// Support: Firefox<29, Android 2.3
76 | 					// Vendor-prefix box-sizing
77 | 					"-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" +
78 | 					"box-sizing:content-box;display:block;margin:0;border:0;padding:0";
79 | 				marginDiv.style.marginRight = marginDiv.style.width = "0";
80 | 				div.style.width = "1px";
81 | 				docElem.appendChild( container );
82 | 
83 | 				ret = !parseFloat( window.getComputedStyle( marginDiv, null ).marginRight );
84 | 
85 | 				docElem.removeChild( container );
86 | 
87 | 				return ret;
88 | 			}
89 | 		});
90 | 	}
91 | })();
92 | 
93 | return support;
94 | 
95 | });
96 | 


--------------------------------------------------------------------------------
/effects/Tween.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"../core",
  3 | 	"../css"
  4 | ], function( jQuery ) {
  5 | 
  6 | function Tween( elem, options, prop, end, easing ) {
  7 | 	return new Tween.prototype.init( elem, options, prop, end, easing );
  8 | }
  9 | jQuery.Tween = Tween;
 10 | 
 11 | Tween.prototype = {
 12 | 	constructor: Tween,
 13 | 	init: function( elem, options, prop, end, easing, unit ) {
 14 | 		this.elem = elem;
 15 | 		this.prop = prop;
 16 | 		this.easing = easing || "swing";
 17 | 		this.options = options;
 18 | 		this.start = this.now = this.cur();
 19 | 		this.end = end;
 20 | 		this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
 21 | 	},
 22 | 	cur: function() {
 23 | 		var hooks = Tween.propHooks[ this.prop ];
 24 | 
 25 | 		return hooks && hooks.get ?
 26 | 			hooks.get( this ) :
 27 | 			Tween.propHooks._default.get( this );
 28 | 	},
 29 | 	run: function( percent ) {
 30 | 		var eased,
 31 | 			hooks = Tween.propHooks[ this.prop ];
 32 | 
 33 | 		if ( this.options.duration ) {
 34 | 			this.pos = eased = jQuery.easing[ this.easing ](
 35 | 				percent, this.options.duration * percent, 0, 1, this.options.duration
 36 | 			);
 37 | 		} else {
 38 | 			this.pos = eased = percent;
 39 | 		}
 40 | 		this.now = ( this.end - this.start ) * eased + this.start;
 41 | 
 42 | 		if ( this.options.step ) {
 43 | 			this.options.step.call( this.elem, this.now, this );
 44 | 		}
 45 | 
 46 | 		if ( hooks && hooks.set ) {
 47 | 			hooks.set( this );
 48 | 		} else {
 49 | 			Tween.propHooks._default.set( this );
 50 | 		}
 51 | 		return this;
 52 | 	}
 53 | };
 54 | 
 55 | Tween.prototype.init.prototype = Tween.prototype;
 56 | 
 57 | Tween.propHooks = {
 58 | 	_default: {
 59 | 		get: function( tween ) {
 60 | 			var result;
 61 | 
 62 | 			if ( tween.elem[ tween.prop ] != null &&
 63 | 				(!tween.elem.style || tween.elem.style[ tween.prop ] == null) ) {
 64 | 				return tween.elem[ tween.prop ];
 65 | 			}
 66 | 
 67 | 			// Passing an empty string as a 3rd parameter to .css will automatically
 68 | 			// attempt a parseFloat and fallback to a string if the parse fails.
 69 | 			// Simple values such as "10px" are parsed to Float;
 70 | 			// complex values such as "rotate(1rad)" are returned as-is.
 71 | 			result = jQuery.css( tween.elem, tween.prop, "" );
 72 | 			// Empty strings, null, undefined and "auto" are converted to 0.
 73 | 			return !result || result === "auto" ? 0 : result;
 74 | 		},
 75 | 		set: function( tween ) {
 76 | 			// Use step hook for back compat.
 77 | 			// Use cssHook if its there.
 78 | 			// Use .style if available and use plain properties where available.
 79 | 			if ( jQuery.fx.step[ tween.prop ] ) {
 80 | 				jQuery.fx.step[ tween.prop ]( tween );
 81 | 			} else if ( tween.elem.style &&
 82 | 				( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||
 83 | 					jQuery.cssHooks[ tween.prop ] ) ) {
 84 | 				jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
 85 | 			} else {
 86 | 				tween.elem[ tween.prop ] = tween.now;
 87 | 			}
 88 | 		}
 89 | 	}
 90 | };
 91 | 
 92 | // Support: IE9
 93 | // Panic based approach to setting things on disconnected nodes
 94 | Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
 95 | 	set: function( tween ) {
 96 | 		if ( tween.elem.nodeType && tween.elem.parentNode ) {
 97 | 			tween.elem[ tween.prop ] = tween.now;
 98 | 		}
 99 | 	}
100 | };
101 | 
102 | jQuery.easing = {
103 | 	linear: function( p ) {
104 | 		return p;
105 | 	},
106 | 	swing: function( p ) {
107 | 		return 0.5 - Math.cos( p * Math.PI ) / 2;
108 | 	}
109 | };
110 | 
111 | jQuery.fx = Tween.prototype.init;
112 | 
113 | // Back Compat <1.8 extension point
114 | jQuery.fx.step = {};
115 | 
116 | });
117 | 


--------------------------------------------------------------------------------
/queue.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"./core",
  3 | 	"./data/var/dataPriv",
  4 | 	"./deferred",
  5 | 	"./callbacks"
  6 | ], function( jQuery, dataPriv ) {
  7 | 
  8 | jQuery.extend({
  9 | 	queue: function( elem, type, data ) {
 10 | 		var queue;
 11 | 
 12 | 		if ( elem ) {
 13 | 			type = ( type || "fx" ) + "queue";
 14 | 			queue = dataPriv.get( elem, type );
 15 | 
 16 | 			// Speed up dequeue by getting out quickly if this is just a lookup
 17 | 			if ( data ) {
 18 | 				if ( !queue || jQuery.isArray( data ) ) {
 19 | 					queue = dataPriv.access( elem, type, jQuery.makeArray(data) );
 20 | 				} else {
 21 | 					queue.push( data );
 22 | 				}
 23 | 			}
 24 | 			return queue || [];
 25 | 		}
 26 | 	},
 27 | 
 28 | 	dequeue: function( elem, type ) {
 29 | 		type = type || "fx";
 30 | 
 31 | 		var queue = jQuery.queue( elem, type ),
 32 | 			startLength = queue.length,
 33 | 			fn = queue.shift(),
 34 | 			hooks = jQuery._queueHooks( elem, type ),
 35 | 			next = function() {
 36 | 				jQuery.dequeue( elem, type );
 37 | 			};
 38 | 
 39 | 		// If the fx queue is dequeued, always remove the progress sentinel
 40 | 		if ( fn === "inprogress" ) {
 41 | 			fn = queue.shift();
 42 | 			startLength--;
 43 | 		}
 44 | 
 45 | 		if ( fn ) {
 46 | 
 47 | 			// Add a progress sentinel to prevent the fx queue from being
 48 | 			// automatically dequeued
 49 | 			if ( type === "fx" ) {
 50 | 				queue.unshift( "inprogress" );
 51 | 			}
 52 | 
 53 | 			// Clear up the last queue stop function
 54 | 			delete hooks.stop;
 55 | 			fn.call( elem, next, hooks );
 56 | 		}
 57 | 
 58 | 		if ( !startLength && hooks ) {
 59 | 			hooks.empty.fire();
 60 | 		}
 61 | 	},
 62 | 
 63 | 	// Not public - generate a queueHooks object, or return the current one
 64 | 	_queueHooks: function( elem, type ) {
 65 | 		var key = type + "queueHooks";
 66 | 		return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
 67 | 			empty: jQuery.Callbacks("once memory").add(function() {
 68 | 				dataPriv.remove( elem, [ type + "queue", key ] );
 69 | 			})
 70 | 		});
 71 | 	}
 72 | });
 73 | 
 74 | jQuery.fn.extend({
 75 | 	queue: function( type, data ) {
 76 | 		var setter = 2;
 77 | 
 78 | 		if ( typeof type !== "string" ) {
 79 | 			data = type;
 80 | 			type = "fx";
 81 | 			setter--;
 82 | 		}
 83 | 
 84 | 		if ( arguments.length < setter ) {
 85 | 			return jQuery.queue( this[0], type );
 86 | 		}
 87 | 
 88 | 		return data === undefined ?
 89 | 			this :
 90 | 			this.each(function() {
 91 | 				var queue = jQuery.queue( this, type, data );
 92 | 
 93 | 				// Ensure a hooks for this queue
 94 | 				jQuery._queueHooks( this, type );
 95 | 
 96 | 				if ( type === "fx" && queue[0] !== "inprogress" ) {
 97 | 					jQuery.dequeue( this, type );
 98 | 				}
 99 | 			});
100 | 	},
101 | 	dequeue: function( type ) {
102 | 		return this.each(function() {
103 | 			jQuery.dequeue( this, type );
104 | 		});
105 | 	},
106 | 	clearQueue: function( type ) {
107 | 		return this.queue( type || "fx", [] );
108 | 	},
109 | 	// Get a promise resolved when queues of a certain type
110 | 	// are emptied (fx is the type by default)
111 | 	promise: function( type, obj ) {
112 | 		var tmp,
113 | 			count = 1,
114 | 			defer = jQuery.Deferred(),
115 | 			elements = this,
116 | 			i = this.length,
117 | 			resolve = function() {
118 | 				if ( !( --count ) ) {
119 | 					defer.resolveWith( elements, [ elements ] );
120 | 				}
121 | 			};
122 | 
123 | 		if ( typeof type !== "string" ) {
124 | 			obj = type;
125 | 			type = undefined;
126 | 		}
127 | 		type = type || "fx";
128 | 
129 | 		while ( i-- ) {
130 | 			tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
131 | 			if ( tmp && tmp.empty ) {
132 | 				count++;
133 | 				tmp.empty.add( resolve );
134 | 			}
135 | 		}
136 | 		resolve();
137 | 		return defer.promise( obj );
138 | 	}
139 | });
140 | 
141 | return jQuery;
142 | });
143 | 


--------------------------------------------------------------------------------
/serialize.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"./core",
  3 | 	"./manipulation/var/rcheckableType",
  4 | 	"./core/init",
  5 | 	"./traversing", // filter
  6 | 	"./attributes/prop"
  7 | ], function( jQuery, rcheckableType ) {
  8 | 
  9 | var r20 = /%20/g,
 10 | 	rbracket = /\[\]$/,
 11 | 	rCRLF = /\r?\n/g,
 12 | 	rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
 13 | 	rsubmittable = /^(?:input|select|textarea|keygen)/i;
 14 | 
 15 | function buildParams( prefix, obj, traditional, add ) {
 16 | 	var name;
 17 | 
 18 | 	if ( jQuery.isArray( obj ) ) {
 19 | 		// Serialize array item.
 20 | 		jQuery.each( obj, function( i, v ) {
 21 | 			if ( traditional || rbracket.test( prefix ) ) {
 22 | 				// Treat each array item as a scalar.
 23 | 				add( prefix, v );
 24 | 
 25 | 			} else {
 26 | 				// Item is non-scalar (array or object), encode its numeric index.
 27 | 				buildParams(
 28 | 					prefix + "[" + ( typeof v === "object" ? i : "" ) + "]",
 29 | 					v,
 30 | 					traditional,
 31 | 					add
 32 | 				);
 33 | 			}
 34 | 		});
 35 | 
 36 | 	} else if ( !traditional && jQuery.type( obj ) === "object" ) {
 37 | 		// Serialize object item.
 38 | 		for ( name in obj ) {
 39 | 			buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
 40 | 		}
 41 | 
 42 | 	} else {
 43 | 		// Serialize scalar item.
 44 | 		add( prefix, obj );
 45 | 	}
 46 | }
 47 | 
 48 | // Serialize an array of form elements or a set of
 49 | // key/values into a query string
 50 | jQuery.param = function( a, traditional ) {
 51 | 	var prefix,
 52 | 		s = [],
 53 | 		add = function( key, value ) {
 54 | 			// If value is a function, invoke it and return its value
 55 | 			value = jQuery.isFunction( value ) ? value() : ( value == null ? "" : value );
 56 | 			s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
 57 | 		};
 58 | 
 59 | 	// Set traditional to true for jQuery <= 1.3.2 behavior.
 60 | 	if ( traditional === undefined ) {
 61 | 		traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;
 62 | 	}
 63 | 
 64 | 	// If an array was passed in, assume that it is an array of form elements.
 65 | 	if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
 66 | 		// Serialize the form elements
 67 | 		jQuery.each( a, function() {
 68 | 			add( this.name, this.value );
 69 | 		});
 70 | 
 71 | 	} else {
 72 | 		// If traditional, encode the "old" way (the way 1.3.2 or older
 73 | 		// did it), otherwise encode params recursively.
 74 | 		for ( prefix in a ) {
 75 | 			buildParams( prefix, a[ prefix ], traditional, add );
 76 | 		}
 77 | 	}
 78 | 
 79 | 	// Return the resulting serialization
 80 | 	return s.join( "&" ).replace( r20, "+" );
 81 | };
 82 | 
 83 | jQuery.fn.extend({
 84 | 	serialize: function() {
 85 | 		return jQuery.param( this.serializeArray() );
 86 | 	},
 87 | 	serializeArray: function() {
 88 | 		return this.map(function() {
 89 | 			// Can add propHook for "elements" to filter or add form elements
 90 | 			var elements = jQuery.prop( this, "elements" );
 91 | 			return elements ? jQuery.makeArray( elements ) : this;
 92 | 		})
 93 | 		.filter(function() {
 94 | 			var type = this.type;
 95 | 
 96 | 			// Use .is( ":disabled" ) so that fieldset[disabled] works
 97 | 			return this.name && !jQuery( this ).is( ":disabled" ) &&
 98 | 				rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
 99 | 				( this.checked || !rcheckableType.test( type ) );
100 | 		})
101 | 		.map(function( i, elem ) {
102 | 			var val = jQuery( this ).val();
103 | 
104 | 			return val == null ?
105 | 				null :
106 | 				jQuery.isArray( val ) ?
107 | 					jQuery.map( val, function( val ) {
108 | 						return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
109 | 					}) :
110 | 					{ name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
111 | 		}).get();
112 | 	}
113 | });
114 | 
115 | return jQuery;
116 | });
117 | 


--------------------------------------------------------------------------------
/attributes/attr.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"../core",
  3 | 	"../var/rnotwhite",
  4 | 	"../core/access",
  5 | 	"./support",
  6 | 	"../selector"
  7 | ], function( jQuery, rnotwhite, access, support ) {
  8 | 
  9 | var nodeHook, boolHook,
 10 | 	attrHandle = jQuery.expr.attrHandle;
 11 | 
 12 | jQuery.fn.extend({
 13 | 	attr: function( name, value ) {
 14 | 		return access( this, jQuery.attr, name, value, arguments.length > 1 );
 15 | 	},
 16 | 
 17 | 	removeAttr: function( name ) {
 18 | 		return this.each(function() {
 19 | 			jQuery.removeAttr( this, name );
 20 | 		});
 21 | 	}
 22 | });
 23 | 
 24 | jQuery.extend({
 25 | 	attr: function( elem, name, value ) {
 26 | 		var hooks, ret,
 27 | 			nType = elem.nodeType;
 28 | 
 29 | 		// don't get/set attributes on text, comment and attribute nodes
 30 | 		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
 31 | 			return;
 32 | 		}
 33 | 
 34 | 		// Fallback to prop when attributes are not supported
 35 | 		if ( typeof elem.getAttribute === "undefined" ) {
 36 | 			return jQuery.prop( elem, name, value );
 37 | 		}
 38 | 
 39 | 		// All attributes are lowercase
 40 | 		// Grab necessary hook if one is defined
 41 | 		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
 42 | 			name = name.toLowerCase();
 43 | 			hooks = jQuery.attrHooks[ name ] ||
 44 | 				( jQuery.expr.match.bool.test( name ) ? boolHook : nodeHook );
 45 | 		}
 46 | 
 47 | 		if ( value !== undefined ) {
 48 | 
 49 | 			if ( value === null ) {
 50 | 				jQuery.removeAttr( elem, name );
 51 | 
 52 | 			} else if ( hooks && "set" in hooks &&
 53 | 				(ret = hooks.set( elem, value, name )) !== undefined ) {
 54 | 
 55 | 				return ret;
 56 | 
 57 | 			} else {
 58 | 				elem.setAttribute( name, value + "" );
 59 | 				return value;
 60 | 			}
 61 | 
 62 | 		} else if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
 63 | 			return ret;
 64 | 
 65 | 		} else {
 66 | 			ret = jQuery.find.attr( elem, name );
 67 | 
 68 | 			// Non-existent attributes return null, we normalize to undefined
 69 | 			return ret == null ?
 70 | 				undefined :
 71 | 				ret;
 72 | 		}
 73 | 	},
 74 | 
 75 | 	removeAttr: function( elem, value ) {
 76 | 		var name, propName,
 77 | 			i = 0,
 78 | 			attrNames = value && value.match( rnotwhite );
 79 | 
 80 | 		if ( attrNames && elem.nodeType === 1 ) {
 81 | 			while ( (name = attrNames[i++]) ) {
 82 | 				propName = jQuery.propFix[ name ] || name;
 83 | 
 84 | 				// Boolean attributes get special treatment (#10870)
 85 | 				if ( jQuery.expr.match.bool.test( name ) ) {
 86 | 					// Set corresponding property to false
 87 | 					elem[ propName ] = false;
 88 | 				}
 89 | 
 90 | 				elem.removeAttribute( name );
 91 | 			}
 92 | 		}
 93 | 	},
 94 | 
 95 | 	attrHooks: {
 96 | 		type: {
 97 | 			set: function( elem, value ) {
 98 | 				if ( !support.radioValue && value === "radio" &&
 99 | 					jQuery.nodeName( elem, "input" ) ) {
100 | 					var val = elem.value;
101 | 					elem.setAttribute( "type", value );
102 | 					if ( val ) {
103 | 						elem.value = val;
104 | 					}
105 | 					return value;
106 | 				}
107 | 			}
108 | 		}
109 | 	}
110 | });
111 | 
112 | // Hooks for boolean attributes
113 | boolHook = {
114 | 	set: function( elem, value, name ) {
115 | 		if ( value === false ) {
116 | 			// Remove boolean attributes when set to false
117 | 			jQuery.removeAttr( elem, name );
118 | 		} else {
119 | 			elem.setAttribute( name, name );
120 | 		}
121 | 		return name;
122 | 	}
123 | };
124 | jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
125 | 	var getter = attrHandle[ name ] || jQuery.find.attr;
126 | 
127 | 	attrHandle[ name ] = function( elem, name, isXML ) {
128 | 		var ret, handle;
129 | 		if ( !isXML ) {
130 | 			// Avoid an infinite loop by temporarily removing this function from the getter
131 | 			handle = attrHandle[ name ];
132 | 			attrHandle[ name ] = ret;
133 | 			ret = getter( elem, name, isXML ) != null ?
134 | 				name.toLowerCase() :
135 | 				null;
136 | 			attrHandle[ name ] = handle;
137 | 		}
138 | 		return ret;
139 | 	};
140 | });
141 | 
142 | });
143 | 


--------------------------------------------------------------------------------
/ajax/xhr.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"../core",
  3 | 	"../var/support",
  4 | 	"../ajax"
  5 | ], function( jQuery, support ) {
  6 | 
  7 | jQuery.ajaxSettings.xhr = function() {
  8 | 	try {
  9 | 		return new XMLHttpRequest();
 10 | 	} catch ( e ) {}
 11 | };
 12 | 
 13 | var xhrId = 0,
 14 | 	xhrCallbacks = {},
 15 | 	xhrSuccessStatus = {
 16 | 		// file protocol always yields status code 0, assume 200
 17 | 		0: 200,
 18 | 		// Support: IE9
 19 | 		// #1450: sometimes IE returns 1223 when it should be 204
 20 | 		1223: 204
 21 | 	},
 22 | 	xhrSupported = jQuery.ajaxSettings.xhr();
 23 | 
 24 | // Support: IE9
 25 | // Open requests must be manually aborted on unload (#5280)
 26 | if ( window.ActiveXObject ) {
 27 | 	jQuery( window ).on( "unload", function() {
 28 | 		for ( var key in xhrCallbacks ) {
 29 | 			xhrCallbacks[ key ]();
 30 | 		}
 31 | 	});
 32 | }
 33 | 
 34 | support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
 35 | support.ajax = xhrSupported = !!xhrSupported;
 36 | 
 37 | jQuery.ajaxTransport(function( options ) {
 38 | 	var callback;
 39 | 
 40 | 	// Cross domain only allowed if supported through XMLHttpRequest
 41 | 	if ( support.cors || xhrSupported && !options.crossDomain ) {
 42 | 		return {
 43 | 			send: function( headers, complete ) {
 44 | 				var i,
 45 | 					xhr = options.xhr(),
 46 | 					id = ++xhrId;
 47 | 
 48 | 				xhr.open(
 49 | 					options.type,
 50 | 					options.url,
 51 | 					options.async,
 52 | 					options.username,
 53 | 					options.password
 54 | 				);
 55 | 
 56 | 				// Apply custom fields if provided
 57 | 				if ( options.xhrFields ) {
 58 | 					for ( i in options.xhrFields ) {
 59 | 						xhr[ i ] = options.xhrFields[ i ];
 60 | 					}
 61 | 				}
 62 | 
 63 | 				// Override mime type if needed
 64 | 				if ( options.mimeType && xhr.overrideMimeType ) {
 65 | 					xhr.overrideMimeType( options.mimeType );
 66 | 				}
 67 | 
 68 | 				// X-Requested-With header
 69 | 				// For cross-domain requests, seeing as conditions for a preflight are
 70 | 				// akin to a jigsaw puzzle, we simply never set it to be sure.
 71 | 				// (it can always be set on a per-request basis or even using ajaxSetup)
 72 | 				// For same-domain requests, won't change header if already provided.
 73 | 				if ( !options.crossDomain && !headers["X-Requested-With"] ) {
 74 | 					headers["X-Requested-With"] = "XMLHttpRequest";
 75 | 				}
 76 | 
 77 | 				// Set headers
 78 | 				for ( i in headers ) {
 79 | 					xhr.setRequestHeader( i, headers[ i ] );
 80 | 				}
 81 | 
 82 | 				// Callback
 83 | 				callback = function( type ) {
 84 | 					return function() {
 85 | 						if ( callback ) {
 86 | 							delete xhrCallbacks[ id ];
 87 | 							callback = xhr.onload = xhr.onerror = null;
 88 | 
 89 | 							if ( type === "abort" ) {
 90 | 								xhr.abort();
 91 | 							} else if ( type === "error" ) {
 92 | 								complete(
 93 | 									// file: protocol always yields status 0; see #8605, #14207
 94 | 									xhr.status,
 95 | 									xhr.statusText
 96 | 								);
 97 | 							} else {
 98 | 								complete(
 99 | 									xhrSuccessStatus[ xhr.status ] || xhr.status,
100 | 									xhr.statusText,
101 | 									// Support: IE9
102 | 									// Accessing binary-data responseText throws an exception
103 | 									// (#11426)
104 | 									typeof xhr.responseText === "string" ? {
105 | 										text: xhr.responseText
106 | 									} : undefined,
107 | 									xhr.getAllResponseHeaders()
108 | 								);
109 | 							}
110 | 						}
111 | 					};
112 | 				};
113 | 
114 | 				// Listen to events
115 | 				xhr.onload = callback();
116 | 				xhr.onerror = callback("error");
117 | 
118 | 				// Create the abort callback
119 | 				callback = xhrCallbacks[ id ] = callback("abort");
120 | 
121 | 				try {
122 | 					// Do send the request (this may raise an exception)
123 | 					xhr.send( options.hasContent && options.data || null );
124 | 				} catch ( e ) {
125 | 					// #14683: Only rethrow if this hasn't been notified as an error yet
126 | 					if ( callback ) {
127 | 						throw e;
128 | 					}
129 | 				}
130 | 			},
131 | 
132 | 			abort: function() {
133 | 				if ( callback ) {
134 | 					callback();
135 | 				}
136 | 			}
137 | 		};
138 | 	}
139 | });
140 | 
141 | });
142 | 


--------------------------------------------------------------------------------
/attributes/val.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"../core",
  3 | 	"./support",
  4 | 	"../core/init"
  5 | ], function( jQuery, support ) {
  6 | 
  7 | var rreturn = /\r/g;
  8 | 
  9 | jQuery.fn.extend({
 10 | 	val: function( value ) {
 11 | 		var hooks, ret, isFunction,
 12 | 			elem = this[0];
 13 | 
 14 | 		if ( !arguments.length ) {
 15 | 			if ( elem ) {
 16 | 				hooks = jQuery.valHooks[ elem.type ] ||
 17 | 					jQuery.valHooks[ elem.nodeName.toLowerCase() ];
 18 | 
 19 | 				if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
 20 | 					return ret;
 21 | 				}
 22 | 
 23 | 				ret = elem.value;
 24 | 
 25 | 				return typeof ret === "string" ?
 26 | 					// Handle most common string cases
 27 | 					ret.replace(rreturn, "") :
 28 | 					// Handle cases where value is null/undef or number
 29 | 					ret == null ? "" : ret;
 30 | 			}
 31 | 
 32 | 			return;
 33 | 		}
 34 | 
 35 | 		isFunction = jQuery.isFunction( value );
 36 | 
 37 | 		return this.each(function( i ) {
 38 | 			var val;
 39 | 
 40 | 			if ( this.nodeType !== 1 ) {
 41 | 				return;
 42 | 			}
 43 | 
 44 | 			if ( isFunction ) {
 45 | 				val = value.call( this, i, jQuery( this ).val() );
 46 | 			} else {
 47 | 				val = value;
 48 | 			}
 49 | 
 50 | 			// Treat null/undefined as ""; convert numbers to string
 51 | 			if ( val == null ) {
 52 | 				val = "";
 53 | 
 54 | 			} else if ( typeof val === "number" ) {
 55 | 				val += "";
 56 | 
 57 | 			} else if ( jQuery.isArray( val ) ) {
 58 | 				val = jQuery.map( val, function( value ) {
 59 | 					return value == null ? "" : value + "";
 60 | 				});
 61 | 			}
 62 | 
 63 | 			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
 64 | 
 65 | 			// If set returns undefined, fall back to normal setting
 66 | 			if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
 67 | 				this.value = val;
 68 | 			}
 69 | 		});
 70 | 	}
 71 | });
 72 | 
 73 | jQuery.extend({
 74 | 	valHooks: {
 75 | 		option: {
 76 | 			get: function( elem ) {
 77 | 				var val = jQuery.find.attr( elem, "value" );
 78 | 				return val != null ?
 79 | 					val :
 80 | 					// Support: IE10-11+
 81 | 					// option.text throws exceptions (#14686, #14858)
 82 | 					jQuery.trim( jQuery.text( elem ) );
 83 | 			}
 84 | 		},
 85 | 		select: {
 86 | 			get: function( elem ) {
 87 | 				var value, option,
 88 | 					options = elem.options,
 89 | 					index = elem.selectedIndex,
 90 | 					one = elem.type === "select-one" || index < 0,
 91 | 					values = one ? null : [],
 92 | 					max = one ? index + 1 : options.length,
 93 | 					i = index < 0 ?
 94 | 						max :
 95 | 						one ? index : 0;
 96 | 
 97 | 				// Loop through all the selected options
 98 | 				for ( ; i < max; i++ ) {
 99 | 					option = options[ i ];
100 | 
101 | 					// IE6-9 doesn't update selected after form reset (#2551)
102 | 					if ( ( option.selected || i === index ) &&
103 | 							// Don't return options that are disabled or in a disabled optgroup
104 | 							( support.optDisabled ?
105 | 								!option.disabled : option.getAttribute( "disabled" ) === null ) &&
106 | 							( !option.parentNode.disabled ||
107 | 								!jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {
108 | 
109 | 						// Get the specific value for the option
110 | 						value = jQuery( option ).val();
111 | 
112 | 						// We don't need an array for one selects
113 | 						if ( one ) {
114 | 							return value;
115 | 						}
116 | 
117 | 						// Multi-Selects return an array
118 | 						values.push( value );
119 | 					}
120 | 				}
121 | 
122 | 				return values;
123 | 			},
124 | 
125 | 			set: function( elem, value ) {
126 | 				var optionSet, option,
127 | 					options = elem.options,
128 | 					values = jQuery.makeArray( value ),
129 | 					i = options.length;
130 | 
131 | 				while ( i-- ) {
132 | 					option = options[ i ];
133 | 					if ( (option.selected = jQuery.inArray( option.value, values ) >= 0) ) {
134 | 						optionSet = true;
135 | 					}
136 | 				}
137 | 
138 | 				// Force browsers to behave consistently when non-matching value is set
139 | 				if ( !optionSet ) {
140 | 					elem.selectedIndex = -1;
141 | 				}
142 | 				return values;
143 | 			}
144 | 		}
145 | 	}
146 | });
147 | 
148 | // Radios and checkboxes getter/setter
149 | jQuery.each([ "radio", "checkbox" ], function() {
150 | 	jQuery.valHooks[ this ] = {
151 | 		set: function( elem, value ) {
152 | 			if ( jQuery.isArray( value ) ) {
153 | 				return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
154 | 			}
155 | 		}
156 | 	};
157 | 	if ( !support.checkOn ) {
158 | 		jQuery.valHooks[ this ].get = function( elem ) {
159 | 			return elem.getAttribute("value") === null ? "on" : elem.value;
160 | 		};
161 | 	}
162 | });
163 | 
164 | });
165 | 


--------------------------------------------------------------------------------
/core/ready.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"../core",
  3 | 	"../core/init",
  4 | 	"../deferred"
  5 | ], function( jQuery ) {
  6 | 
  7 | // The deferred used on DOM ready
  8 | // 在dom准备好时使用
  9 | var readyList;
 10 | 
 11 | jQuery.fn.ready = function( fn ) {
 12 | 	// Add the callback
 13 |     // 增加回调
 14 | 	jQuery.ready.promise().done( fn );
 15 | 
 16 | 	return this;
 17 | };
 18 | 
 19 | jQuery.extend({
 20 | 	// Is the DOM ready to be used? Set to true once it occurs.
 21 |     // dom是否ready? 当 ready 时将其设置为true
 22 | 	isReady: false,
 23 | 
 24 | 	// A counter to track how many items to wait for before
 25 | 	// the ready event fires. See #6781
 26 |     // 一个计数器统计有多少项等待 ready 后事件触发
 27 | 	readyWait: 1,
 28 | 
 29 | 	// Hold (or release) the ready event
 30 |     // 暂停 或者 恢复 ready事件
 31 | 	holdReady: function( hold ) {
 32 | 		if ( hold ) {
 33 |             // 需要暂停，且等待数加1
 34 | 			jQuery.readyWait++;
 35 | 		} else {
 36 |             // 恢复 ready
 37 | 			jQuery.ready( true );
 38 | 		}
 39 | 	},
 40 | 
 41 | 	// Handle when the DOM is ready
 42 |     // 处理 dom已经ready
 43 | 	ready: function( wait ) {
 44 |         // wait 表示是否需要等待
 45 | 
 46 | 		// Abort if there are pending holds or we're already ready
 47 |         // 如果还有等待 或者是 已经ready 直接中止（return）
 48 | 
 49 |         // 处理  jQuery.holdReady(false); 的情况 表示恢复一次 ready 事件
 50 | 
 51 |         // 如果 wait === true （需要等待）
 52 |         // 判断 Wait计数器是否还有 等待数量， 如果有 直接中止
 53 | 
 54 |         // 否则 wait !== true （不需要等待）
 55 |         // 判断 isReady 是否为true ，当 isReady 为 true时表示 dom 已经 ready， 直接中止
 56 | 		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
 57 |             // 换句话说 jQuery.readyWait 大于１（需要等待） 或者 jQuery.isReady 为 true
 58 | 			// 就直接返回 中止掉
 59 |             return;
 60 | 		}
 61 | 
 62 | 		// Remember that the DOM is ready
 63 |         // 标记为dom已经ready
 64 | 
 65 |         // 当走到这里时，wait不为true,且dom还没有ready,不需要等待
 66 |         // 或者 readyWait 为 1（readyWait默认为1） 也就是不需要待
 67 |         // 设置为true表明 dom已经ready了
 68 | 		jQuery.isReady = true;
 69 | 
 70 | 		// If a normal DOM Ready event fired, decrement, and wait if need be
 71 |         // 如果一个正常的dom ready事件被触发，减量，需要等待
 72 | 
 73 |         // 如果 wait 不为 true 且 jQuery.readyWait自减 还大于0时
 74 |         // 直接中止，说明还 需要等待
 75 | 		if ( wait !== true && --jQuery.readyWait > 0 ) {
 76 | 			return;
 77 | 		}
 78 | 
 79 | 		// If there are functions bound, to execute
 80 |         // 执行，如果绑定有方法
 81 |         // 转换成 resolve ，并转入上下文以及 参数　
 82 | 		readyList.resolveWith( document, [ jQuery ] );
 83 | 
 84 | 		// Trigger any bound ready events
 85 |         // 触发所有的绑定事件
 86 | 		if ( jQuery.fn.triggerHandler ) {
 87 |             // 触发 document 的 ready 事件
 88 |             jQuery( document ).triggerHandler( "ready" );
 89 |             // 取消绑定document的ready事件
 90 | 			jQuery( document ).off( "ready" );
 91 | 		}
 92 | 	}
 93 | });
 94 | 
 95 | /**
 96 |  * The ready event handler and self cleanup method
 97 |  * ready事件处理以及事件取消绑定
 98 |  */
 99 | function completed() {
100 |     // 事件取消绑定
101 | 	document.removeEventListener( "DOMContentLoaded", completed, false );
102 | 	window.removeEventListener( "load", completed, false );
103 |     // ready 事件处理
104 | 	jQuery.ready();
105 | }
106 | 
107 | jQuery.ready.promise = function( obj ) {
108 |     // 如果 ready列表不存在
109 | 	if ( !readyList ) {
110 |         // 创建一个延迟对象
111 | 		readyList = jQuery.Deferred();
112 | 
113 | 		// Catch cases where $(document).ready() is called
114 |         // 捕获 $(document).ready() 调用过的情况
115 | 		// after the browser event has already occurred.
116 | 		// We once tried to use readyState "interactive" here,
117 |         // 我们曾经在这里尝试使用 readyState 做 interactive
118 | 		// but it caused issues like the one
119 |         // 但它引起类似的问题
120 | 		// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
121 |         // 来自 ChrisS 的发现 地址： http://bugs.jquery.com/ticket/12282#comment:15
122 |         // 判断 document 的readyState 是否为 complete (完成)
123 |         if ( document.readyState === "complete" ) {
124 | 			// Handle it asynchronously to allow scripts the opportunity to delay ready
125 |             // 以异步方式使得脚本处理延迟ready
126 | 			setTimeout( jQuery.ready );
127 | 
128 | 		} else {
129 | 
130 |             // 绑定 DOMContentLoaded 以及 load 事件
131 | 			// Use the handy event callback
132 |             // 使用方便的事件回调
133 |             // DOMContentLoaded dom加载完毕事件
134 | 			document.addEventListener( "DOMContentLoaded", completed, false );
135 | 
136 | 			// A fallback to window.onload, that will always work
137 |             // 回退到 window.onlad 事件，也将起作用
138 | 			window.addEventListener( "load", completed, false );
139 | 		}
140 | 	}
141 |     // 返回延迟对象的 promise
142 | 	return readyList.promise( obj );
143 | };
144 | 
145 | // Kick off the DOM ready check even if the user does not
146 | // 即使用户没有做准备也启动 dom　ready 检查
147 | // 调用 jQuery.ready.promise 开始 DOM ready
148 | jQuery.ready.promise();
149 | 
150 | });
151 | 


--------------------------------------------------------------------------------
/attributes/classes.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"../core",
  3 | 	"../var/rnotwhite",
  4 | 	"../data/var/dataPriv",
  5 | 	"../core/init"
  6 | ], function( jQuery, rnotwhite, dataPriv ) {
  7 | 
  8 | var rclass = /[\t\r\n\f]/g;
  9 | 
 10 | jQuery.fn.extend({
 11 | 	addClass: function( value ) {
 12 | 		var classes, elem, cur, clazz, j, finalValue,
 13 | 			proceed = typeof value === "string" && value,
 14 | 			i = 0,
 15 | 			len = this.length;
 16 | 
 17 | 		if ( jQuery.isFunction( value ) ) {
 18 | 			return this.each(function( j ) {
 19 | 				jQuery( this ).addClass( value.call( this, j, this.className ) );
 20 | 			});
 21 | 		}
 22 | 
 23 | 		if ( proceed ) {
 24 | 			// The disjunction here is for better compressibility (see removeClass)
 25 | 			classes = ( value || "" ).match( rnotwhite ) || [];
 26 | 
 27 | 			for ( ; i < len; i++ ) {
 28 | 				elem = this[ i ];
 29 | 				cur = elem.nodeType === 1 && ( elem.className ?
 30 | 					( " " + elem.className + " " ).replace( rclass, " " ) :
 31 | 					" "
 32 | 				);
 33 | 
 34 | 				if ( cur ) {
 35 | 					j = 0;
 36 | 					while ( (clazz = classes[j++]) ) {
 37 | 						if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
 38 | 							cur += clazz + " ";
 39 | 						}
 40 | 					}
 41 | 
 42 | 					// only assign if different to avoid unneeded rendering.
 43 | 					finalValue = jQuery.trim( cur );
 44 | 					if ( elem.className !== finalValue ) {
 45 | 						elem.className = finalValue;
 46 | 					}
 47 | 				}
 48 | 			}
 49 | 		}
 50 | 
 51 | 		return this;
 52 | 	},
 53 | 
 54 | 	removeClass: function( value ) {
 55 | 		var classes, elem, cur, clazz, j, finalValue,
 56 | 			proceed = arguments.length === 0 || typeof value === "string" && value,
 57 | 			i = 0,
 58 | 			len = this.length;
 59 | 
 60 | 		if ( jQuery.isFunction( value ) ) {
 61 | 			return this.each(function( j ) {
 62 | 				jQuery( this ).removeClass( value.call( this, j, this.className ) );
 63 | 			});
 64 | 		}
 65 | 		if ( proceed ) {
 66 | 			classes = ( value || "" ).match( rnotwhite ) || [];
 67 | 
 68 | 			for ( ; i < len; i++ ) {
 69 | 				elem = this[ i ];
 70 | 				// This expression is here for better compressibility (see addClass)
 71 | 				cur = elem.nodeType === 1 && ( elem.className ?
 72 | 					( " " + elem.className + " " ).replace( rclass, " " ) :
 73 | 					""
 74 | 				);
 75 | 
 76 | 				if ( cur ) {
 77 | 					j = 0;
 78 | 					while ( (clazz = classes[j++]) ) {
 79 | 						// Remove *all* instances
 80 | 						while ( cur.indexOf( " " + clazz + " " ) >= 0 ) {
 81 | 							cur = cur.replace( " " + clazz + " ", " " );
 82 | 						}
 83 | 					}
 84 | 
 85 | 					// Only assign if different to avoid unneeded rendering.
 86 | 					finalValue = value ? jQuery.trim( cur ) : "";
 87 | 					if ( elem.className !== finalValue ) {
 88 | 						elem.className = finalValue;
 89 | 					}
 90 | 				}
 91 | 			}
 92 | 		}
 93 | 
 94 | 		return this;
 95 | 	},
 96 | 
 97 | 	toggleClass: function( value, stateVal ) {
 98 | 		var type = typeof value;
 99 | 
100 | 		if ( typeof stateVal === "boolean" && type === "string" ) {
101 | 			return stateVal ? this.addClass( value ) : this.removeClass( value );
102 | 		}
103 | 
104 | 		if ( jQuery.isFunction( value ) ) {
105 | 			return this.each(function( i ) {
106 | 				jQuery( this ).toggleClass(
107 | 					value.call(this, i, this.className, stateVal), stateVal
108 | 				);
109 | 			});
110 | 		}
111 | 
112 | 		return this.each(function() {
113 | 			if ( type === "string" ) {
114 | 				// Toggle individual class names
115 | 				var className,
116 | 					i = 0,
117 | 					self = jQuery( this ),
118 | 					classNames = value.match( rnotwhite ) || [];
119 | 
120 | 				while ( (className = classNames[ i++ ]) ) {
121 | 					// Check each className given, space separated list
122 | 					if ( self.hasClass( className ) ) {
123 | 						self.removeClass( className );
124 | 					} else {
125 | 						self.addClass( className );
126 | 					}
127 | 				}
128 | 
129 | 			// Toggle whole class name
130 | 			} else if ( value === undefined || type === "boolean" ) {
131 | 				if ( this.className ) {
132 | 					// store className if set
133 | 					dataPriv.set( this, "__className__", this.className );
134 | 				}
135 | 
136 | 				// If the element has a class name or if we're passed `false`,
137 | 				// then remove the whole classname (if there was one, the above saved it).
138 | 				// Otherwise bring back whatever was previously saved (if anything),
139 | 				// falling back to the empty string if nothing was stored.
140 | 				this.className = this.className || value === false ?
141 | 					"" :
142 | 					dataPriv.get( this, "__className__" ) || "";
143 | 			}
144 | 		});
145 | 	},
146 | 
147 | 	hasClass: function( selector ) {
148 | 		var className = " " + selector + " ",
149 | 			i = 0,
150 | 			l = this.length;
151 | 		for ( ; i < l; i++ ) {
152 | 			if ( this[i].nodeType === 1 &&
153 | 				(" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) {
154 | 
155 | 				return true;
156 | 			}
157 | 		}
158 | 
159 | 		return false;
160 | 	}
161 | });
162 | 
163 | });
164 | 


--------------------------------------------------------------------------------
/traversing.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"./core",
  3 | 	"./var/indexOf",
  4 | 	"./traversing/var/rneedsContext",
  5 | 	"./core/init",
  6 | 	"./traversing/findFilter",
  7 | 	"./selector"
  8 | ], function( jQuery, indexOf, rneedsContext ) {
  9 | 
 10 | var rparentsprev = /^(?:parents|prev(?:Until|All))/,
 11 | 	// Methods guaranteed to produce a unique set when starting from a unique set
 12 | 	guaranteedUnique = {
 13 | 		children: true,
 14 | 		contents: true,
 15 | 		next: true,
 16 | 		prev: true
 17 | 	};
 18 | 
 19 | jQuery.extend({
 20 | 	dir: function( elem, dir, until ) {
 21 | 		var matched = [],
 22 | 			truncate = until !== undefined;
 23 | 
 24 | 		while ( (elem = elem[ dir ]) && elem.nodeType !== 9 ) {
 25 | 			if ( elem.nodeType === 1 ) {
 26 | 				if ( truncate && jQuery( elem ).is( until ) ) {
 27 | 					break;
 28 | 				}
 29 | 				matched.push( elem );
 30 | 			}
 31 | 		}
 32 | 		return matched;
 33 | 	},
 34 | 
 35 | 	sibling: function( n, elem ) {
 36 | 		var matched = [];
 37 | 
 38 | 		for ( ; n; n = n.nextSibling ) {
 39 | 			if ( n.nodeType === 1 && n !== elem ) {
 40 | 				matched.push( n );
 41 | 			}
 42 | 		}
 43 | 
 44 | 		return matched;
 45 | 	}
 46 | });
 47 | 
 48 | jQuery.fn.extend({
 49 | 	has: function( target ) {
 50 | 		var targets = jQuery( target, this ),
 51 | 			l = targets.length;
 52 | 
 53 | 		return this.filter(function() {
 54 | 			var i = 0;
 55 | 			for ( ; i < l; i++ ) {
 56 | 				if ( jQuery.contains( this, targets[i] ) ) {
 57 | 					return true;
 58 | 				}
 59 | 			}
 60 | 		});
 61 | 	},
 62 | 
 63 | 	closest: function( selectors, context ) {
 64 | 		var cur,
 65 | 			i = 0,
 66 | 			l = this.length,
 67 | 			matched = [],
 68 | 			pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?
 69 | 				jQuery( selectors, context || this.context ) :
 70 | 				0;
 71 | 
 72 | 		for ( ; i < l; i++ ) {
 73 | 			for ( cur = this[i]; cur && cur !== context; cur = cur.parentNode ) {
 74 | 				// Always skip document fragments
 75 | 				if ( cur.nodeType < 11 && (pos ?
 76 | 					pos.index(cur) > -1 :
 77 | 
 78 | 					// Don't pass non-elements to Sizzle
 79 | 					cur.nodeType === 1 &&
 80 | 						jQuery.find.matchesSelector(cur, selectors)) ) {
 81 | 
 82 | 					matched.push( cur );
 83 | 					break;
 84 | 				}
 85 | 			}
 86 | 		}
 87 | 
 88 | 		return this.pushStack( matched.length > 1 ? jQuery.unique( matched ) : matched );
 89 | 	},
 90 | 
 91 | 	// Determine the position of an element within the set
 92 | 	index: function( elem ) {
 93 | 
 94 | 		// No argument, return index in parent
 95 | 		if ( !elem ) {
 96 | 			return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
 97 | 		}
 98 | 
 99 | 		// Index in selector
100 | 		if ( typeof elem === "string" ) {
101 | 			return indexOf.call( jQuery( elem ), this[ 0 ] );
102 | 		}
103 | 
104 | 		// Locate the position of the desired element
105 | 		return indexOf.call( this,
106 | 
107 | 			// If it receives a jQuery object, the first element is used
108 | 			elem.jquery ? elem[ 0 ] : elem
109 | 		);
110 | 	},
111 | 
112 | 	add: function( selector, context ) {
113 | 		return this.pushStack(
114 | 			jQuery.unique(
115 | 				jQuery.merge( this.get(), jQuery( selector, context ) )
116 | 			)
117 | 		);
118 | 	},
119 | 
120 | 	addBack: function( selector ) {
121 | 		return this.add( selector == null ?
122 | 			this.prevObject : this.prevObject.filter(selector)
123 | 		);
124 | 	}
125 | });
126 | 
127 | function sibling( cur, dir ) {
128 | 	while ( (cur = cur[dir]) && cur.nodeType !== 1 ) {}
129 | 	return cur;
130 | }
131 | 
132 | jQuery.each({
133 | 	parent: function( elem ) {
134 | 		var parent = elem.parentNode;
135 | 		return parent && parent.nodeType !== 11 ? parent : null;
136 | 	},
137 | 	parents: function( elem ) {
138 | 		return jQuery.dir( elem, "parentNode" );
139 | 	},
140 | 	parentsUntil: function( elem, i, until ) {
141 | 		return jQuery.dir( elem, "parentNode", until );
142 | 	},
143 | 	next: function( elem ) {
144 | 		return sibling( elem, "nextSibling" );
145 | 	},
146 | 	prev: function( elem ) {
147 | 		return sibling( elem, "previousSibling" );
148 | 	},
149 | 	nextAll: function( elem ) {
150 | 		return jQuery.dir( elem, "nextSibling" );
151 | 	},
152 | 	prevAll: function( elem ) {
153 | 		return jQuery.dir( elem, "previousSibling" );
154 | 	},
155 | 	nextUntil: function( elem, i, until ) {
156 | 		return jQuery.dir( elem, "nextSibling", until );
157 | 	},
158 | 	prevUntil: function( elem, i, until ) {
159 | 		return jQuery.dir( elem, "previousSibling", until );
160 | 	},
161 | 	siblings: function( elem ) {
162 | 		return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );
163 | 	},
164 | 	children: function( elem ) {
165 | 		return jQuery.sibling( elem.firstChild );
166 | 	},
167 | 	contents: function( elem ) {
168 | 		return elem.contentDocument || jQuery.merge( [], elem.childNodes );
169 | 	}
170 | }, function( name, fn ) {
171 | 	jQuery.fn[ name ] = function( until, selector ) {
172 | 		var matched = jQuery.map( this, fn, until );
173 | 
174 | 		if ( name.slice( -5 ) !== "Until" ) {
175 | 			selector = until;
176 | 		}
177 | 
178 | 		if ( selector && typeof selector === "string" ) {
179 | 			matched = jQuery.filter( selector, matched );
180 | 		}
181 | 
182 | 		if ( this.length > 1 ) {
183 | 			// Remove duplicates
184 | 			if ( !guaranteedUnique[ name ] ) {
185 | 				jQuery.unique( matched );
186 | 			}
187 | 
188 | 			// Reverse order for parents* and prev-derivatives
189 | 			if ( rparentsprev.test( name ) ) {
190 | 				matched.reverse();
191 | 			}
192 | 		}
193 | 
194 | 		return this.pushStack( matched );
195 | 	};
196 | });
197 | 
198 | return jQuery;
199 | });
200 | 


--------------------------------------------------------------------------------
/selector-native.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"./core"
  3 | ], function( jQuery ) {
  4 | 
  5 | /*
  6 |  * Optional (non-Sizzle) selector module for custom builds.
  7 |  *
  8 |  * Note that this DOES NOT SUPPORT many documented jQuery
  9 |  * features in exchange for its smaller size:
 10 |  *
 11 |  * Attribute not equal selector
 12 |  * Positional selectors (:first; :eq(n); :odd; etc.)
 13 |  * Type selectors (:input; :checkbox; :button; etc.)
 14 |  * State-based selectors (:animated; :visible; :hidden; etc.)
 15 |  * :has(selector)
 16 |  * :not(complex selector)
 17 |  * custom selectors via Sizzle extensions
 18 |  * Leading combinators (e.g., $collection.find("> *"))
 19 |  * Reliable functionality on XML fragments
 20 |  * Requiring all parts of a selector to match elements under context
 21 |  *   (e.g., $div.find("div > *") now matches children of $div)
 22 |  * Matching against non-elements
 23 |  * Reliable sorting of disconnected nodes
 24 |  * querySelectorAll bug fixes (e.g., unreliable :focus on WebKit)
 25 |  *
 26 |  * If any of these are unacceptable tradeoffs, either use Sizzle or
 27 |  * customize this stub for the project's specific needs.
 28 |  */
 29 | 
 30 | var hasDuplicate,
 31 | 	docElem = window.document.documentElement,
 32 | 	matches = docElem.matches ||
 33 | 		docElem.webkitMatchesSelector ||
 34 | 		docElem.mozMatchesSelector ||
 35 | 		docElem.oMatchesSelector ||
 36 | 		docElem.msMatchesSelector,
 37 | 	sortOrder = function( a, b ) {
 38 | 		// Flag for duplicate removal
 39 | 		if ( a === b ) {
 40 | 			hasDuplicate = true;
 41 | 			return 0;
 42 | 		}
 43 | 
 44 | 		var compare = b.compareDocumentPosition &&
 45 | 			a.compareDocumentPosition &&
 46 | 			a.compareDocumentPosition( b );
 47 | 
 48 | 		if ( compare ) {
 49 | 			// Disconnected nodes
 50 | 			if ( compare & 1 ) {
 51 | 
 52 | 				// Choose the first element that is related to our document
 53 | 				if ( a === document || jQuery.contains(document, a) ) {
 54 | 					return -1;
 55 | 				}
 56 | 				if ( b === document || jQuery.contains(document, b) ) {
 57 | 					return 1;
 58 | 				}
 59 | 
 60 | 				// Maintain original order
 61 | 				return 0;
 62 | 			}
 63 | 
 64 | 			return compare & 4 ? -1 : 1;
 65 | 		}
 66 | 
 67 | 		// Not directly comparable, sort on existence of method
 68 | 		return a.compareDocumentPosition ? -1 : 1;
 69 | 	};
 70 | 
 71 | jQuery.extend({
 72 | 	find: function( selector, context, results, seed ) {
 73 | 		var elem, nodeType,
 74 | 			i = 0;
 75 | 
 76 | 		results = results || [];
 77 | 		context = context || document;
 78 | 
 79 | 		// Same basic safeguard as Sizzle
 80 | 		if ( !selector || typeof selector !== "string" ) {
 81 | 			return results;
 82 | 		}
 83 | 
 84 | 		// Early return if context is not an element or document
 85 | 		if ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) {
 86 | 			return [];
 87 | 		}
 88 | 
 89 | 		if ( seed ) {
 90 | 			while ( (elem = seed[i++]) ) {
 91 | 				if ( jQuery.find.matchesSelector(elem, selector) ) {
 92 | 					results.push( elem );
 93 | 				}
 94 | 			}
 95 | 		} else {
 96 | 			jQuery.merge( results, context.querySelectorAll(selector) );
 97 | 		}
 98 | 
 99 | 		return results;
100 | 	},
101 | 	unique: function( results ) {
102 | 		var elem,
103 | 			duplicates = [],
104 | 			i = 0,
105 | 			j = 0;
106 | 
107 | 		hasDuplicate = false;
108 | 		results.sort( sortOrder );
109 | 
110 | 		if ( hasDuplicate ) {
111 | 			while ( (elem = results[i++]) ) {
112 | 				if ( elem === results[ i ] ) {
113 | 					j = duplicates.push( i );
114 | 				}
115 | 			}
116 | 			while ( j-- ) {
117 | 				results.splice( duplicates[ j ], 1 );
118 | 			}
119 | 		}
120 | 
121 | 		return results;
122 | 	},
123 | 	text: function( elem ) {
124 | 		var node,
125 | 			ret = "",
126 | 			i = 0,
127 | 			nodeType = elem.nodeType;
128 | 
129 | 		if ( !nodeType ) {
130 | 			// If no nodeType, this is expected to be an array
131 | 			while ( (node = elem[i++]) ) {
132 | 				// Do not traverse comment nodes
133 | 				ret += jQuery.text( node );
134 | 			}
135 | 		} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
136 | 			// Use textContent for elements
137 | 			return elem.textContent;
138 | 		} else if ( nodeType === 3 || nodeType === 4 ) {
139 | 			return elem.nodeValue;
140 | 		}
141 | 		// Do not include comment or processing instruction nodes
142 | 
143 | 		return ret;
144 | 	},
145 | 
146 | 	// 检测一个dom元素是否是另一个dom元素的后代
147 | 	contains: function( a, b ) {
148 | 		// a 为 document 返回 a.documentElement , 否则返回 a
149 | 		// 目的是为了 a 是 document对象时 将其转换为 对应 root元素
150 | 		var adown = a.nodeType === 9 ? a.documentElement : a,
151 | 			// 取 b 元素的父节点
152 | 			bup = b && b.parentNode;
153 | 		// 当 a 元素 等于 b.parentNode 直接返回 true
154 | 		// 否则 判断 b.parentNode 是否为元素节点 且调用 dom 方法 contains 判断 a 是否包括 子元素 b.parentNode
155 | 		return a === bup || !!( bup && bup.nodeType === 1 && adown.contains(bup) );
156 | 	},
157 | 	isXMLDoc: function( elem ) {
158 | 		// 元素的根节点或者elem  的文档根节点的名称是否为 html
159 | 		// 如果不等于那么 就是xml文档　
160 | 		// 否则当是html文档
161 | 		return (elem.ownerDocument || elem).documentElement.nodeName !== "HTML";
162 | 	},
163 | 	expr: {
164 | 		attrHandle: {},
165 | 		match: {
166 | 			bool: /^(?:checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped)$/i,
167 | 			needsContext: /^[\x20\t\r\n\f]*[>+~]/
168 | 		}
169 | 	}
170 | });
171 | 
172 | jQuery.extend( jQuery.find, {
173 | 	matches: function( expr, elements ) {
174 | 		return jQuery.find( expr, null, null, elements );
175 | 	},
176 | 	matchesSelector: function( elem, expr ) {
177 | 		return matches.call( elem, expr );
178 | 	},
179 | 	attr: function( elem, name ) {
180 | 		return elem.getAttribute( name );
181 | 	}
182 | });
183 | 
184 | });
185 | 


--------------------------------------------------------------------------------
/offset.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"./core",
  3 | 	"./core/access",
  4 | 	"./css/var/rnumnonpx",
  5 | 	"./css/curCSS",
  6 | 	"./css/addGetHookIf",
  7 | 	"./css/support",
  8 | 
  9 | 	"./core/init",
 10 | 	"./css",
 11 | 	"./selector" // contains
 12 | ], function( jQuery, access, rnumnonpx, curCSS, addGetHookIf, support ) {
 13 | 
 14 | var docElem = window.document.documentElement;
 15 | 
 16 | /**
 17 |  * Gets a window from an element
 18 |  */
 19 | function getWindow( elem ) {
 20 | 	return jQuery.isWindow( elem ) ? elem : elem.nodeType === 9 && elem.defaultView;
 21 | }
 22 | 
 23 | jQuery.offset = {
 24 | 	setOffset: function( elem, options, i ) {
 25 | 		var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
 26 | 			position = jQuery.css( elem, "position" ),
 27 | 			curElem = jQuery( elem ),
 28 | 			props = {};
 29 | 
 30 | 		// Set position first, in-case top/left are set even on static elem
 31 | 		if ( position === "static" ) {
 32 | 			elem.style.position = "relative";
 33 | 		}
 34 | 
 35 | 		curOffset = curElem.offset();
 36 | 		curCSSTop = jQuery.css( elem, "top" );
 37 | 		curCSSLeft = jQuery.css( elem, "left" );
 38 | 		calculatePosition = ( position === "absolute" || position === "fixed" ) &&
 39 | 			( curCSSTop + curCSSLeft ).indexOf("auto") > -1;
 40 | 
 41 | 		// Need to be able to calculate position if either
 42 | 		// top or left is auto and position is either absolute or fixed
 43 | 		if ( calculatePosition ) {
 44 | 			curPosition = curElem.position();
 45 | 			curTop = curPosition.top;
 46 | 			curLeft = curPosition.left;
 47 | 
 48 | 		} else {
 49 | 			curTop = parseFloat( curCSSTop ) || 0;
 50 | 			curLeft = parseFloat( curCSSLeft ) || 0;
 51 | 		}
 52 | 
 53 | 		if ( jQuery.isFunction( options ) ) {
 54 | 			options = options.call( elem, i, curOffset );
 55 | 		}
 56 | 
 57 | 		if ( options.top != null ) {
 58 | 			props.top = ( options.top - curOffset.top ) + curTop;
 59 | 		}
 60 | 		if ( options.left != null ) {
 61 | 			props.left = ( options.left - curOffset.left ) + curLeft;
 62 | 		}
 63 | 
 64 | 		if ( "using" in options ) {
 65 | 			options.using.call( elem, props );
 66 | 
 67 | 		} else {
 68 | 			curElem.css( props );
 69 | 		}
 70 | 	}
 71 | };
 72 | 
 73 | jQuery.fn.extend({
 74 | 	offset: function( options ) {
 75 | 		if ( arguments.length ) {
 76 | 			return options === undefined ?
 77 | 				this :
 78 | 				this.each(function( i ) {
 79 | 					jQuery.offset.setOffset( this, options, i );
 80 | 				});
 81 | 		}
 82 | 
 83 | 		var docElem, win,
 84 | 			elem = this[ 0 ],
 85 | 			box = { top: 0, left: 0 },
 86 | 			doc = elem && elem.ownerDocument;
 87 | 
 88 | 		if ( !doc ) {
 89 | 			return;
 90 | 		}
 91 | 
 92 | 		docElem = doc.documentElement;
 93 | 
 94 | 		// Make sure it's not a disconnected DOM node
 95 | 		if ( !jQuery.contains( docElem, elem ) ) {
 96 | 			return box;
 97 | 		}
 98 | 
 99 | 		// Support: BlackBerry 5, iOS 3 (original iPhone)
100 | 		// If we don't have gBCR, just use 0,0 rather than error
101 | 		if ( elem.getBoundingClientRect ) {
102 | 			box = elem.getBoundingClientRect();
103 | 		}
104 | 		win = getWindow( doc );
105 | 		return {
106 | 			top: box.top + win.pageYOffset - docElem.clientTop,
107 | 			left: box.left + win.pageXOffset - docElem.clientLeft
108 | 		};
109 | 	},
110 | 
111 | 	position: function() {
112 | 		if ( !this[ 0 ] ) {
113 | 			return;
114 | 		}
115 | 
116 | 		var offsetParent, offset,
117 | 			elem = this[ 0 ],
118 | 			parentOffset = { top: 0, left: 0 };
119 | 
120 | 		// Fixed elements are offset from window (parentOffset = {top:0, left: 0},
121 | 		// because it is its only offset parent
122 | 		if ( jQuery.css( elem, "position" ) === "fixed" ) {
123 | 			// Assume getBoundingClientRect is there when computed position is fixed
124 | 			offset = elem.getBoundingClientRect();
125 | 
126 | 		} else {
127 | 			// Get *real* offsetParent
128 | 			offsetParent = this.offsetParent();
129 | 
130 | 			// Get correct offsets
131 | 			offset = this.offset();
132 | 			if ( !jQuery.nodeName( offsetParent[ 0 ], "html" ) ) {
133 | 				parentOffset = offsetParent.offset();
134 | 			}
135 | 
136 | 			// Add offsetParent borders
137 | 			parentOffset.top += jQuery.css( offsetParent[ 0 ], "borderTopWidth", true );
138 | 			parentOffset.left += jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true );
139 | 		}
140 | 
141 | 		// Subtract parent offsets and element margins
142 | 		return {
143 | 			top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
144 | 			left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
145 | 		};
146 | 	},
147 | 
148 | 	offsetParent: function() {
149 | 		return this.map(function() {
150 | 			var offsetParent = this.offsetParent || docElem;
151 | 
152 | 			while ( offsetParent && ( !jQuery.nodeName( offsetParent, "html" ) &&
153 | 				jQuery.css( offsetParent, "position" ) === "static" ) ) {
154 | 				offsetParent = offsetParent.offsetParent;
155 | 			}
156 | 
157 | 			return offsetParent || docElem;
158 | 		});
159 | 	}
160 | });
161 | 
162 | // Create scrollLeft and scrollTop methods
163 | jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
164 | 	var top = "pageYOffset" === prop;
165 | 
166 | 	jQuery.fn[ method ] = function( val ) {
167 | 		return access( this, function( elem, method, val ) {
168 | 			var win = getWindow( elem );
169 | 
170 | 			if ( val === undefined ) {
171 | 				return win ? win[ prop ] : elem[ method ];
172 | 			}
173 | 
174 | 			if ( win ) {
175 | 				win.scrollTo(
176 | 					!top ? val : window.pageXOffset,
177 | 					top ? val : window.pageYOffset
178 | 				);
179 | 
180 | 			} else {
181 | 				elem[ method ] = val;
182 | 			}
183 | 		}, method, val, arguments.length, null );
184 | 	};
185 | });
186 | 
187 | // Support: Safari<7+, Chrome<37+
188 | // Add the top/left cssHooks using jQuery.fn.position
189 | // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
190 | // Blink bug: https://code.google.com/p/chromium/issues/detail?id=229280
191 | // getComputedStyle returns percent when specified for top/left/bottom/right;
192 | // rather than make the css module depend on the offset module, just check for it here
193 | jQuery.each( [ "top", "left" ], function( i, prop ) {
194 | 	jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
195 | 		function( elem, computed ) {
196 | 			if ( computed ) {
197 | 				computed = curCSS( elem, prop );
198 | 				// If curCSS returns percentage, fallback to offset
199 | 				return rnumnonpx.test( computed ) ?
200 | 					jQuery( elem ).position()[ prop ] + "px" :
201 | 					computed;
202 | 			}
203 | 		}
204 | 	);
205 | });
206 | 
207 | return jQuery;
208 | });
209 | 


--------------------------------------------------------------------------------
/core/init.js:
--------------------------------------------------------------------------------
  1 | // Initialize a jQuery object
  2 | define([
  3 | 	"../core",
  4 | 	"./var/rsingleTag",
  5 | 	"../traversing/findFilter"
  6 | ], function( jQuery, rsingleTag ) {
  7 | 
  8 | // A central reference to the root jQuery(document)
  9 | // 声明一个 rootjQuery 变量，用于将 document 封装成 jQuery 对象并缓存
 10 | var rootjQuery,
 11 | 
 12 | 	// A simple way to check for HTML strings
 13 | 	// 一个简单的方式来检查 HTML 字符串
 14 | 	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
 15 | 	// #id 优先 <tag> 以避免通过location.hash XSS （#9521)
 16 | 	// Strict HTML recognition (#11290: must start with <)
 17 | 	// 严格的识别 HTML (#11290： 必须以开头 < )
 18 | 
 19 | 	// rquickExpr
 20 | 	// /^(?:pattern)$/  非获取匹配 并且 （匹配输入/字符串的开始 以及 匹配输入/字符串的结尾）
 21 | 	// pattern: \s*(<[\w\W]+>)[^>]*|#([\w-]*)
 22 | 	// pattern 用|分割得到 \s*(<[\w\W]+>)[^>]* 以及 #([\w-]*)
 23 | 	// 最后合并分解成  /^(?:\s*(<[\w\W]+>)[^>]*)$/  或者  /^(?:#([\w-]*))$/
 24 | 	// 前者是匹配简单的<tag>，必须是以 < 开头，当然 < 前面可任意空白符\s。
 25 | 	// 后者是匹配#id,符合#[A-Za-z0-9_-]
 26 | 	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,
 27 | 
 28 | 	// jQuery真实的构造函数
 29 | 	init = jQuery.fn.init = function( selector, context ) {
 30 | 		var match, elem;
 31 | 
 32 | 		// HANDLE: $(""), $(null), $(undefined), $(false)
 33 | 		// 处理： "", null, undefined, false
 34 | 		// 返回一个空的jQuery对象
 35 | 		if ( !selector ) {
 36 | 			return this;
 37 | 		}
 38 | 
 39 | 		// Handle HTML strings
 40 | 		// 处理 HTML 字符串
 41 | 		// 检测 selector 是否为 string 类型
 42 | 		if ( typeof selector === "string" ) {
 43 | 			// 如果 selector 第一个字符是 "<" 且 最后一个字符 ">" 并且 selector的长度 大于 3  例如： <x>
 44 | 			if ( selector[0] === "<" &&
 45 | 				selector[ selector.length - 1 ] === ">" &&
 46 | 				selector.length >= 3 ) {
 47 | 
 48 | 				// Assume that strings that start and end with <> are HTML and skip the regex check
 49 | 				// 假定是 html 标签 就跳过 正则 检查
 50 | 				match = [ null, selector, null ];
 51 | 
 52 | 			} else {
 53 | 				// 否则用正则检查
 54 | 				// match = [ selector, html or undefined, id or undefined]
 55 | 				// 匹配成功 则 html 或 id 其中一项 相反是 undefined
 56 | 				// [selector, html, undefined]  或者 [ selector, undefined, id]
 57 | 				match = rquickExpr.exec( selector );
 58 | 			}
 59 | 
 60 | 			// Match html or make sure no context is specified for #id
 61 | 			// 匹配 html 或者 没有指定上下文的 #id
 62 | 			// 其实是这样子  if ( match && (match[1] || match[2] && !context) ) {
 63 | 			// 如果 match 存在， 并且 (( match[1] 不是 undefined ) 或 ( match[2] 不是 undefined 且没有指定上下文 ))
 64 | 			// 如果 match[1] 是 undefined ， 那么 match[2] 必然不是 undefined 所以省去了对 match[2] 的判断
 65 | 			if ( match && (match[1] || !context) ) {
 66 | 
 67 | 				// HANDLE: $(html) -> $(array)
 68 |                 // 处理：$(html) -> $(数组)
 69 | 				if ( match[1] ) {
 70 | 					// 如果 context 是 jQuery对象 返回 context第一个元素(也就是原生js对象)，  否则 直接 使用 context
 71 | 					context = context instanceof jQuery ? context[0] : context;
 72 | 
 73 | 					// Option to run scripts is true for back-compat
 74 |                     // 运行脚本 选项设置为true 保证向后兼容
 75 | 					// Intentionally let the error be thrown if parseHTML is not present
 76 |                     // 如果 parseHTML 不存在，有意抛出错误
 77 | 					jQuery.merge( this, jQuery.parseHTML(
 78 | 						match[1],
 79 | 						// 传入上下文
 80 | 						// 如果 context 存在 且 context 是节点
 81 | 						// 那么取 context.ownerDocument (有可能是frame) 作为上下文 (document.ownerDocument => null)
 82 | 						// 否则用 document
 83 | 						context && context.nodeType ? context.ownerDocument || context : document,
 84 | 						// 包含script标签
 85 | 						true
 86 | 					) );
 87 | 
 88 | 					// HANDLE: $(html, props)
 89 |                     // 处理：$(html,属性) 情况
 90 |                     // 判断是否简单的标签 且 context 的普通对象
 91 | 					if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
 92 |                         // 遍历context
 93 | 						for ( match in context ) {
 94 | 							// Properties of context are called as methods if possible
 95 |                             // 可能context的属性是方法
 96 | 							if ( jQuery.isFunction( this[ match ] ) ) {
 97 |                                 // 调用方法
 98 | 								this[ match ]( context[ match ] );
 99 | 
100 | 							// ...and otherwise set as attributes
101 |                             // 设置属性
102 | 							} else {
103 | 								this.attr( match, context[ match ] );
104 | 							}
105 | 						}
106 | 					}
107 | 
108 |                     // 返回jQuery对象
109 | 					return this;
110 | 
111 | 				// HANDLE: $(#id)
112 | 				// 处理：id的情况
113 |                 } else {
114 |                     // 直接通过  getElementById 获取元素
115 | 					elem = document.getElementById( match[2] );
116 | 
117 | 					// Support: Blackberry 4.6
118 | 					// gEBID returns nodes no longer in the document (#6963)
119 |                     // 通过id获取的节点元素不在文档中（有可能在fragment）
120 | 					if ( elem && elem.parentNode ) {
121 | 						// Inject the element directly into the jQuery object
122 |                         // 将元素注入到jQuery对象
123 | 						this.length = 1;
124 | 						this[0] = elem;
125 | 					}
126 | 
127 |                     // 通过id获取的元素 context为 document
128 | 					this.context = document;
129 |                     // 保存 选择器
130 | 					this.selector = selector;
131 |                     // 返回jQuery对象
132 | 					return this;
133 | 				}
134 | 
135 | 			// HANDLE: $(expr, $(...))
136 | 			// 处理：$(选择器，jQuery对象上下文)
137 |             // 如果不存在 context 而在  rootjQuery 中find selector
138 |             // 如果context存在且context.jquery存在时，认为context为jQuery对象且在其find selector
139 |             } else if ( !context || context.jquery ) {
140 | 				return ( context || rootjQuery ).find( selector );
141 | 
142 | 			// HANDLE: $(expr, context)
143 |             // $(选择器，上下文)
144 | 			// (which is just equivalent to: $(context).find(expr)
145 |             // 这相当于$(context).find(expr)
146 | 			} else {
147 |                 // 通过this.constructor也就是jQuery将context转化成jquery对象再 find　选择器
148 | 				return this.constructor( context ).find( selector );
149 | 			}
150 | 
151 | 		// HANDLE: $(DOMElement)
152 | 		// 处理：$(dom元素)
153 |         // 如果元素有.nodeType属性 那么就是单个元素
154 |         } else if ( selector.nodeType ) {
155 |             // 保存元素以及上下文
156 | 			this.context = this[0] = selector;
157 |             // 设置jQuery对象的length
158 | 			this.length = 1;
159 |             // 返回jQuery对象
160 | 			return this;
161 | 
162 | 		// HANDLE: $(function)
163 |         // 处理： $(函数)
164 | 		// Shortcut for document ready
165 |         // document ready 的快捷方式
166 | 		} else if ( jQuery.isFunction( selector ) ) {
167 |             // 如果document ready不为空也就是存在
168 | 			return rootjQuery.ready !== undefined ?
169 |                 // 那么将selector传入document ready事件中
170 | 				rootjQuery.ready( selector ) :
171 | 				// Execute immediately if ready is not present
172 |                 // 如果 ready 不存在则传入jQuery并立即执行函数
173 | 				selector( jQuery );
174 | 		}
175 | 
176 |         // 如果 selector 不为 undefined
177 | 		if ( selector.selector !== undefined ) {
178 |             // 保存 选择器 以及  上下文
179 | 			this.selector = selector.selector;
180 | 			this.context = selector.context;
181 | 		}
182 | 
183 |         // 处理 []、object（类数组）
184 |         // 最后只能将 selector 合并到 this（jQuery对象中）
185 | 		return jQuery.makeArray( selector, this );
186 | 	};
187 | 
188 | // Give the init function the jQuery prototype for later instantiation
189 | // 给init方法实例化的jQuery原型
190 | // 由于jQuery对象是由init函数构造，修正原型的指向为jQuery.prototype
191 | init.prototype = jQuery.fn;
192 | 
193 | // Initialize central reference
194 | // 初始化document对象为jQuery对象
195 | // 多次使用缓存起来
196 | rootjQuery = jQuery( document );
197 | 
198 | return init;
199 | 
200 | });
201 | 


--------------------------------------------------------------------------------
/deferred.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"./core",
  3 | 	"./var/slice",
  4 | 	"./callbacks"
  5 | ], function( jQuery, slice ) {
  6 | 
  7 | jQuery.extend({
  8 | 
  9 | 	Deferred: function( func ) {
 10 | 		// 映射关系
 11 | 		var tuples = [
 12 | 				// action, add listener, listener list, final state
 13 | 				// 转换状态(行为), 侦听器, 侦听器列表, 最终状态
 14 | 				// [ resolve | reject ] 的回调列表参数是 "once memory"，说明只能调用一次
 15 | 				[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
 16 | 				[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
 17 | 				[ "notify", "progress", jQuery.Callbacks("memory") ]
 18 | 			],
 19 | 
 20 | 
 21 | 			// 默认状态为 pending
 22 | 			state = "pending",
 23 | 			// 延迟对象(无状态转换)
 24 | 			promise = {
 25 | 				// 返回状态
 26 | 				state: function() {
 27 | 					return state;
 28 | 				},
 29 | 				// 当 [ done | fail ]  状态时执行 alwaysCallbacks
 30 | 				always: function() {
 31 | 					deferred.done( arguments ).fail( arguments );
 32 | 					return this;
 33 | 				},
 34 | 				// 延迟对象  [ done | fail | progress ] 时，调用处理程序
 35 | 				then: function( /* fnDone, fnFail, fnProgress */ ) {
 36 | 					var fns = arguments;
 37 | 					// 返回一个新的 $.Deferred().promise()
 38 | 					return jQuery.Deferred(function( newDefer ) {
 39 | 						jQuery.each( tuples, function( i, tuple ) {
 40 | 							// 当前项是函数时，将当前项给fn
 41 | 							var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
 42 | 							// deferred[ done | fail | progress ] for forwarding actions to newDefer
 43 | 							// 为 deferred[ done | fail | progress ] 添加一个处理函数
 44 | 							// 处理函数用于在 newDefer 的状态转换
 45 | 							deferred[ tuple[1] ](function() {
 46 | 								// 如果存在就执行 上下文为当前的延迟对象
 47 | 								var returned = fn && fn.apply( this, arguments );
 48 | 								// 如果返回值是一个延迟对象
 49 | 								if ( returned && jQuery.isFunction( returned.promise ) ) {
 50 | 									// 那么直接在 当前延迟对象[done | fail | progress]下添加 转换新延迟对象状态 的回调函数
 51 | 									returned.promise()
 52 | 										.done( newDefer.resolve )
 53 | 										.fail( newDefer.reject )
 54 | 										.progress( newDefer.notify );
 55 | 								// 如果返回值不是延迟对象
 56 | 								} else {
 57 | 									// 直接转换新延迟对象的状态
 58 | 									newDefer[ tuple[ 0 ] + "With" ](
 59 | 										this === promise ? newDefer.promise() : this,
 60 | 										fn ? [ returned ] : arguments
 61 | 									);
 62 | 								}
 63 | 							});
 64 | 						});
 65 | 						fns = null;
 66 | 					}).promise();
 67 | 				},
 68 | 				// Get a promise for this deferred
 69 | 				// If obj is provided, the promise aspect is added to the object
 70 | 				// 在 deferred 下获取一个 promise
 71 | 				// 如果 obj 存在，promise 合并到 object
 72 | 				promise: function( obj ) {
 73 | 					// 如果 obj 不为空时, 把 promise 合并到 obj
 74 | 					// 否则返回 promise 对象
 75 | 					return obj != null ? jQuery.extend( obj, promise ) : promise;
 76 | 				}
 77 | 			},
 78 | 			// 延迟对象
 79 | 			deferred = {};
 80 | 
 81 | 		// Keep pipe for back-compat
 82 | 		// 管道
 83 | 		promise.pipe = promise.then;
 84 | 
 85 | 		// Add list-specific methods
 86 | 		// 添加特定于延迟对象的方法
 87 | 		jQuery.each( tuples, function( i, tuple ) {
 88 | 			// 回调
 89 | 			var list = tuple[ 2 ],
 90 | 				// 状态  [ resolved | rejected ]
 91 | 				stateString = tuple[ 3 ];
 92 | 
 93 | 			// promise[ done | fail | progress ] = list.add
 94 | 			// 监听器 (其实就是 Callbacks 的 add)
 95 | 			promise[ tuple[1] ] = list.add;
 96 | 
 97 | 			// Handle state
 98 | 			// 处理状态
 99 | 			if ( stateString ) {
100 | 				// 在回调列表中增加 改变状态的三个函数
101 | 				list.add(function() {
102 | 					// state = [ resolved | rejected ]
103 | 					// 状态 只有 解决(resolved)  rejected(拒绝)
104 | 					// 修改状态
105 | 					state = stateString;
106 | 
107 | 				// [ reject_list | resolve_list ].disable; progress_list.lock
108 | 				// 当 i == 0 时 i ^ 1 == 1
109 | 				// 当 i == 1 时 i ^ 1 == 0
110 | 				// tuples[ i ^ 1 ][ 2 ].disable
111 | 				// 当 state == resolved 时 rejected 是 disable
112 | 				// 相反 state == rejected 时 resolved 也是 disable
113 | 				// tuples[ 2 ][ 2 ].lock
114 | 				// 当 state 转换 resolved | rejected
115 | 				// notify的状态是lock
116 | 				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
117 | 			}
118 | 
119 | 			// deferred[ resolve | reject | notify ]
120 | 			deferred[ tuple[0] ] = function() {
121 | 				// 当 this 指向 deferred
122 | 				// 将 context 改变 promise
123 | 				// 否则 context 用 this , 并把 arguments 传入调用
124 | 				deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
125 | 				return this;
126 | 			};
127 | 			// deferred[ resolveWith | rejectWith | notifyWith ]
128 | 			// 带 context 的 deferred[ resolve | reject | notify ]
129 | 			deferred[ tuple[0] + "With" ] = list.fireWith;
130 | 		});
131 | 
132 | 
133 | 
134 | 		// Make the deferred a promise
135 | 		// 把 promise 合并到 deferred
136 | 		promise.promise( deferred );
137 | 
138 | 		// Call given func if any
139 | 		// 如果参数 func 存在,就调用
140 | 		// 内部用于 $.then
141 | 		if ( func ) {
142 | 			func.call( deferred, deferred );
143 | 		}
144 | 
145 | 		// All done!
146 | 		return deferred;
147 | 	},
148 | 
149 | 	// Deferred helper
150 | 	// Deferred 辅助对象，用于多个延迟对象
151 | 	when: function( subordinate /* , ..., subordinateN */ ) {
152 | 		// i 用于遍历
153 | 		var i = 0,
154 | 			// 获取所有参数转换成数组
155 | 			resolveValues = slice.call( arguments ),
156 | 			// 参数的长度
157 | 			length = resolveValues.length,
158 | 
159 | 			// the count of uncompleted subordinates
160 | 			// 计数器 用于计数未完成状态数
161 | 			// 如果 参数的长度不为1 或者 第一个参数是延迟对象时  计数器为取参数的长度
162 | 			// 否则 计数器为 0
163 | 			remaining = length !== 1 ||
164 | 				( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
165 | 
166 | 			// the master Deferred.
167 | 			// If resolveValues consist of only a single Deferred, just use that.
168 | 			// 如果 计数器 为 1 只有一个延迟对象 ， 那么直接用这个延迟对象
169 | 			// 否则 创建一个延迟对象
170 | 			deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
171 | 
172 | 			// Update function for both resolve and progress values
173 | 			updateFunc = function( i, contexts, values ) {
174 | 				// 返回一个函数(形成闭包)
175 | 				return function( value ) {
176 | 					// 根据i值保存上下文以及参数在数组上
177 | 					// 数组是引用类型
178 | 					// contexts =>  progressContexts resolveContexts
179 | 					// values => resolveValues progressValues
180 | 					// 保存上下文(延迟对象的 promise)
181 | 					contexts[ i ] = this;
182 | 					// 保存转换状态时参数
183 | 					// 如果参数大于1，转换成数组
184 | 					values[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
185 | 					// 当处理 notify 时
186 | 					if ( values === progressValues ) {
187 | 						// 调用 $.when 下的 延迟对象的notify，并传入上下文
188 | 						deferred.notifyWith( contexts, values );
189 | 					// 当延迟对象 resolve 时 执行--操作
190 | 					// remaining 为 0 时
191 | 					} else if ( !( --remaining ) ) {
192 | 						// 调用 $.when 下的 延迟对象的 resolve，并传入上下文
193 | 						deferred.resolveWith( contexts, values );
194 | 					}
195 | 				};
196 | 			},
197 | 
198 | 			progressValues, progressContexts, resolveContexts;
199 | 
200 | 		// Add listeners to Deferred subordinates; treat others as resolved
201 | 		if ( length > 1 ) {
202 | 			// 根据长度创建 保存 progress 和 resolve 的上下文数组和值数组
203 | 			progressValues = new Array( length );
204 | 			progressContexts = new Array( length );
205 | 			resolveContexts = new Array( length );
206 | 			for ( ; i < length; i++ ) {
207 | 				// 如果是延迟对象
208 | 				if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
209 | 					resolveValues[ i ].promise()
210 | 						// 为每个延迟对象增加一个 done 的回调函数(由执行 updateFunc 返回一个函数)
211 | 						.done( updateFunc( i, resolveContexts, resolveValues ) )
212 | 						// 当其中一个延迟对象为fail时 直接 reject 延迟对象
213 | 						.fail( deferred.reject )
214 | 						// 为每个延迟对象增加一个 progress 的回调函数(由执行 updateFunc 返回一个函数)
215 | 						.progress( updateFunc( i, progressContexts, progressValues ) );
216 | 				} else {
217 | 					// 如果不是延迟对象，直接递减
218 | 					--remaining;
219 | 				}
220 | 			}
221 | 		}
222 | 
223 | 		// If we're not waiting on anything, resolve the master
224 | 		// 如果不需要等待，直接 resolve
225 | 		// 也就是说 延迟对象计算器 为 0 时
226 | 		if ( !remaining ) {
227 | 			// 传入上下文，和$.when的所有参数
228 | 			deferred.resolveWith( resolveContexts, resolveValues );
229 | 		}
230 | 
231 | 		// 返回延迟对象的 promise对象
232 | 		return deferred.promise();
233 | 	}
234 | });
235 | 
236 | return jQuery;
237 | });
238 | 


--------------------------------------------------------------------------------
/data/Data.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"../core",
  3 | 	"../var/rnotwhite",
  4 | 	"./accepts"
  5 | ], function( jQuery, rnotwhite ) {
  6 | 
  7 | function Data() {
  8 | 	// Support: Android<4,
  9 | 	// Old WebKit does not have Object.preventExtensions/freeze method,
 10 | 	// return new empty object instead with no [[set]] accessor
 11 | 	// 为 this.cache 添加一个 0 属性
 12 | 	// 返回一个空对象，而没有 [[set]] accessor
 13 | 	// 只能获取不能设置
 14 | 	// 用于不能设置 data 情况返回空对象
 15 | 	Object.defineProperty( this.cache = {}, 0, {
 16 | 		get: function() {
 17 | 			return {};
 18 | 		}
 19 | 	});
 20 | 
 21 | 	// expando 用于生成数据关联属性的唯一标识
 22 | 	// 类似 <div jQuery2110344250543936482250.1582788177630381="1"></div> 这种
 23 | 	// 实际是在 对象上添加
 24 | 	this.expando = jQuery.expando + Math.random();
 25 | }
 26 | // uid 用于生成数据关联属性值的唯一标识
 27 | // jQuery2110344250543936482250.1582788177630381="1"
 28 | // 每次使用时自增
 29 | Data.uid = 1;
 30 | // 确定一个对象是否可以添加数据缓存
 31 | Data.accepts = jQuery.acceptData;
 32 | 
 33 | Data.prototype = {
 34 | 	key: function( owner ) {
 35 | 		// We can accept data for non-element nodes in modern browsers,
 36 | 		// but we should not, see #8335.
 37 | 		// Always return the key for a frozen object.
 38 | 		// 在现代浏览器中可以接受非元素节点添加data
 39 | 		// 但是不应该出现这种情况，见  http://bugs.jquery.com/ticket/8335
 40 | 		// key永远返回0, 在cache取得一个不能被修改的空对象
 41 | 		if ( !Data.accepts( owner ) ) {
 42 | 			return 0;
 43 | 		}
 44 | 
 45 | 		//
 46 | 		var descriptor = {},
 47 | 			// Check if the owner object already has a cache key
 48 | 			// 检查对象是否有cache key
 49 | 			unlock = owner[ this.expando ];
 50 | 
 51 | 		// If not, create one
 52 | 		// 如果没有，创建一个
 53 | 		if ( !unlock ) {
 54 | 			// 取一个key值，并自增
 55 | 			unlock = Data.uid++;
 56 | 
 57 | 			// Secure it in a non-enumerable, non-writable property
 58 | 			// 定义不可枚举，不可写的属性，避免被修改
 59 | 			try {
 60 | 				descriptor[ this.expando ] = { value: unlock };
 61 | 				Object.defineProperties( owner, descriptor );
 62 | 
 63 | 			// Support: Android<4
 64 | 			// Fallback to a less secure definition
 65 | 			// 当不支持 defineProperties 时，回退到不安全的定义，使用 jQuery.extend 来完成
 66 | 			} catch ( e ) {
 67 | 				descriptor[ this.expando ] = unlock;
 68 | 				jQuery.extend( owner, descriptor );
 69 | 			}
 70 | 		}
 71 | 
 72 | 		// Ensure the cache object
 73 | 		// 确定是否有缓存对象
 74 | 		if ( !this.cache[ unlock ] ) {
 75 | 			// 如果没有创建一个空对象
 76 | 			this.cache[ unlock ] = {};
 77 | 		}
 78 | 
 79 | 		// 返回 key
 80 | 		return unlock;
 81 | 	},
 82 | 	set: function( owner, data, value ) {
 83 | 		var prop,
 84 | 			// There may be an unlock assigned to this node,
 85 | 			// if there is no entry for this "owner", create one inline
 86 | 			// and set the unlock as though an owner entry had always existed
 87 | 			// 有可能是有一个 unlock 分配给该节点
 88 | 			// 如果没有 owner 的信息，通过this.key()创建一个并设置 unlock，
 89 | 			// 使得 cache 存在
 90 | 			unlock = this.key( owner ),
 91 | 			cache = this.cache[ unlock ];
 92 | 
 93 | 		// Handle: [ owner, key, value ] args
 94 | 		// 处理 data 是字符串的情况
 95 | 		if ( typeof data === "string" ) {
 96 | 			// 直接设置值
 97 | 			cache[ data ] = value;
 98 | 
 99 | 		// Handle: [ owner, { properties } ] args
100 | 		// 处理 data 是 对象的情况
101 | 		} else {
102 | 			// Fresh assignments by object are shallow copied
103 | 			// 当 cache 为空时
104 | 			if ( jQuery.isEmptyObject( cache ) ) {
105 | 				// 使用 extend 浅拷贝
106 | 				jQuery.extend( this.cache[ unlock ], data );
107 | 			// Otherwise, copy the properties one-by-one to the cache object
108 | 			// 否则使用 for 一个一个的复制到缓存对象
109 | 			} else {
110 | 				for ( prop in data ) {
111 | 					cache[ prop ] = data[ prop ];
112 | 				}
113 | 			}
114 | 		}
115 | 		// 返回 owner 的 cache
116 | 		return cache;
117 | 	},
118 | 	get: function( owner, key ) {
119 | 		// Either a valid cache is found, or will be created.
120 | 		// New caches will be created and the unlock returned,
121 | 		// allowing direct access to the newly created
122 | 		// empty data object. A valid owner object must be provided.
123 | 		// 在缓存中查找，或者创建。
124 | 		// 将创建新的cache和unlock并返回，
125 | 		// 允许直接访问新创建的空数据对象
126 | 		// 必须提供一个有效的 owner
127 | 		var cache = this.cache[ this.key( owner ) ];
128 | 
129 | 		// 如果 key 不存在， 那么取得 cache
130 | 		// 否则从 cache 找到 key 对应的 value
131 | 		return key === undefined ?
132 | 			cache : cache[ key ];
133 | 	},
134 | 	access: function( owner, key, value ) {
135 | 		// 用于 owner 的 cache 临时存储
136 | 		var stored;
137 | 		// In cases where either:
138 | 		//
139 | 		//   1. No key was specified
140 | 		//   2. A string key was specified, but no value provided
141 | 		//
142 | 		// Take the "read" path and allow the get method to determine
143 | 		// which value to return, respectively either:
144 | 		//
145 | 		//   1. The entire cache object
146 | 		//   2. The data stored at the key
147 | 		// 以下情况：
148 | 		// 1. key 没有指定    2. 指定了 key ,没指定value
149 | 		// 采用 get 方法，get方法来确定返回值
150 | 		// 1. 整个缓存对象 2.指定 key 对应的 value
151 | 
152 | 		// 如果 key 为空 或者 指定了key没有指定 value
153 | 		if ( key === undefined ||
154 | 				((key && typeof key === "string") && value === undefined) ) {
155 | 
156 | 			// 取得 cache
157 | 			stored = this.get( owner, key );
158 | 
159 | 			// 如果 cache 不为 undefined 那么返回 cache
160 | 			// 否则按照 key 不为驼峰处理， 转换后获取 cache
161 | 			return stored !== undefined ?
162 | 				stored : this.get( owner, jQuery.camelCase(key) );
163 | 		}
164 | 
165 | 		// [*]When the key is not a string, or both a key and value
166 | 		// are specified, set or extend (existing objects) with either:
167 | 		//
168 | 		//   1. An object of properties
169 | 		//   2. A key and value
170 | 		// 当 key 不是一个字符串时 或 一键值对
171 | 		// 则设置 或者 扩展(现有对象)
172 | 		// 1. 对象  2. 一键值对
173 | 		this.set( owner, key, value );
174 | 
175 | 		// Since the "set" path can have two possible entry points
176 | 		// return the expected data based on which path was taken[*]
177 | 		// 由于 set 有两种类型的可能，
178 | 		// 预期返回的数据采用了哪一种可能
179 | 		// 如果 value 不为 空 返回 value 否则 key
180 | 		return value !== undefined ? value : key;
181 | 	},
182 | 	remove: function( owner, key ) {
183 | 		var i, name, camel,
184 | 			// 取得key
185 | 			unlock = this.key( owner ),
186 | 			// 取得缓存
187 | 			cache = this.cache[ unlock ];
188 | 
189 | 		// 如果 key 为空
190 | 		if ( key === undefined ) {
191 | 			// 清空缓存
192 | 			this.cache[ unlock ] = {};
193 | 
194 | 		} else {
195 | 			// Support array or space separated string of keys
196 | 			// 支持数组或者用空格隔开的字符串形式的 key
197 | 			// 如果是数组
198 | 			if ( jQuery.isArray( key ) ) {
199 | 				// If "name" is an array of keys...
200 | 				// When data is initially created, via ("key", "val") signature,
201 | 				// keys will be converted to camelCase.
202 | 				// Since there is no way to tell _how_ a key was added, remove
203 | 				// both plain key and camelCase key. #12786
204 | 				// This will only penalize the array argument path.
205 | 
206 | 				// 如果 name 是数组 key 的 keys
207 | 				// 将key通过map调用jQuery.camelCase转换成驼峰表示法
208 | 				// "add-num" => "addNum"
209 | 				// 并用 concat 连接起来
210 | 				// ["del-num","add-num"] => ["del-num","add-num","delNum","addNum"]
211 | 				name = key.concat( key.map( jQuery.camelCase ) );
212 | 			} else {
213 | 				// 如果 key 是单个的， 将 key 转换为驼峰表示法
214 | 				camel = jQuery.camelCase( key );
215 | 				// Try the string as a key before any manipulation
216 | 				// 尝试 key 是否为 cache 的属性
217 | 				if ( key in cache ) {
218 | 					// 组合起来
219 | 					name = [ key, camel ];
220 | 				} else {
221 | 					// If a key with the spaces exists, use it.
222 | 					// Otherwise, create an array by matching non-whitespace
223 | 					// 将转换后的key传给name
224 | 					name = camel;
225 | 					// 再次尝试 转换后的key是否是cache的属性
226 | 					name = name in cache ?
227 | 						// 如果是，那么保存为数组
228 | 						// 否则 转换后的key 当以空白为分隔符的多个key值  "addNum delNum"
229 | 						// 用正则 rnotwhite 通过 match 转换成数组 如果匹配失败使用空数组
230 | 						[ name ] : ( name.match( rnotwhite ) || [] );
231 | 				}
232 | 			}
233 | 
234 | 			// ["del-num","add-num"] => ["del-num","add-num","delNum","addNum"]
235 | 			// "add-num" => ["add-num","addNum"]
236 | 			// "addNum" => ["addNum"]
237 | 			// "add-num delNum" => ["addNum","delNum"]
238 | 			// !("xxx" in cache) => []
239 | 
240 | 			// 遍历处理后的key
241 | 			i = name.length;
242 | 			while ( i-- ) {
243 | 				// 删除对应的属性
244 | 				delete cache[ name[ i ] ];
245 | 			}
246 | 		}
247 | 	},
248 | 	// 此方法判断 owner 是否有data
249 | 	hasData: function( owner ) {
250 | 		// 求反判断是否为空对象
251 | 		return !jQuery.isEmptyObject(
252 | 			// 尝试去取 owner 的 cache ，如果没有返回 {}
253 | 			this.cache[ owner[ this.expando ] ] || {}
254 | 		);
255 | 	},
256 | 	// 此方法用于从 cache 取消关联
257 | 	discard: function( owner ) {
258 | 		// 如果 owner 的 cache 关联属性存在
259 | 		if ( owner[ this.expando ] ) {
260 | 			// 那么直接删除 cache 中 key(unlock) 属性
261 | 			delete this.cache[ owner[ this.expando ] ];
262 | 		}
263 | 	}
264 | };
265 | 
266 | return Data;
267 | });
268 | 


--------------------------------------------------------------------------------
/data.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"./core",
  3 | 	"./var/rnotwhite",
  4 | 	"./core/access",
  5 | 	"./data/var/dataPriv",
  6 | 	"./data/var/dataUser"
  7 | ], function( jQuery, rnotwhite, access, dataPriv, dataUser ) {
  8 | 
  9 | //	Implementation Summary
 10 | //
 11 | //	1. Enforce API surface and semantic compatibility with 1.9.x branch
 12 | //	2. Improve the module's maintainability by reducing the storage
 13 | //		paths to a single mechanism.
 14 | //	3. Use the same single mechanism to support "private" and "user" data.
 15 | //	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
 16 | //	5. Avoid exposing implementation details on user objects (eg. expando properties)
 17 | //	6. Provide a clear path for implementation upgrade to WeakMap in 2014
 18 | 
 19 | //	执行摘要
 20 | //
 21 | //	1. 强制API表现和语义 与 1.9.x分支兼容
 22 | //	2. 通过简单机制来减少路径，提高模块的可维护性
 23 | //	3. 使用相同的简单机制来支持"private" 和 "user"的数据.
 24 | //	4. 不会将"private"数据暴露给用户代码 (TODO: Drop _data, _removeData)
 25 | //	5. 避免在用户对象上暴露实现细节(例如. expando properties)
 26 | //	6. 在2014为实现升级到WeakMap(ES6)提供一个清晰的路径
 27 | 
 28 | 
 29 | // 匹配以{或[开头 内容为[A-Za-z0-9_][^A-Za-z0-9_] 以}或[结尾的字符串
 30 | var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
 31 |     // 匹配 A-Z
 32 | 	rmultiDash = /([A-Z])/g;
 33 | 
 34 | // 用于设置 HTML5 data-* 属性到cache中，并返回 属性值
 35 | function dataAttr( elem, key, data ) {
 36 | 	var name;
 37 | 
 38 | 	// If nothing was found internally, try to fetch any
 39 | 	// data from the HTML5 data-* attribute
 40 | 	// 如果在cache没有找到数据，
 41 |     // 尝试从  HTML5 data-* 属性中 查找
 42 | 
 43 |     // data 如果为空 且  元素类型为 节点
 44 | 	if ( data === undefined && elem.nodeType === 1 ) {
 45 |         // 将 key 转换成 HTML5 data-* 属性
 46 |         // addName => data-add-name
 47 | 		name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
 48 |         // 获取属性值
 49 | 		data = elem.getAttribute( name );
 50 | 
 51 |         // 如果 数据的类型为 string, 说明有其属性
 52 | 		if ( typeof data === "string" ) {
 53 | 			try {
 54 |                 // 尝试转换属性值成原始值
 55 | 				data = data === "true" ? true :
 56 | 					data === "false" ? false :
 57 | 					data === "null" ? null :
 58 | 					// Only convert to a number if it doesn't change the string
 59 |                     // 如果不会更改字符串，只转换为数字
 60 | 					+data + "" === data ? +data :
 61 |                     // rbrace 测试是否为 json 字符串，jQuery.parseJSON 来解析成 json
 62 | 					rbrace.test( data ) ? jQuery.parseJSON( data ) :
 63 |                     // 否则当是普通的字符串
 64 | 					data;
 65 | 			} catch ( e ) {}
 66 | 
 67 | 			// Make sure we set the data so it isn't changed later
 68 |             // 确定我们set data, 所以之后不会改变
 69 |             // "<div data-aaa='abc'></div>"
 70 |             // $($0).data('aaa')  => 'abc'
 71 |             // $($0).attr('data-aaa','xxx')
 72 |             // $($0).data('aaa')  => 'abc'
 73 | 			dataUser.set( elem, key, data );
 74 | 
 75 |         //否则 undefined
 76 | 		} else {
 77 | 			data = undefined;
 78 | 		}
 79 | 	}
 80 |     // 返回数据
 81 | 	return data;
 82 | }
 83 | 
 84 | jQuery.extend({
 85 |     // 判断是有 data
 86 | 	hasData: function( elem ) {
 87 |         // 从来 User 中判断，如果没有则在 Priv 中判断
 88 | 		return dataUser.hasData( elem ) || dataPriv.hasData( elem );
 89 | 	},
 90 | 
 91 |     // 设置或者获取 data
 92 | 	data: function( elem, name, data ) {
 93 |         // 通过 access 方法来做多功能操作
 94 | 		return dataUser.access( elem, name, data );
 95 | 	},
 96 | 
 97 |     // 删除 data
 98 | 	removeData: function( elem, name ) {
 99 |         // 从 User 中删除
100 | 		dataUser.remove( elem, name );
101 | 	},
102 | 
103 | 	// TODO: Now that all calls to _data and _removeData have been replaced
104 | 	// with direct calls to dataPriv methods, these can be deprecated.
105 |     // _data 和 _removeDate 已经被替换，这些可以被废弃，直接调用dataPriv的方法
106 | 
107 |     // 设置或者获取 dataPriv data
108 | 	_data: function( elem, name, data ) {
109 | 		return dataPriv.access( elem, name, data );
110 | 	},
111 |     // 删除 dataPriv data
112 | 	_removeData: function( elem, name ) {
113 | 		dataPriv.remove( elem, name );
114 | 	}
115 | });
116 | 
117 | jQuery.fn.extend({
118 | 	data: function( key, value ) {
119 | 		var i, name, data,
120 |             // 获取第一元素
121 | 			elem = this[ 0 ],
122 |             // 获取元素的所有的属性  attributes
123 | 			attrs = elem && elem.attributes;
124 | 		// Gets all values
125 |         // 如果没有key说明是获取所有的 value
126 | 		if ( key === undefined ) {
127 |             // 元素长度存在
128 | 			if ( this.length ) {
129 |                 // 获取所有的 cache data
130 | 				data = dataUser.get( elem );
131 | 
132 |                 // 如果是 元素 节点  并且是   "没有获取过" data-* 属性时
133 | 				if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
134 | 					i = attrs.length;
135 |                     // 遍历元素的 attributes的每个属性
136 | 					while ( i-- ) {
137 | 						// Support: IE11+
138 | 						// The attrs elements can be null (#14894)
139 | 						if ( attrs[ i ] ) {
140 | 							name = attrs[ i ].name;
141 |                             // 查找 data-* 的属性
142 | 							if ( name.indexOf( "data-" ) === 0 ) {
143 |                                 // 将元素转换为 驼峰的写法
144 | 								name = jQuery.camelCase( name.slice(5) );
145 |                                 // 获取 data-* 的属性值
146 | 								dataAttr( elem, name, data[ name ] );
147 | 							}
148 | 						}
149 | 					}
150 |                     // 将设置为 "获取过" data-* 属性
151 | 					dataPriv.set( elem, "hasDataAttrs", true );
152 | 				}
153 | 			}
154 | 
155 |             // 返回 data cache
156 | 			return data;
157 | 		}
158 | 
159 | 		// Sets multiple values
160 |         // 设置多个属性值
161 | 		if ( typeof key === "object" ) {
162 |             // 遍历jQuery对象
163 | 			return this.each(function() {
164 |                 // 为每一个dom元素设置 cache data
165 | 				dataUser.set( this, key );
166 | 			});
167 | 		}
168 | 
169 |         // 设置
170 | 		return access( this, function( value ) {
171 | 			var data,
172 |                 // 转驼峰
173 | 				camelKey = jQuery.camelCase( key );
174 | 
175 | 			// The calling jQuery object (element matches) is not empty
176 | 			// (and therefore has an element appears at this[ 0 ]) and the
177 | 			// `value` parameter was not undefined. An empty jQuery object
178 | 			// will result in `undefined` for elem = this[ 0 ] which will
179 | 			// throw an exception if an attempt to read a data cache is made.
180 |             // 调用的 jQuery对象(匹配的元素) 不为空
181 |             // (也因此会有一个元素在在 this[ 0 ] 上 )
182 |             // 且 value 不是 未定义
183 |             // 一个空的jQuery对象，将 elem = this[ 0 ] 会导致结果为 未定义
184 |             // 如果尝试去获取 数据缓存，会抛出一个异常。
185 | 			if ( elem && value === undefined ) {
186 | 				// Attempt to get data from the cache
187 | 				// with the key as-is
188 |                 // 尝试直接用 key 在 cache中获取
189 | 				data = dataUser.get( elem, key );
190 |                 // 如果不为空
191 | 				if ( data !== undefined ) {
192 |                     // 返回数据
193 |                     return data;
194 | 				}
195 | 
196 | 				// Attempt to get data from the cache
197 | 				// with the key camelized
198 |                 // 尝试用转换成的驼峰 key 在 cache 中获取
199 | 				data = dataUser.get( elem, camelKey );
200 |                 // 如果不为空
201 | 				if ( data !== undefined ) {
202 |                     // 返回数据
203 | 					return data;
204 | 				}
205 | 
206 | 				// Attempt to "discover" the data in
207 | 				// HTML5 custom data-* attrs
208 |                 // 尝试在 HTML5 自定义属性 data-* 中获取 data
209 | 				data = dataAttr( elem, camelKey, undefined );
210 |                 // 如果不为空
211 | 				if ( data !== undefined ) {
212 |                     // 返回数据
213 |                     return data;
214 | 				}
215 | 
216 | 				// We tried really hard, but the data doesn't exist.
217 |                 // 我们真的很努力，但是该数据不存在。
218 | 				return;
219 | 			}
220 | 
221 | 			// Set the data...
222 |             // 设置 data
223 |             // 遍历元素
224 | 			this.each(function() {
225 | 				// First, attempt to store a copy or reference of any
226 | 				// data that might've been store with a camelCased key.
227 |                 // 首先，尝试用 驼峰key 去复制或者是引用已存储的数据
228 | 				var data = dataUser.get( this, camelKey );
229 | 
230 | 				// For HTML5 data-* attribute interop, we have to
231 | 				// store property names with dashes in a camelCase form.
232 | 				// This might not apply to all properties...*
233 |                 // HTML5 data-* 属性互操作，
234 |                 // 我们不得不存储 驼峰key 的 属性名称
235 |                 // 这可能不适合所有的属性
236 | 				dataUser.set( this, camelKey, value );
237 | 
238 | 				// *... In the case of properties that might _actually_
239 | 				// have dashes, we need to also store a copy of that
240 | 				// unchanged property.
241 |                 // 在属性中有破折号的情况下，我们也需要存储副本
242 | 				if ( key.indexOf("-") !== -1 && data !== undefined ) {
243 | 					dataUser.set( this, key, value );
244 | 				}
245 | 			});
246 | 		}, null, value, arguments.length > 1, null, true );
247 | 	},
248 |     // 删除数据
249 | 	removeData: function( key ) {
250 |         // 遍历jQuery对象
251 | 		return this.each(function() {
252 |             // 为每一个元素删除 对应的 data
253 | 			dataUser.remove( this, key );
254 | 		});
255 | 	}
256 | });
257 | 
258 | return jQuery;
259 | });
260 | 


--------------------------------------------------------------------------------
/callbacks.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"./core",
  3 | 	"./var/rnotwhite"
  4 | ], function( jQuery, rnotwhite ) {
  5 | 
  6 | // String to Object options format cache
  7 | // 缓存对象
  8 | var optionsCache = {};
  9 | 
 10 | // Convert String-formatted options into Object-formatted ones and store in cache
 11 | // 转换 字符串格式的 options 参数 为 object格式并缓存
 12 | function createOptions( options ) {
 13 | 	// 将object和 optionsCache[x] 指向了同一个对象
 14 | 	// 用于在 optionsCache 缓存对象中查找已缓存的某个 options
 15 | 	// 例如 当首次options是 'once memory'时, 则缓存对象创建类似这样的属性 optionsCache['once memory'] = { once:true , memory:true }
 16 | 	// 而当再次使用同样的 string options 时，将从缓存对象里面取对应的参数不再创建
 17 | 	var object = optionsCache[ options ] = {};
 18 | 	// 通过正则匹配空格转成数组
 19 | 	// 再通过工具方法 each 遍历把对应的参数设置为 true 作为其属性
 20 | 	jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {
 21 | 		object[ flag ] = true;
 22 | 	});
 23 | 	// 最后返回参数对象
 24 | 	return object;
 25 | }
 26 | 
 27 | /*
 28 |  * Create a callback list using the following parameters:
 29 |  * 使用以下参数创建一个回调列表
 30 |  *
 31 |  *	options: an optional list of space-separated options that will change how
 32 |  *			the callback list behaves or a more traditional option object
 33 |  *  参数可以是以,号隔开的字符串形式或者是对象
 34 |  * By default a callback list will act like an event callback list and can be
 35 |  * "fired" multiple times.
 36 |  * 回调列表默认像事件回调列表一样可以多次触发
 37 |  *
 38 |  * Possible options:
 39 |  * 可选参数
 40 |  *
 41 |  *	once:			will ensure the callback list can only be fired once (like a Deferred)
 42 |  *  确保回调列表只执行一次
 43 |  *
 44 |  *	memory:			will keep track of previous values and will call any callback added
 45 |  *					after the list has been fired right away with the latest "memorized"
 46 |  *					values (like a Deferred)
 47 |  *  所谓"记忆",将跟踪之前的值，并会用在fire之后立即使用最新的"记忆"值并执行添加任何的回调
 48 |  *
 49 |  *	unique:			will ensure a callback can only be added once (no duplicate in the list)
 50 |  *  确保回调只能添加一次到列表中（不重复）
 51 |  *
 52 |  *	stopOnFalse:	interrupt callings when a callback returns false
 53 |  *  用于当callback返回false时中断后续执行
 54 |  *
 55 |  */
 56 | jQuery.Callbacks = function( options ) {
 57 | 
 58 | 	// Convert options from String-formatted to Object-formatted if needed
 59 | 	// (we check in cache first)
 60 | 	// 如果 options 为字符串
 61 | 	options = typeof options === "string" ?
 62 | 		// 那么尝试去缓存对象中取得参数，没有则通过createOptions来创建为object格式并缓存
 63 | 		( optionsCache[ options ] || createOptions( options ) ) :
 64 | 		// 如果不是字符串，那么直接使用工具方法 extend 来合并对象
 65 | 		jQuery.extend( {}, options );
 66 | 
 67 | 	var // Last fire value (for non-forgettable lists)
 68 |         // 最后觖发的值 (上下文以及参数)
 69 | 		memory,
 70 | 		// Flag to know if list was already fired
 71 |         // 标记列表的是否为执行过
 72 | 		fired,
 73 | 		// Flag to know if list is currently firing
 74 |         // 标记列表执行状态
 75 | 		firing,
 76 | 		// First callback to fire (used internally by add and fireWith)
 77 |         // 执行回调的起始位置
 78 | 		firingStart,
 79 | 		// End of the loop when firing
 80 |         // firing 循环结束，用于缓存列表长度
 81 | 		firingLength,
 82 | 		// Index of currently firing callback (modified by remove if needed)
 83 |         // 当前触发的回调函数的索引 （self.remove() 可能需要修改）
 84 | 		firingIndex,
 85 | 		// Actual callback list
 86 |         // 回调列表
 87 | 		list = [],
 88 | 		// Stack of fire calls for repeatable lists
 89 |         // 当 options.once 为 false 时， stack 为 []
 90 |         // 当 options.once 为 true 时， stack 为 false
 91 |         // stack 当是 [] 时， 用于保存 firing 的 上下文以及参数
 92 | 		stack = !options.once && [],
 93 | 		// Fire callbacks
 94 | 		// 执行回调
 95 | 		fire = function( data ) {
 96 | 			// 当 options.memory 为 true 时，保存 data (上下文以及参数)
 97 |             // 当 options.memory 为 false 时， 那么 保存的是 false
 98 | 			memory = options.memory && data;
 99 | 			// 标记为已经执行过
100 | 			fired = true;
101 | 			// 当 firingStart 不为 0 时 那么说明有 memory 操作，将列表 firingIndex 调整
102 | 			firingIndex = firingStart || 0;
103 |             // 重置为 0， 为下次 memory 操作
104 | 			firingStart = 0;
105 |             // 保存 firing时的列表长度
106 | 			firingLength = list.length;
107 | 			// fire start
108 | 			firing = true;
109 | 			for ( ; list && firingIndex < firingLength; firingIndex++ ) {
110 | 				// 当调用回调时返回值为 false 且 options.stopOnFalse 为 true 时
111 | 				if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false &&
112 | 					options.stopOnFalse ) {
113 | 
114 | 					// 将 memory 调为 false ，阻止后续 memory 操作
115 | 					memory = false; // To prevent further calls using add
116 | 					// 跳出循环
117 | 					break;
118 | 				}
119 | 			}
120 | 			// fire end
121 | 			firing = false;
122 | 			if ( list ) {
123 | 				// 当 stack 有值时保存了 上下文以及参数 ，当然 options.once 也为 false
124 | 				// options = { once : false }
125 | 				if ( stack ) {
126 | 					if ( stack.length ) {
127 | 						fire( stack.shift() );
128 | 					}
129 | 				// 如果能走到这里，那么当 options.once 为 true 时，options.memory 为 true 也不能改变 once 事实
130 | 				// options = { once : true, memory: true }
131 | 				} else if ( memory ) {
132 | 					// 所以把列表清空
133 | 					list = [];
134 | 				// 当 options.once 为 true 且 options.memory 为 false 时
135 | 				// options = { once : true }
136 | 				} else {
137 | 					// 那么就直接调用 self.disable() 禁止掉
138 | 					self.disable();
139 | 				}
140 | 			}
141 | 		},
142 | 		// Actual Callbacks object
143 | 		self = {
144 | 			// Add a callback or a collection of callbacks to the list
145 | 			// 添加一个回调或回调集合到列表中
146 | 			add: function() {
147 | 				if ( list ) {
148 | 					// First, we save the current length
149 | 					// 首先，我们先保存当前列表的长度
150 | 					var start = list.length;
151 | 					// 用于在添加回调到列表
152 | 					(function add( args ) {
153 | 						jQuery.each( args, function( _, arg ) {
154 | 							// 检测arg的类型
155 | 							var type = jQuery.type( arg );
156 | 							// 函数
157 | 							if ( type === "function" ) {
158 | 								// 当 options.unique 为 false 时 或者
159 | 								// 当 options.unique 为 true , 且列表中不存在arg 时
160 | 								if ( !options.unique || !self.has( arg ) ) {
161 | 									// 将arg push进list
162 | 									list.push( arg );
163 | 								}
164 | 								// arg是数组的情况，如[a,b,c]
165 | 							} else if ( arg && arg.length && type !== "string" ) {
166 | 								// Inspect recursively
167 | 								// 递归
168 | 								add( arg );
169 | 							}
170 | 						});
171 | 					// 将所有的参数传入
172 | 					})( arguments );
173 | 					// Do we need to add the callbacks to the
174 | 					// current firing batch?
175 | 					// 当我们需要在当前触发处理中时添加callbacks时
176 | 					// 如 function a(){  } function b(){ cb.add(a); } cb.add(b); cb.fire();
177 | 					if ( firing ) {
178 | 						// 修正firing的列表长度
179 | 						firingLength = list.length;
180 | 
181 | 					// With memory, if we're not firing then
182 | 					// we should call right away
183 | 					// 如果 memory 存在 那么说明 options.memory 为true
184 | 					// 不在 firing 时应该立即调用
185 | 					} else if ( memory ) {
186 | 						// 修改触发开始的位置
187 | 						firingStart = start;
188 | 						// 将 memory (上下文以及回调参数) 传入执行
189 | 						fire( memory );
190 | 					}
191 | 				}
192 | 				return this;
193 | 			},
194 | 			// Remove a callback from the list
195 | 			// 从列表删除指定的回调
196 | 			remove: function() {
197 | 				if ( list ) {
198 | 					jQuery.each( arguments, function( _, arg ) {
199 | 						// 保存对应的索引位置也作为循环时 inArray 的起始检索位置
200 | 						var index;
201 | 						//  使用循环确保没有重复回调
202 | 						while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
203 | 							// 通过 splice 删除
204 | 							list.splice( index, 1 );
205 | 							// Handle firing indexes
206 | 							// 处理 firing 的情况
207 | 							if ( firing ) {
208 | 								// 删除一项时
209 | 								if ( index <= firingLength ) {
210 | 									// 应该把 firingLength 减1
211 | 									firingLength--;
212 | 								}
213 | 								// 当索引位置 小于等于 当前 firingIndex 时
214 | 								if ( index <= firingIndex ) {
215 | 									// 应该把当前 firingIndex 减1
216 | 									firingIndex--;
217 | 								}
218 | 							}
219 | 						}
220 | 					});
221 | 				}
222 | 				return this;
223 | 			},
224 | 			// Check if a given callback is in the list.
225 | 			// 检测回调是否在列表中
226 | 			// If no argument is given, return whether or not list has callbacks attached.
227 | 			// 如果没有参数就返回列表中是否有回调
228 | 			has: function( fn ) {
229 | 				return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );
230 | 			},
231 | 			// Remove all callbacks from the list
232 | 			// 删除列表中所有回调
233 | 			empty: function() {
234 | 				list = [];
235 | 				firingLength = 0;
236 | 				return this;
237 | 			},
238 | 			// Have the list do nothing anymore
239 | 			// 禁用回调列表中的回调
240 | 			disable: function() {
241 | 				list = stack = memory = undefined;
242 | 				return this;
243 | 			},
244 | 			// Is it disabled?
245 | 			// 确定回调列表是否已被禁用
246 | 			disabled: function() {
247 | 				return !list;
248 | 			},
249 | 			// Lock the list in its current state
250 | 			// 锁定回调列表的当前状态
251 | 			lock: function() {
252 | 				// 将 stack 设为 undefined，阻止后续的 cb.fire() 操作
253 | 				stack = undefined;
254 | 				// 当 memory 为 false
255 | 				if ( !memory ) {
256 | 					// 禁用回调
257 | 					self.disable();
258 | 				}
259 | 				return this;
260 | 			},
261 | 			// Is it locked?
262 | 			// 确定回调列表是否已被锁定
263 | 			locked: function() {
264 | 				return !stack;
265 | 			},
266 | 			// Call all callbacks with the given context and arguments
267 | 			// 访问给定的上下文和参数列表中的所有回调
268 | 			fireWith: function( context, args ) {
269 | 				// list 不为 undefined 时( 可能被禁用 self.disable() )
270 | 				// fired用于标记是否至少执行过一次
271 | 				// 当 options.once 为 true 时，stack 为 false
272 | 				// 那么 当 fire 没有执行过
273 | 				// 或者 当 fire 至少执行过一次 且 options.once 不为 true ，也没有锁定回调列表( self.lock() )
274 | 				if ( list && ( !fired || stack ) ) {
275 | 					// 不存在args则用空数组
276 | 					args = args || [];
277 | 					// 把上下文以参数合并为一个数组
278 | 					args = [ context, args.slice ? args.slice() : args ];
279 | 					// 当 firing 时
280 | 					if ( firing ) {
281 | 						// 将 args (上下文以及参数) 压入栈中
282 | 						stack.push( args );
283 | 					// fire end 时
284 | 					} else {
285 | 						// 直接调用
286 | 						fire( args );
287 | 					}
288 | 				}
289 | 				return this;
290 | 			},
291 | 			// Call all the callbacks with the given arguments
292 | 			// 传入指定的参数调用所有的回调
293 | 			fire: function() {
294 | 				self.fireWith( this, arguments );
295 | 				return this;
296 | 			},
297 | 			// To know if the callbacks have already been called at least once
298 | 			// 确定回调是否至少已经调用一次
299 | 			fired: function() {
300 | 				return !!fired;
301 | 			}
302 | 		};
303 | 
304 | 	return self;
305 | };
306 | 
307 | return jQuery;
308 | });
309 | 


--------------------------------------------------------------------------------
/css.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"./core",
  3 | 	"./var/pnum",
  4 | 	"./core/access",
  5 | 	"./css/var/rmargin",
  6 | 	"./css/var/rnumnonpx",
  7 | 	"./css/var/cssExpand",
  8 | 	"./css/var/isHidden",
  9 | 	"./css/var/getStyles",
 10 | 	"./css/curCSS",
 11 | 	"./css/defaultDisplay",
 12 | 	"./css/addGetHookIf",
 13 | 	"./css/support",
 14 | 	"./data/var/dataPriv",
 15 | 
 16 | 	"./core/init",
 17 | 	"./css/swap",
 18 | 	"./core/ready",
 19 | 	"./selector" // contains
 20 | ], function( jQuery, pnum, access, rmargin, rnumnonpx, cssExpand, isHidden,
 21 | 	getStyles, curCSS, defaultDisplay, addGetHookIf, support, dataPriv ) {
 22 | 
 23 | var
 24 | 	// Swappable if display is none or starts with table
 25 | 	// except "table", "table-cell", or "table-caption"
 26 | 	// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
 27 | 	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
 28 | 	rnumsplit = new RegExp( "^(" + pnum + ")(.*)$", "i" ),
 29 | 	rrelNum = new RegExp( "^([+-])=(" + pnum + ")", "i" ),
 30 | 
 31 | 	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
 32 | 	cssNormalTransform = {
 33 | 		letterSpacing: "0",
 34 | 		fontWeight: "400"
 35 | 	},
 36 | 
 37 | 	cssPrefixes = [ "Webkit", "O", "Moz", "ms" ];
 38 | 
 39 | // Return a css property mapped to a potentially vendor prefixed property
 40 | function vendorPropName( style, name ) {
 41 | 
 42 | 	// Shortcut for names that are not vendor prefixed
 43 | 	if ( name in style ) {
 44 | 		return name;
 45 | 	}
 46 | 
 47 | 	// Check for vendor prefixed names
 48 | 	var capName = name[0].toUpperCase() + name.slice(1),
 49 | 		origName = name,
 50 | 		i = cssPrefixes.length;
 51 | 
 52 | 	while ( i-- ) {
 53 | 		name = cssPrefixes[ i ] + capName;
 54 | 		if ( name in style ) {
 55 | 			return name;
 56 | 		}
 57 | 	}
 58 | 
 59 | 	return origName;
 60 | }
 61 | 
 62 | function setPositiveNumber( elem, value, subtract ) {
 63 | 	var matches = rnumsplit.exec( value );
 64 | 	return matches ?
 65 | 		// Guard against undefined "subtract", e.g., when used as in cssHooks
 66 | 		Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) :
 67 | 		value;
 68 | }
 69 | 
 70 | function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
 71 | 	var i = extra === ( isBorderBox ? "border" : "content" ) ?
 72 | 		// If we already have the right measurement, avoid augmentation
 73 | 		4 :
 74 | 		// Otherwise initialize for horizontal or vertical properties
 75 | 		name === "width" ? 1 : 0,
 76 | 
 77 | 		val = 0;
 78 | 
 79 | 	for ( ; i < 4; i += 2 ) {
 80 | 		// Both box models exclude margin, so add it if we want it
 81 | 		if ( extra === "margin" ) {
 82 | 			val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
 83 | 		}
 84 | 
 85 | 		if ( isBorderBox ) {
 86 | 			// border-box includes padding, so remove it if we want content
 87 | 			if ( extra === "content" ) {
 88 | 				val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
 89 | 			}
 90 | 
 91 | 			// At this point, extra isn't border nor margin, so remove border
 92 | 			if ( extra !== "margin" ) {
 93 | 				val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
 94 | 			}
 95 | 		} else {
 96 | 			// At this point, extra isn't content, so add padding
 97 | 			val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
 98 | 
 99 | 			// At this point, extra isn't content nor padding, so add border
100 | 			if ( extra !== "padding" ) {
101 | 				val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
102 | 			}
103 | 		}
104 | 	}
105 | 
106 | 	return val;
107 | }
108 | 
109 | function getWidthOrHeight( elem, name, extra ) {
110 | 
111 | 	// Start with offset property, which is equivalent to the border-box value
112 | 	var valueIsBorderBox = true,
113 | 		val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
114 | 		styles = getStyles( elem ),
115 | 		isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
116 | 
117 | 	// Some non-html elements return undefined for offsetWidth, so check for null/undefined
118 | 	// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
119 | 	// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
120 | 	if ( val <= 0 || val == null ) {
121 | 		// Fall back to computed then uncomputed css if necessary
122 | 		val = curCSS( elem, name, styles );
123 | 		if ( val < 0 || val == null ) {
124 | 			val = elem.style[ name ];
125 | 		}
126 | 
127 | 		// Computed unit is not pixels. Stop here and return.
128 | 		if ( rnumnonpx.test(val) ) {
129 | 			return val;
130 | 		}
131 | 
132 | 		// Check for style in case a browser which returns unreliable values
133 | 		// for getComputedStyle silently falls back to the reliable elem.style
134 | 		valueIsBorderBox = isBorderBox &&
135 | 			( support.boxSizingReliable() || val === elem.style[ name ] );
136 | 
137 | 		// Normalize "", auto, and prepare for extra
138 | 		val = parseFloat( val ) || 0;
139 | 	}
140 | 
141 | 	// Use the active box-sizing model to add/subtract irrelevant styles
142 | 	return ( val +
143 | 		augmentWidthOrHeight(
144 | 			elem,
145 | 			name,
146 | 			extra || ( isBorderBox ? "border" : "content" ),
147 | 			valueIsBorderBox,
148 | 			styles
149 | 		)
150 | 	) + "px";
151 | }
152 | 
153 | function showHide( elements, show ) {
154 | 	var display, elem, hidden,
155 | 		values = [],
156 | 		index = 0,
157 | 		length = elements.length;
158 | 
159 | 	for ( ; index < length; index++ ) {
160 | 		elem = elements[ index ];
161 | 		if ( !elem.style ) {
162 | 			continue;
163 | 		}
164 | 
165 | 		values[ index ] = dataPriv.get( elem, "olddisplay" );
166 | 		display = elem.style.display;
167 | 		if ( show ) {
168 | 			// Reset the inline display of this element to learn if it is
169 | 			// being hidden by cascaded rules or not
170 | 			if ( !values[ index ] && display === "none" ) {
171 | 				elem.style.display = "";
172 | 			}
173 | 
174 | 			// Set elements which have been overridden with display: none
175 | 			// in a stylesheet to whatever the default browser style is
176 | 			// for such an element
177 | 			if ( elem.style.display === "" && isHidden( elem ) ) {
178 | 				values[ index ] = dataPriv.access(
179 | 					elem,
180 | 					"olddisplay",
181 | 					defaultDisplay(elem.nodeName)
182 | 				);
183 | 			}
184 | 		} else {
185 | 			hidden = isHidden( elem );
186 | 
187 | 			if ( display !== "none" || !hidden ) {
188 | 				dataPriv.set(
189 | 					elem,
190 | 					"olddisplay",
191 | 					hidden ? display : jQuery.css( elem, "display" )
192 | 				);
193 | 			}
194 | 		}
195 | 	}
196 | 
197 | 	// Set the display of most of the elements in a second loop
198 | 	// to avoid the constant reflow
199 | 	for ( index = 0; index < length; index++ ) {
200 | 		elem = elements[ index ];
201 | 		if ( !elem.style ) {
202 | 			continue;
203 | 		}
204 | 		if ( !show || elem.style.display === "none" || elem.style.display === "" ) {
205 | 			elem.style.display = show ? values[ index ] || "" : "none";
206 | 		}
207 | 	}
208 | 
209 | 	return elements;
210 | }
211 | 
212 | jQuery.extend({
213 | 
214 | 	// Add in style property hooks for overriding the default
215 | 	// behavior of getting and setting a style property
216 | 	cssHooks: {
217 | 		opacity: {
218 | 			get: function( elem, computed ) {
219 | 				if ( computed ) {
220 | 
221 | 					// We should always get a number back from opacity
222 | 					var ret = curCSS( elem, "opacity" );
223 | 					return ret === "" ? "1" : ret;
224 | 				}
225 | 			}
226 | 		}
227 | 	},
228 | 
229 | 	// Don't automatically add "px" to these possibly-unitless properties
230 | 	cssNumber: {
231 | 		"columnCount": true,
232 | 		"fillOpacity": true,
233 | 		"flexGrow": true,
234 | 		"flexShrink": true,
235 | 		"fontWeight": true,
236 | 		"lineHeight": true,
237 | 		"opacity": true,
238 | 		"order": true,
239 | 		"orphans": true,
240 | 		"widows": true,
241 | 		"zIndex": true,
242 | 		"zoom": true
243 | 	},
244 | 
245 | 	// Add in properties whose names you wish to fix before
246 | 	// setting or getting the value
247 | 	cssProps: {
248 | 		"float": "cssFloat"
249 | 	},
250 | 
251 | 	// Get and set the style property on a DOM Node
252 | 	style: function( elem, name, value, extra ) {
253 | 
254 | 		// Don't set styles on text and comment nodes
255 | 		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
256 | 			return;
257 | 		}
258 | 
259 | 		// Make sure that we're working with the right name
260 | 		var ret, type, hooks,
261 | 			origName = jQuery.camelCase( name ),
262 | 			style = elem.style;
263 | 
264 | 		name = jQuery.cssProps[ origName ] ||
265 | 			( jQuery.cssProps[ origName ] = vendorPropName( style, origName ) );
266 | 
267 | 		// Gets hook for the prefixed version, then unprefixed version
268 | 		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
269 | 
270 | 		// Check if we're setting a value
271 | 		if ( value !== undefined ) {
272 | 			type = typeof value;
273 | 
274 | 			// Convert "+=" or "-=" to relative numbers (#7345)
275 | 			if ( type === "string" && (ret = rrelNum.exec( value )) ) {
276 | 				value = ( ret[1] + 1 ) * ret[2] + parseFloat( jQuery.css( elem, name ) );
277 | 				// Fixes bug #9237
278 | 				type = "number";
279 | 			}
280 | 
281 | 			// Make sure that null and NaN values aren't set (#7116)
282 | 			if ( value == null || value !== value ) {
283 | 				return;
284 | 			}
285 | 
286 | 			// If a number was passed in, add 'px' (except for certain CSS properties)
287 | 			if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
288 | 				value += "px";
289 | 			}
290 | 
291 | 			// Support: IE9-11+
292 | 			// background-* props affect original clone's values
293 | 			if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
294 | 				style[ name ] = "inherit";
295 | 			}
296 | 
297 | 			// If a hook was provided, use that value, otherwise just set the specified value
298 | 			if ( !hooks || !("set" in hooks) ||
299 | 				(value = hooks.set( elem, value, extra )) !== undefined ) {
300 | 
301 | 				style[ name ] = value;
302 | 			}
303 | 
304 | 		} else {
305 | 			// If a hook was provided get the non-computed value from there
306 | 			if ( hooks && "get" in hooks &&
307 | 				(ret = hooks.get( elem, false, extra )) !== undefined ) {
308 | 
309 | 				return ret;
310 | 			}
311 | 
312 | 			// Otherwise just get the value from the style object
313 | 			return style[ name ];
314 | 		}
315 | 	},
316 | 
317 | 	css: function( elem, name, extra, styles ) {
318 | 		var val, num, hooks,
319 | 			origName = jQuery.camelCase( name );
320 | 
321 | 		// Make sure that we're working with the right name
322 | 		name = jQuery.cssProps[ origName ] ||
323 | 			( jQuery.cssProps[ origName ] = vendorPropName( elem.style, origName ) );
324 | 
325 | 		// Try prefixed name followed by the unprefixed name
326 | 		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
327 | 
328 | 		// If a hook was provided get the computed value from there
329 | 		if ( hooks && "get" in hooks ) {
330 | 			val = hooks.get( elem, true, extra );
331 | 		}
332 | 
333 | 		// Otherwise, if a way to get the computed value exists, use that
334 | 		if ( val === undefined ) {
335 | 			val = curCSS( elem, name, styles );
336 | 		}
337 | 
338 | 		// Convert "normal" to computed value
339 | 		if ( val === "normal" && name in cssNormalTransform ) {
340 | 			val = cssNormalTransform[ name ];
341 | 		}
342 | 
343 | 		// Make numeric if forced or a qualifier was provided and val looks numeric
344 | 		if ( extra === "" || extra ) {
345 | 			num = parseFloat( val );
346 | 			return extra === true || jQuery.isNumeric( num ) ? num || 0 : val;
347 | 		}
348 | 		return val;
349 | 	}
350 | });
351 | 
352 | jQuery.each([ "height", "width" ], function( i, name ) {
353 | 	jQuery.cssHooks[ name ] = {
354 | 		get: function( elem, computed, extra ) {
355 | 			if ( computed ) {
356 | 
357 | 				// Certain elements can have dimension info if we invisibly show them
358 | 				// but it must have a current display style that would benefit
359 | 				return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
360 | 					elem.offsetWidth === 0 ?
361 | 						jQuery.swap( elem, cssShow, function() {
362 | 							return getWidthOrHeight( elem, name, extra );
363 | 						}) :
364 | 						getWidthOrHeight( elem, name, extra );
365 | 			}
366 | 		},
367 | 
368 | 		set: function( elem, value, extra ) {
369 | 			var styles = extra && getStyles( elem );
370 | 			return setPositiveNumber( elem, value, extra ?
371 | 				augmentWidthOrHeight(
372 | 					elem,
373 | 					name,
374 | 					extra,
375 | 					jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
376 | 					styles
377 | 				) : 0
378 | 			);
379 | 		}
380 | 	};
381 | });
382 | 
383 | // Support: Android 2.3
384 | jQuery.cssHooks.marginRight = addGetHookIf( support.reliableMarginRight,
385 | 	function( elem, computed ) {
386 | 		if ( computed ) {
387 | 			return jQuery.swap( elem, { "display": "inline-block" },
388 | 				curCSS, [ elem, "marginRight" ] );
389 | 		}
390 | 	}
391 | );
392 | 
393 | // These hooks are used by animate to expand properties
394 | jQuery.each({
395 | 	margin: "",
396 | 	padding: "",
397 | 	border: "Width"
398 | }, function( prefix, suffix ) {
399 | 	jQuery.cssHooks[ prefix + suffix ] = {
400 | 		expand: function( value ) {
401 | 			var i = 0,
402 | 				expanded = {},
403 | 
404 | 				// Assumes a single number if not a string
405 | 				parts = typeof value === "string" ? value.split(" ") : [ value ];
406 | 
407 | 			for ( ; i < 4; i++ ) {
408 | 				expanded[ prefix + cssExpand[ i ] + suffix ] =
409 | 					parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
410 | 			}
411 | 
412 | 			return expanded;
413 | 		}
414 | 	};
415 | 
416 | 	if ( !rmargin.test( prefix ) ) {
417 | 		jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
418 | 	}
419 | });
420 | 
421 | jQuery.fn.extend({
422 | 	css: function( name, value ) {
423 | 		return access( this, function( elem, name, value ) {
424 | 			var styles, len,
425 | 				map = {},
426 | 				i = 0;
427 | 
428 | 			if ( jQuery.isArray( name ) ) {
429 | 				styles = getStyles( elem );
430 | 				len = name.length;
431 | 
432 | 				for ( ; i < len; i++ ) {
433 | 					map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
434 | 				}
435 | 
436 | 				return map;
437 | 			}
438 | 
439 | 			return value !== undefined ?
440 | 				jQuery.style( elem, name, value ) :
441 | 				jQuery.css( elem, name );
442 | 		}, name, value, arguments.length > 1 );
443 | 	},
444 | 	show: function() {
445 | 		return showHide( this, true );
446 | 	},
447 | 	hide: function() {
448 | 		return showHide( this );
449 | 	},
450 | 	toggle: function( state ) {
451 | 		if ( typeof state === "boolean" ) {
452 | 			return state ? this.show() : this.hide();
453 | 		}
454 | 
455 | 		return this.each(function() {
456 | 			if ( isHidden( this ) ) {
457 | 				jQuery( this ).show();
458 | 			} else {
459 | 				jQuery( this ).hide();
460 | 			}
461 | 		});
462 | 	}
463 | });
464 | 
465 | return jQuery;
466 | });
467 | 


--------------------------------------------------------------------------------
/effects.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"./core",
  3 | 	"./var/pnum",
  4 | 	"./css/var/cssExpand",
  5 | 	"./css/var/isHidden",
  6 | 	"./css/defaultDisplay",
  7 | 	"./data/var/dataPriv",
  8 | 
  9 | 	"./core/init",
 10 | 	"./effects/Tween",
 11 | 	"./queue",
 12 | 	"./css",
 13 | 	"./deferred",
 14 | 	"./traversing"
 15 | ], function( jQuery, pnum, cssExpand, isHidden, defaultDisplay, dataPriv ) {
 16 | 
 17 | var
 18 | 	fxNow, timerId,
 19 | 	rfxtypes = /^(?:toggle|show|hide)$/,
 20 | 	rfxnum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ),
 21 | 	rrun = /queueHooks$/,
 22 | 	animationPrefilters = [ defaultPrefilter ],
 23 | 	tweeners = {
 24 | 		"*": [ function( prop, value ) {
 25 | 			var tween = this.createTween( prop, value ),
 26 | 				target = tween.cur(),
 27 | 				parts = rfxnum.exec( value ),
 28 | 				unit = parts && parts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
 29 | 
 30 | 				// Starting value computation is required for potential unit mismatches
 31 | 				start = ( jQuery.cssNumber[ prop ] || unit !== "px" && +target ) &&
 32 | 					rfxnum.exec( jQuery.css( tween.elem, prop ) ),
 33 | 				scale = 1,
 34 | 				maxIterations = 20;
 35 | 
 36 | 			if ( start && start[ 3 ] !== unit ) {
 37 | 				// Trust units reported by jQuery.css
 38 | 				unit = unit || start[ 3 ];
 39 | 
 40 | 				// Make sure we update the tween properties later on
 41 | 				parts = parts || [];
 42 | 
 43 | 				// Iteratively approximate from a nonzero starting point
 44 | 				start = +target || 1;
 45 | 
 46 | 				do {
 47 | 					// If previous iteration zeroed out, double until we get *something*.
 48 | 					// Use string for doubling so we don't accidentally see scale as unchanged below
 49 | 					scale = scale || ".5";
 50 | 
 51 | 					// Adjust and apply
 52 | 					start = start / scale;
 53 | 					jQuery.style( tween.elem, prop, start + unit );
 54 | 
 55 | 				// Update scale, tolerating zero or NaN from tween.cur(),
 56 | 				// break the loop if scale is unchanged or perfect, or if we've just had enough
 57 | 				} while (
 58 | 					scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations
 59 | 				);
 60 | 			}
 61 | 
 62 | 			// Update tween properties
 63 | 			if ( parts ) {
 64 | 				start = tween.start = +start || +target || 0;
 65 | 				tween.unit = unit;
 66 | 				// If a +=/-= token was provided, we're doing a relative animation
 67 | 				tween.end = parts[ 1 ] ?
 68 | 					start + ( parts[ 1 ] + 1 ) * parts[ 2 ] :
 69 | 					+parts[ 2 ];
 70 | 			}
 71 | 
 72 | 			return tween;
 73 | 		} ]
 74 | 	};
 75 | 
 76 | function raf() {
 77 | 	if ( timerId ) {
 78 | 		window.requestAnimationFrame( raf );
 79 | 		jQuery.fx.tick();
 80 | 	}
 81 | }
 82 | 
 83 | // Animations created synchronously will run synchronously
 84 | function createFxNow() {
 85 | 	setTimeout(function() {
 86 | 		fxNow = undefined;
 87 | 	});
 88 | 	return ( fxNow = jQuery.now() );
 89 | }
 90 | 
 91 | // Generate parameters to create a standard animation
 92 | function genFx( type, includeWidth ) {
 93 | 	var which,
 94 | 		i = 0,
 95 | 		attrs = { height: type };
 96 | 
 97 | 	// If we include width, step value is 1 to do all cssExpand values,
 98 | 	// otherwise step value is 2 to skip over Left and Right
 99 | 	includeWidth = includeWidth ? 1 : 0;
100 | 	for ( ; i < 4 ; i += 2 - includeWidth ) {
101 | 		which = cssExpand[ i ];
102 | 		attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
103 | 	}
104 | 
105 | 	if ( includeWidth ) {
106 | 		attrs.opacity = attrs.width = type;
107 | 	}
108 | 
109 | 	return attrs;
110 | }
111 | 
112 | function createTween( value, prop, animation ) {
113 | 	var tween,
114 | 		collection = ( tweeners[ prop ] || [] ).concat( tweeners[ "*" ] ),
115 | 		index = 0,
116 | 		length = collection.length;
117 | 	for ( ; index < length; index++ ) {
118 | 		if ( (tween = collection[ index ].call( animation, prop, value )) ) {
119 | 
120 | 			// We're done with this property
121 | 			return tween;
122 | 		}
123 | 	}
124 | }
125 | 
126 | function defaultPrefilter( elem, props, opts ) {
127 | 	/* jshint validthis: true */
128 | 	var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay,
129 | 		anim = this,
130 | 		orig = {},
131 | 		style = elem.style,
132 | 		hidden = elem.nodeType && isHidden( elem ),
133 | 		dataShow = dataPriv.get( elem, "fxshow" );
134 | 
135 | 	// Handle queue: false promises
136 | 	if ( !opts.queue ) {
137 | 		hooks = jQuery._queueHooks( elem, "fx" );
138 | 		if ( hooks.unqueued == null ) {
139 | 			hooks.unqueued = 0;
140 | 			oldfire = hooks.empty.fire;
141 | 			hooks.empty.fire = function() {
142 | 				if ( !hooks.unqueued ) {
143 | 					oldfire();
144 | 				}
145 | 			};
146 | 		}
147 | 		hooks.unqueued++;
148 | 
149 | 		anim.always(function() {
150 | 			// Ensure the complete handler is called before this completes
151 | 			anim.always(function() {
152 | 				hooks.unqueued--;
153 | 				if ( !jQuery.queue( elem, "fx" ).length ) {
154 | 					hooks.empty.fire();
155 | 				}
156 | 			});
157 | 		});
158 | 	}
159 | 
160 | 	// Height/width overflow pass
161 | 	if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
162 | 		// Make sure that nothing sneaks out
163 | 		// Record all 3 overflow attributes because IE9-10 do not
164 | 		// change the overflow attribute when overflowX and
165 | 		// overflowY are set to the same value
166 | 		opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
167 | 
168 | 		// Set display property to inline-block for height/width
169 | 		// animations on inline elements that are having width/height animated
170 | 		display = jQuery.css( elem, "display" );
171 | 
172 | 		// Test default display if display is currently "none"
173 | 		checkDisplay = display === "none" ?
174 | 			dataPriv.get( elem, "olddisplay" ) || defaultDisplay( elem.nodeName ) : display;
175 | 
176 | 		if ( checkDisplay === "inline" && jQuery.css( elem, "float" ) === "none" ) {
177 | 			style.display = "inline-block";
178 | 		}
179 | 	}
180 | 
181 | 	if ( opts.overflow ) {
182 | 		style.overflow = "hidden";
183 | 		anim.always(function() {
184 | 			style.overflow = opts.overflow[ 0 ];
185 | 			style.overflowX = opts.overflow[ 1 ];
186 | 			style.overflowY = opts.overflow[ 2 ];
187 | 		});
188 | 	}
189 | 
190 | 	// show/hide pass
191 | 	for ( prop in props ) {
192 | 		value = props[ prop ];
193 | 		if ( rfxtypes.exec( value ) ) {
194 | 			delete props[ prop ];
195 | 			toggle = toggle || value === "toggle";
196 | 			if ( value === ( hidden ? "hide" : "show" ) ) {
197 | 
198 | 				// If there is dataShow left over from a stopped hide or show
199 | 				// and we are going to proceed with show, we should pretend to be hidden
200 | 				if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
201 | 					hidden = true;
202 | 				} else {
203 | 					continue;
204 | 				}
205 | 			}
206 | 			orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
207 | 
208 | 		// Any non-fx value stops us from restoring the original display value
209 | 		} else {
210 | 			display = undefined;
211 | 		}
212 | 	}
213 | 
214 | 	if ( !jQuery.isEmptyObject( orig ) ) {
215 | 		if ( dataShow ) {
216 | 			if ( "hidden" in dataShow ) {
217 | 				hidden = dataShow.hidden;
218 | 			}
219 | 		} else {
220 | 			dataShow = dataPriv.access( elem, "fxshow", {} );
221 | 		}
222 | 
223 | 		// Store state if its toggle - enables .stop().toggle() to "reverse"
224 | 		if ( toggle ) {
225 | 			dataShow.hidden = !hidden;
226 | 		}
227 | 		if ( hidden ) {
228 | 			jQuery( elem ).show();
229 | 		} else {
230 | 			anim.done(function() {
231 | 				jQuery( elem ).hide();
232 | 			});
233 | 		}
234 | 		anim.done(function() {
235 | 			var prop;
236 | 
237 | 			dataPriv.remove( elem, "fxshow" );
238 | 			for ( prop in orig ) {
239 | 				jQuery.style( elem, prop, orig[ prop ] );
240 | 			}
241 | 		});
242 | 		for ( prop in orig ) {
243 | 			tween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
244 | 
245 | 			if ( !( prop in dataShow ) ) {
246 | 				dataShow[ prop ] = tween.start;
247 | 				if ( hidden ) {
248 | 					tween.end = tween.start;
249 | 					tween.start = prop === "width" || prop === "height" ? 1 : 0;
250 | 				}
251 | 			}
252 | 		}
253 | 
254 | 	// If this is a noop like .hide().hide(), restore an overwritten display value
255 | 	} else if ( (display === "none" ? defaultDisplay( elem.nodeName ) : display) === "inline" ) {
256 | 		style.display = display;
257 | 	}
258 | }
259 | 
260 | function propFilter( props, specialEasing ) {
261 | 	var index, name, easing, value, hooks;
262 | 
263 | 	// camelCase, specialEasing and expand cssHook pass
264 | 	for ( index in props ) {
265 | 		name = jQuery.camelCase( index );
266 | 		easing = specialEasing[ name ];
267 | 		value = props[ index ];
268 | 		if ( jQuery.isArray( value ) ) {
269 | 			easing = value[ 1 ];
270 | 			value = props[ index ] = value[ 0 ];
271 | 		}
272 | 
273 | 		if ( index !== name ) {
274 | 			props[ name ] = value;
275 | 			delete props[ index ];
276 | 		}
277 | 
278 | 		hooks = jQuery.cssHooks[ name ];
279 | 		if ( hooks && "expand" in hooks ) {
280 | 			value = hooks.expand( value );
281 | 			delete props[ name ];
282 | 
283 | 			// Not quite $.extend, this won't overwrite existing keys.
284 | 			// Reusing 'index' because we have the correct "name"
285 | 			for ( index in value ) {
286 | 				if ( !( index in props ) ) {
287 | 					props[ index ] = value[ index ];
288 | 					specialEasing[ index ] = easing;
289 | 				}
290 | 			}
291 | 		} else {
292 | 			specialEasing[ name ] = easing;
293 | 		}
294 | 	}
295 | }
296 | 
297 | function Animation( elem, properties, options ) {
298 | 	var result,
299 | 		stopped,
300 | 		index = 0,
301 | 		length = animationPrefilters.length,
302 | 		deferred = jQuery.Deferred().always( function() {
303 | 			// Don't match elem in the :animated selector
304 | 			delete tick.elem;
305 | 		}),
306 | 		tick = function() {
307 | 			if ( stopped ) {
308 | 				return false;
309 | 			}
310 | 			var currentTime = fxNow || createFxNow(),
311 | 				remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
312 | 				// Support: Android 2.3
313 | 				// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
314 | 				temp = remaining / animation.duration || 0,
315 | 				percent = 1 - temp,
316 | 				index = 0,
317 | 				length = animation.tweens.length;
318 | 
319 | 			for ( ; index < length ; index++ ) {
320 | 				animation.tweens[ index ].run( percent );
321 | 			}
322 | 
323 | 			deferred.notifyWith( elem, [ animation, percent, remaining ]);
324 | 
325 | 			if ( percent < 1 && length ) {
326 | 				return remaining;
327 | 			} else {
328 | 				deferred.resolveWith( elem, [ animation ] );
329 | 				return false;
330 | 			}
331 | 		},
332 | 		animation = deferred.promise({
333 | 			elem: elem,
334 | 			props: jQuery.extend( {}, properties ),
335 | 			opts: jQuery.extend( true, { specialEasing: {} }, options ),
336 | 			originalProperties: properties,
337 | 			originalOptions: options,
338 | 			startTime: fxNow || createFxNow(),
339 | 			duration: options.duration,
340 | 			tweens: [],
341 | 			createTween: function( prop, end ) {
342 | 				var tween = jQuery.Tween( elem, animation.opts, prop, end,
343 | 						animation.opts.specialEasing[ prop ] || animation.opts.easing );
344 | 				animation.tweens.push( tween );
345 | 				return tween;
346 | 			},
347 | 			stop: function( gotoEnd ) {
348 | 				var index = 0,
349 | 					// If we are going to the end, we want to run all the tweens
350 | 					// otherwise we skip this part
351 | 					length = gotoEnd ? animation.tweens.length : 0;
352 | 				if ( stopped ) {
353 | 					return this;
354 | 				}
355 | 				stopped = true;
356 | 				for ( ; index < length ; index++ ) {
357 | 					animation.tweens[ index ].run( 1 );
358 | 				}
359 | 
360 | 				// Resolve when we played the last frame; otherwise, reject
361 | 				if ( gotoEnd ) {
362 | 					deferred.resolveWith( elem, [ animation, gotoEnd ] );
363 | 				} else {
364 | 					deferred.rejectWith( elem, [ animation, gotoEnd ] );
365 | 				}
366 | 				return this;
367 | 			}
368 | 		}),
369 | 		props = animation.props;
370 | 
371 | 	propFilter( props, animation.opts.specialEasing );
372 | 
373 | 	for ( ; index < length ; index++ ) {
374 | 		result = animationPrefilters[ index ].call( animation, elem, props, animation.opts );
375 | 		if ( result ) {
376 | 			return result;
377 | 		}
378 | 	}
379 | 
380 | 	jQuery.map( props, createTween, animation );
381 | 
382 | 	if ( jQuery.isFunction( animation.opts.start ) ) {
383 | 		animation.opts.start.call( elem, animation );
384 | 	}
385 | 
386 | 	jQuery.fx.timer(
387 | 		jQuery.extend( tick, {
388 | 			elem: elem,
389 | 			anim: animation,
390 | 			queue: animation.opts.queue
391 | 		})
392 | 	);
393 | 
394 | 	// attach callbacks from options
395 | 	return animation.progress( animation.opts.progress )
396 | 		.done( animation.opts.done, animation.opts.complete )
397 | 		.fail( animation.opts.fail )
398 | 		.always( animation.opts.always );
399 | }
400 | 
401 | jQuery.Animation = jQuery.extend( Animation, {
402 | 
403 | 	tweener: function( props, callback ) {
404 | 		if ( jQuery.isFunction( props ) ) {
405 | 			callback = props;
406 | 			props = [ "*" ];
407 | 		} else {
408 | 			props = props.split(" ");
409 | 		}
410 | 
411 | 		var prop,
412 | 			index = 0,
413 | 			length = props.length;
414 | 
415 | 		for ( ; index < length ; index++ ) {
416 | 			prop = props[ index ];
417 | 			tweeners[ prop ] = tweeners[ prop ] || [];
418 | 			tweeners[ prop ].unshift( callback );
419 | 		}
420 | 	},
421 | 
422 | 	prefilter: function( callback, prepend ) {
423 | 		if ( prepend ) {
424 | 			animationPrefilters.unshift( callback );
425 | 		} else {
426 | 			animationPrefilters.push( callback );
427 | 		}
428 | 	}
429 | });
430 | 
431 | jQuery.speed = function( speed, easing, fn ) {
432 | 	var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
433 | 		complete: fn || !fn && easing ||
434 | 			jQuery.isFunction( speed ) && speed,
435 | 		duration: speed,
436 | 		easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
437 | 	};
438 | 
439 | 	// Go to the end state if fx are off or if document is hidden
440 | 	if ( jQuery.fx.off || document.hidden ) {
441 | 		opt.duration = 0;
442 | 
443 | 	} else {
444 | 		opt.duration = typeof opt.duration === "number" ?
445 | 			opt.duration : opt.duration in jQuery.fx.speeds ?
446 | 				jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
447 | 	}
448 | 
449 | 	// Normalize opt.queue - true/undefined/null -> "fx"
450 | 	if ( opt.queue == null || opt.queue === true ) {
451 | 		opt.queue = "fx";
452 | 	}
453 | 
454 | 	// Queueing
455 | 	opt.old = opt.complete;
456 | 
457 | 	opt.complete = function() {
458 | 		if ( jQuery.isFunction( opt.old ) ) {
459 | 			opt.old.call( this );
460 | 		}
461 | 
462 | 		if ( opt.queue ) {
463 | 			jQuery.dequeue( this, opt.queue );
464 | 		}
465 | 	};
466 | 
467 | 	return opt;
468 | };
469 | 
470 | jQuery.fn.extend({
471 | 	fadeTo: function( speed, to, easing, callback ) {
472 | 
473 | 		// Show any hidden elements after setting opacity to 0
474 | 		return this.filter( isHidden ).css( "opacity", 0 ).show()
475 | 
476 | 			// Animate to the value specified
477 | 			.end().animate({ opacity: to }, speed, easing, callback );
478 | 	},
479 | 	animate: function( prop, speed, easing, callback ) {
480 | 		var empty = jQuery.isEmptyObject( prop ),
481 | 			optall = jQuery.speed( speed, easing, callback ),
482 | 			doAnimation = function() {
483 | 				// Operate on a copy of prop so per-property easing won't be lost
484 | 				var anim = Animation( this, jQuery.extend( {}, prop ), optall );
485 | 
486 | 				// Empty animations, or finishing resolves immediately
487 | 				if ( empty || dataPriv.get( this, "finish" ) ) {
488 | 					anim.stop( true );
489 | 				}
490 | 			};
491 | 			doAnimation.finish = doAnimation;
492 | 
493 | 		return empty || optall.queue === false ?
494 | 			this.each( doAnimation ) :
495 | 			this.queue( optall.queue, doAnimation );
496 | 	},
497 | 	stop: function( type, clearQueue, gotoEnd ) {
498 | 		var stopQueue = function( hooks ) {
499 | 			var stop = hooks.stop;
500 | 			delete hooks.stop;
501 | 			stop( gotoEnd );
502 | 		};
503 | 
504 | 		if ( typeof type !== "string" ) {
505 | 			gotoEnd = clearQueue;
506 | 			clearQueue = type;
507 | 			type = undefined;
508 | 		}
509 | 		if ( clearQueue && type !== false ) {
510 | 			this.queue( type || "fx", [] );
511 | 		}
512 | 
513 | 		return this.each(function() {
514 | 			var dequeue = true,
515 | 				index = type != null && type + "queueHooks",
516 | 				timers = jQuery.timers,
517 | 				data = dataPriv.get( this );
518 | 
519 | 			if ( index ) {
520 | 				if ( data[ index ] && data[ index ].stop ) {
521 | 					stopQueue( data[ index ] );
522 | 				}
523 | 			} else {
524 | 				for ( index in data ) {
525 | 					if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
526 | 						stopQueue( data[ index ] );
527 | 					}
528 | 				}
529 | 			}
530 | 
531 | 			for ( index = timers.length; index--; ) {
532 | 				if ( timers[ index ].elem === this &&
533 | 					(type == null || timers[ index ].queue === type) ) {
534 | 
535 | 					timers[ index ].anim.stop( gotoEnd );
536 | 					dequeue = false;
537 | 					timers.splice( index, 1 );
538 | 				}
539 | 			}
540 | 
541 | 			// Start the next in the queue if the last step wasn't forced.
542 | 			// Timers currently will call their complete callbacks, which
543 | 			// will dequeue but only if they were gotoEnd.
544 | 			if ( dequeue || !gotoEnd ) {
545 | 				jQuery.dequeue( this, type );
546 | 			}
547 | 		});
548 | 	},
549 | 	finish: function( type ) {
550 | 		if ( type !== false ) {
551 | 			type = type || "fx";
552 | 		}
553 | 		return this.each(function() {
554 | 			var index,
555 | 				data = dataPriv.get( this ),
556 | 				queue = data[ type + "queue" ],
557 | 				hooks = data[ type + "queueHooks" ],
558 | 				timers = jQuery.timers,
559 | 				length = queue ? queue.length : 0;
560 | 
561 | 			// Enable finishing flag on private data
562 | 			data.finish = true;
563 | 
564 | 			// Empty the queue first
565 | 			jQuery.queue( this, type, [] );
566 | 
567 | 			if ( hooks && hooks.stop ) {
568 | 				hooks.stop.call( this, true );
569 | 			}
570 | 
571 | 			// Look for any active animations, and finish them
572 | 			for ( index = timers.length; index--; ) {
573 | 				if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
574 | 					timers[ index ].anim.stop( true );
575 | 					timers.splice( index, 1 );
576 | 				}
577 | 			}
578 | 
579 | 			// Look for any animations in the old queue and finish them
580 | 			for ( index = 0; index < length; index++ ) {
581 | 				if ( queue[ index ] && queue[ index ].finish ) {
582 | 					queue[ index ].finish.call( this );
583 | 				}
584 | 			}
585 | 
586 | 			// Turn off finishing flag
587 | 			delete data.finish;
588 | 		});
589 | 	}
590 | });
591 | 
592 | jQuery.each([ "toggle", "show", "hide" ], function( i, name ) {
593 | 	var cssFn = jQuery.fn[ name ];
594 | 	jQuery.fn[ name ] = function( speed, easing, callback ) {
595 | 		return speed == null || typeof speed === "boolean" ?
596 | 			cssFn.apply( this, arguments ) :
597 | 			this.animate( genFx( name, true ), speed, easing, callback );
598 | 	};
599 | });
600 | 
601 | // Generate shortcuts for custom animations
602 | jQuery.each({
603 | 	slideDown: genFx("show"),
604 | 	slideUp: genFx("hide"),
605 | 	slideToggle: genFx("toggle"),
606 | 	fadeIn: { opacity: "show" },
607 | 	fadeOut: { opacity: "hide" },
608 | 	fadeToggle: { opacity: "toggle" }
609 | }, function( name, props ) {
610 | 	jQuery.fn[ name ] = function( speed, easing, callback ) {
611 | 		return this.animate( props, speed, easing, callback );
612 | 	};
613 | });
614 | 
615 | jQuery.timers = [];
616 | jQuery.fx.tick = function() {
617 | 	var timer,
618 | 		i = 0,
619 | 		timers = jQuery.timers;
620 | 
621 | 	fxNow = jQuery.now();
622 | 
623 | 	for ( ; i < timers.length; i++ ) {
624 | 		timer = timers[ i ];
625 | 		// Checks the timer has not already been removed
626 | 		if ( !timer() && timers[ i ] === timer ) {
627 | 			timers.splice( i--, 1 );
628 | 		}
629 | 	}
630 | 
631 | 	if ( !timers.length ) {
632 | 		jQuery.fx.stop();
633 | 	}
634 | 	fxNow = undefined;
635 | };
636 | 
637 | jQuery.fx.timer = function( timer ) {
638 | 	jQuery.timers.push( timer );
639 | 	if ( timer() ) {
640 | 		jQuery.fx.start();
641 | 	} else {
642 | 		jQuery.timers.pop();
643 | 	}
644 | };
645 | 
646 | jQuery.fx.interval = 13;
647 | jQuery.fx.start = function() {
648 | 	if ( !timerId ) {
649 | 		timerId = window.requestAnimationFrame ?
650 | 			window.requestAnimationFrame( raf ) :
651 | 			setInterval( jQuery.fx.tick, jQuery.fx.interval );
652 | 	}
653 | };
654 | 
655 | jQuery.fx.stop = function() {
656 | 	if ( window.cancelAnimationFrame ) {
657 | 		window.cancelAnimationFrame( timerId );
658 | 	} else {
659 | 		clearInterval( timerId );
660 | 	}
661 | 
662 | 	timerId = null;
663 | };
664 | 
665 | jQuery.fx.speeds = {
666 | 	slow: 600,
667 | 	fast: 200,
668 | 	// Default speed
669 | 	_default: 400
670 | };
671 | 
672 | return jQuery;
673 | });
674 | 


--------------------------------------------------------------------------------
/manipulation.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"./core",
  3 | 	"./var/concat",
  4 | 	"./var/push",
  5 | 	"./core/access",
  6 | 	"./manipulation/var/rcheckableType",
  7 | 	"./manipulation/support",
  8 | 	"./data/var/dataPriv",
  9 | 	"./data/var/dataUser",
 10 | 
 11 | 	"./core/init",
 12 | 	"./data/accepts",
 13 | 	"./traversing",
 14 | 	"./selector",
 15 | 	"./event"
 16 | ], function( jQuery, concat, push, access, rcheckableType, support, dataPriv, dataUser ) {
 17 | 
 18 | var
 19 | 	// (?!p) 反前向声明
 20 | 	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,
 21 | 
 22 | 	//  [A-Za-z0-9_:]
 23 | 	// 匹配 <a  <div
 24 | 	rtagName = /<([\w:]+)/,
 25 | 	// <svg:svg>
 26 | 	// 匹配 HTML标签或特殊符号
 27 | 	// <
 28 | 	// &
 29 | 	// &#
 30 | 	rhtml = /<|&#?\w+;/,
 31 | 	// 匹配 <script 或  <style 或 <link
 32 | 	rnoInnerhtml = /<(?:script|style|link)/i,
 33 | 	// checked="checked" or checked
 34 |     // 匹配 checked="checked" 或者 checked
 35 | 	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
 36 |     // 匹配script类型 "" 或者 /javascript 或者 /ecmascript
 37 | 	rscriptType = /^$|\/(?:java|ecma)script/i,
 38 |     // 匹配 true/ 开头
 39 | 	rscriptTypeMasked = /^true\/(.*)/,
 40 |     // 匹配任意空格开头(<![CDATA[或<!--) 或者 (]]> 或 -->)做空格结尾
 41 | 	rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,
 42 | 
 43 | 	// We have to close these tags to support XHTML (#13200)
 44 |     // 由于浏览器的实现情况不一样 为了保证兼容性，不得不关闭这些标签来支持xhtml
 45 | 	wrapMap = {
 46 | 
 47 | 		// Support: IE9
 48 | 		option: [ 1, "<select multiple='multiple'>", "</select>" ],
 49 | 
 50 | 		thead: [ 1, "<table>", "</table>" ],
 51 | 		col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
 52 | 		tr: [ 2, "<table><tbody>", "</tbody></table>" ],
 53 | 		td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
 54 | 
 55 | 		_default: [ 0, "", "" ]
 56 | 	};
 57 | 
 58 | // Support: IE9
 59 | wrapMap.optgroup = wrapMap.option;
 60 | 
 61 | wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
 62 | wrapMap.th = wrapMap.td;
 63 | 
 64 | // Support: 1.x compatibility
 65 | // Manipulating tables requires a tbody
 66 | function manipulationTarget( elem, content ) {
 67 | 	return jQuery.nodeName( elem, "table" ) &&
 68 | 		jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ?
 69 | 
 70 | 		elem.getElementsByTagName("tbody")[0] ||
 71 | 			elem.appendChild( elem.ownerDocument.createElement("tbody") ) :
 72 | 		elem;
 73 | }
 74 | 
 75 | // Replace/restore the type attribute of script elements for safe DOM manipulation
 76 | function disableScript( elem ) {
 77 | 	elem.type = (elem.getAttribute("type") !== null) + "/" + elem.type;
 78 | 	return elem;
 79 | }
 80 | function restoreScript( elem ) {
 81 | 	var match = rscriptTypeMasked.exec( elem.type );
 82 | 
 83 | 	if ( match ) {
 84 | 		elem.type = match[ 1 ];
 85 | 	} else {
 86 | 		elem.removeAttribute("type");
 87 | 	}
 88 | 
 89 | 	return elem;
 90 | }
 91 | 
 92 | // Mark scripts as having already been evaluated
 93 | // 脚本标记为已经执行
 94 | function setGlobalEval( elems, refElements ) {
 95 | 	var i = 0,
 96 |         // 获取元素集合的长度
 97 | 		l = elems.length;
 98 | 
 99 |     // 遍历元素
100 | 	for ( ; i < l; i++ ) {
101 |         // 为每个元素设置globalEval的data
102 | 		dataPriv.set(
103 |             // 如果refElements取反为false，说明已经设置过了
104 |             // 通过get获取
105 |             // 否则设置为true
106 | 			elems[ i ], "globalEval", !refElements || dataPriv.get( refElements[ i ], "globalEval" )
107 | 		);
108 | 	}
109 | }
110 | 
111 | function cloneCopyEvent( src, dest ) {
112 | 	var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
113 | 
114 | 	if ( dest.nodeType !== 1 ) {
115 | 		return;
116 | 	}
117 | 
118 | 	// 1. Copy private data: events, handlers, etc.
119 | 	if ( dataPriv.hasData( src ) ) {
120 | 		pdataOld = dataPriv.access( src );
121 | 		pdataCur = dataPriv.set( dest, pdataOld );
122 | 		events = pdataOld.events;
123 | 
124 | 		if ( events ) {
125 | 			delete pdataCur.handle;
126 | 			pdataCur.events = {};
127 | 
128 | 			for ( type in events ) {
129 | 				for ( i = 0, l = events[ type ].length; i < l; i++ ) {
130 | 					jQuery.event.add( dest, type, events[ type ][ i ] );
131 | 				}
132 | 			}
133 | 		}
134 | 	}
135 | 
136 | 	// 2. Copy user data
137 | 	if ( dataUser.hasData( src ) ) {
138 | 		udataOld = dataUser.access( src );
139 | 		udataCur = jQuery.extend( {}, udataOld );
140 | 
141 | 		dataUser.set( dest, udataCur );
142 | 	}
143 | }
144 | 
145 | function getAll( context, tag ) {
146 | 	// Support: IE9-11+
147 | 	// Use typeof to avoid zero-argument method invocation on host objects (#15151)
148 | 
149 | 	// typeof context.getElementsByTagName 是否 undefined
150 | 	var ret = typeof context.getElementsByTagName !== "undefined" ?
151 | 		// 存在即用 getElementsByTagName 获取 context 下的 tag 或者 所有元素
152 | 		context.getElementsByTagName( tag || "*" ) :
153 | 		// 否则检测 context.querySelectorAll 是否为 undefined
154 | 			typeof context.querySelectorAll !== "undefined" ?
155 | 				// 存在即用 querySelectorAll 获取 context 下的 tag 或者 所有元素
156 | 				context.querySelectorAll( tag || "*" ) :
157 | 				// 否则为空数组[]
158 | 			[];
159 | 
160 | 	// tag 不存在 返回 ret
161 | 	// tag 存在时 返回 ret
162 | 	// tag存在且 context.nodeName == tag 时
163 | 	// 返回合并后的结果(包括 context ret)
164 | 	return tag === undefined || tag && jQuery.nodeName( context, tag ) ?
165 | 		jQuery.merge( [ context ], ret ) :
166 | 		ret;
167 | }
168 | 
169 | // Fix IE bugs, see support tests
170 | function fixInput( src, dest ) {
171 | 	var nodeName = dest.nodeName.toLowerCase();
172 | 
173 | 	// Fails to persist the checked state of a cloned checkbox or radio button.
174 | 	if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
175 | 		dest.checked = src.checked;
176 | 
177 | 	// Fails to return the selected option to the default selected state when cloning options
178 | 	} else if ( nodeName === "input" || nodeName === "textarea" ) {
179 | 		dest.defaultValue = src.defaultValue;
180 | 	}
181 | }
182 | 
183 | jQuery.extend({
184 | 	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
185 | 		var i, l, srcElements, destElements,
186 | 			clone = elem.cloneNode( true ),
187 | 			inPage = jQuery.contains( elem.ownerDocument, elem );
188 | 
189 | 		// Fix IE cloning issues
190 | 		if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
191 | 				!jQuery.isXMLDoc( elem ) ) {
192 | 
193 | 			// We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
194 | 			destElements = getAll( clone );
195 | 			srcElements = getAll( elem );
196 | 
197 | 			for ( i = 0, l = srcElements.length; i < l; i++ ) {
198 | 				fixInput( srcElements[ i ], destElements[ i ] );
199 | 			}
200 | 		}
201 | 
202 | 		// Copy the events from the original to the clone
203 | 		if ( dataAndEvents ) {
204 | 			if ( deepDataAndEvents ) {
205 | 				srcElements = srcElements || getAll( elem );
206 | 				destElements = destElements || getAll( clone );
207 | 
208 | 				for ( i = 0, l = srcElements.length; i < l; i++ ) {
209 | 					cloneCopyEvent( srcElements[ i ], destElements[ i ] );
210 | 				}
211 | 			} else {
212 | 				cloneCopyEvent( elem, clone );
213 | 			}
214 | 		}
215 | 
216 | 		// Preserve script evaluation history
217 | 		destElements = getAll( clone, "script" );
218 | 		if ( destElements.length > 0 ) {
219 | 			setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
220 | 		}
221 | 
222 | 		// Return the cloned set
223 | 		return clone;
224 | 	},
225 | 
226 | 	buildFragment: function( elems, context, scripts, selection ) {
227 | 		var elem, tmp, tag, wrap, contains, j,
228 | 			// 创建一个文档碎片
229 | 			fragment = context.createDocumentFragment(),
230 | 			// 存放元素数组
231 | 			nodes = [],
232 | 			i = 0,
233 | 			l = elems.length;
234 | 
235 | 		for ( ; i < l; i++ ) {
236 | 			elem = elems[ i ];
237 | 
238 | 			if ( elem || elem === 0 ) {
239 | 
240 | 				// Add nodes directly
241 | 				// 如果 elem 是对象
242 | 				if ( jQuery.type( elem ) === "object" ) {
243 | 					// Support: QtWebKit, PhantomJS
244 | 					// push.apply(_, arraylike) throws on ancient WebKit
245 | 					// 元素 或者 元素集合  merge 到 nodes
246 | 					jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
247 | 
248 | 				// Convert non-html into a text node
249 | 				// 转换文本节点
250 | 				} else if ( !rhtml.test( elem ) ) {
251 | 					// 创建文本节点 push 到 nodes
252 | 					nodes.push( context.createTextNode( elem ) );
253 | 
254 | 				// Convert html into DOM nodes
255 | 				// 将 html 转换为 dom 节点
256 | 				} else {
257 | 					// 如果 tmp 存在 就直接使用
258 | 					// 如果不存在 就 创建一个div 插入到 文档碎片上 并赋值给 tmp
259 | 					tmp = tmp || fragment.appendChild( context.createElement("div") );
260 | 
261 | 					// Deserialize a standard representation
262 | 					// 反序列化
263 | 
264 | 					// 正则 rtagName 匹配 elem 取得标签名
265 | 					// 如 匹配 "<tr><td></td></tr>"  得到 ["<tr","tr"]
266 | 					// 取得标签名 tr 转换为小写
267 | 					tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
268 | 					// 尝试 wrapMap 取得应数据 如果不存在 那么使用 默认数据
269 | 					// 如上逑 将 tr 代入
270 | 					// wrapMap['tr'] 得到  wrap = [ 2, "<table><tbody>", "</tbody></table>" ]
271 | 					// 如果 将 div 代入
272 | 					// wrapMap['div'] 得到 undefined
273 | 					// 将使用 wrap = [ 0, "", "" ]
274 | 					// 这么做的目的是为了某些浏览器下 如类似 tr 必须创建在 tbody 的下面，直接创建在 table 会失败
275 | 					// 为了修正操作
276 | 					wrap = wrapMap[ tag ] || wrapMap._default;
277 | 
278 | 					// elem.replace( rxhtmlTag, "<$1></$2>" )
279 | 					// 用于匹配修正双标签类似"<div></div>"写成半标签的情况"<div />"
280 | 
281 | 					// 整体修正情况类似如下
282 | 					// 当 "<tr><td></td></tr>" 情况时
283 | 					// 修复为 "<table><tbody><tr><td></td></tr></tbody></table>"
284 | 					// 而当 "<tr>" 时
285 | 					// 修复为 "<table><tbody><tr></tr></tbody></table>"
286 | 					// 将修复后的放入 tmp.innerHTML 快速创建成dom元素
287 | 					tmp.innerHTML = wrap[ 1 ] + elem.replace( rxhtmlTag, "<$1></$2>" ) + wrap[ 2 ];
288 | 					// http://www.cnblogs.com/nuysoft/archive/2012/01/11/2318651.html
289 | 					// http://www.cnblogs.com/aaronjs/p/3510768.html
290 | 					// Descend through wrappers to the right content
291 | 
292 | 					// 如上述 wrap = [ 2, "<table><tbody>", "</tbody></table>" ]
293 | 					// wrap[ 0 ] =>  2  代表修正后相比原来元素来说嵌套层数
294 | 					j = wrap[ 0 ];
295 | 					// 遍历 j(层数) 取得   包含 parentNode 的 elem
296 | 					// tmp 为 "<div><table><tbody><tr><td></td></tr></tbody></table></div>" 的 dom
297 | 					// 取两层的 嵌套
298 | 					// tmp最终结果为
299 | 					// "<tbody><tr><td></td></tr></tbody>" 的 dom
300 | 					while ( j-- ) {
301 | 						tmp = tmp.lastChild;
302 | 					}
303 | 
304 | 					// Support: QtWebKit, PhantomJS
305 | 					// push.apply(_, arraylike) throws on ancient WebKit
306 | 					// tmp.childNodes 也就是 elem 转成的 dom元素 合并到 nodes 上
307 | 					jQuery.merge( nodes, tmp.childNodes );
308 | 
309 | 					// Remember the top-level container
310 | 					// 保存顶层容器
311 | 					// 也就是那个div
312 | 					tmp = fragment.firstChild;
313 | 
314 | 					// Ensure the created nodes are orphaned (#12392)
315 | 					//
316 | 					tmp.textContent = "";
317 | 				}
318 | 			}
319 | 		}
320 | 
321 | 		// Remove wrapper from fragment
322 | 		fragment.textContent = "";
323 | 
324 | 		i = 0;
325 | 		while ( (elem = nodes[ i++ ]) ) {
326 | 
327 | 			// #4087 - If origin and destination elements are the same, and this is
328 | 			// that element, do not do anything
329 | 			// 如果元素和目标元素相同
330 | 			if ( selection && jQuery.inArray( elem, selection ) !== -1 ) {
331 | 				// 跳出本次循环
332 | 				continue;
333 | 			}
334 | 
335 | 			// 检测elem的根元素是否包含elem
336 | 			contains = jQuery.contains( elem.ownerDocument, elem );
337 | 
338 | 			// Append to fragment
339 | 			// 获取所有的script标签
340 | 			tmp = getAll( fragment.appendChild( elem ), "script" );
341 | 
342 | 			// Preserve script evaluation history
343 | 			if ( contains ) {
344 | 				setGlobalEval( tmp );
345 | 			}
346 | 
347 | 			// Capture executables
348 | 			// 获取可执行的脚本
349 | 			if ( scripts ) {
350 | 				j = 0;
351 | 				// 遍历所有的script标签
352 | 				while ( (elem = tmp[ j++ ]) ) {
353 | 					// 检测 script 的 type 是否为 javascript 或 ecmascript 或者 没有type属性
354 | 					if ( rscriptType.test( elem.type || "" ) ) {
355 | 						// 推入 scripts 数组里面
356 | 						scripts.push( elem );
357 | 					}
358 | 				}
359 | 			}
360 | 		}
361 | 
362 | 		return fragment;
363 | 	},
364 | 
365 | 	cleanData: function( elems ) {
366 | 		var data, elem, type, key,
367 | 			special = jQuery.event.special,
368 | 			i = 0;
369 | 
370 | 		for ( ; (elem = elems[ i ]) !== undefined; i++ ) {
371 | 			if ( jQuery.acceptData( elem ) ) {
372 | 				key = elem[ dataPriv.expando ];
373 | 
374 | 				if ( key && (data = dataPriv.cache[ key ]) ) {
375 | 					if ( data.events ) {
376 | 						for ( type in data.events ) {
377 | 							if ( special[ type ] ) {
378 | 								jQuery.event.remove( elem, type );
379 | 
380 | 							// This is a shortcut to avoid jQuery.event.remove's overhead
381 | 							} else {
382 | 								jQuery.removeEvent( elem, type, data.handle );
383 | 							}
384 | 						}
385 | 					}
386 | 					if ( dataPriv.cache[ key ] ) {
387 | 						// Discard any remaining `private` data
388 | 						delete dataPriv.cache[ key ];
389 | 					}
390 | 				}
391 | 			}
392 | 			// Discard any remaining `user` data
393 | 			delete dataUser.cache[ elem[ dataUser.expando ] ];
394 | 		}
395 | 	}
396 | });
397 | 
398 | jQuery.fn.extend({
399 | 	text: function( value ) {
400 | 		return access( this, function( value ) {
401 | 			return value === undefined ?
402 | 				jQuery.text( this ) :
403 | 				this.empty().each(function() {
404 | 					if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
405 | 						this.textContent = value;
406 | 					}
407 | 				});
408 | 		}, null, value, arguments.length );
409 | 	},
410 | 
411 | 	append: function() {
412 | 		return this.domManip( arguments, function( elem ) {
413 | 			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
414 | 				var target = manipulationTarget( this, elem );
415 | 				target.appendChild( elem );
416 | 			}
417 | 		});
418 | 	},
419 | 
420 | 	prepend: function() {
421 | 		return this.domManip( arguments, function( elem ) {
422 | 			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
423 | 				var target = manipulationTarget( this, elem );
424 | 				target.insertBefore( elem, target.firstChild );
425 | 			}
426 | 		});
427 | 	},
428 | 
429 | 	before: function() {
430 | 		return this.domManip( arguments, function( elem ) {
431 | 			if ( this.parentNode ) {
432 | 				this.parentNode.insertBefore( elem, this );
433 | 			}
434 | 		});
435 | 	},
436 | 
437 | 	after: function() {
438 | 		return this.domManip( arguments, function( elem ) {
439 | 			if ( this.parentNode ) {
440 | 				this.parentNode.insertBefore( elem, this.nextSibling );
441 | 			}
442 | 		});
443 | 	},
444 | 
445 | 	remove: function( selector, keepData /* Internal Use Only */ ) {
446 | 		var elem,
447 | 			elems = selector ? jQuery.filter( selector, this ) : this,
448 | 			i = 0;
449 | 
450 | 		for ( ; (elem = elems[i]) != null; i++ ) {
451 | 			if ( !keepData && elem.nodeType === 1 ) {
452 | 				jQuery.cleanData( getAll( elem ) );
453 | 			}
454 | 
455 | 			if ( elem.parentNode ) {
456 | 				if ( keepData && jQuery.contains( elem.ownerDocument, elem ) ) {
457 | 					setGlobalEval( getAll( elem, "script" ) );
458 | 				}
459 | 				elem.parentNode.removeChild( elem );
460 | 			}
461 | 		}
462 | 
463 | 		return this;
464 | 	},
465 | 
466 | 	empty: function() {
467 | 		var elem,
468 | 			i = 0;
469 | 
470 | 		for ( ; (elem = this[i]) != null; i++ ) {
471 | 			if ( elem.nodeType === 1 ) {
472 | 
473 | 				// Prevent memory leaks
474 | 				jQuery.cleanData( getAll( elem, false ) );
475 | 
476 | 				// Remove any remaining nodes
477 | 				elem.textContent = "";
478 | 			}
479 | 		}
480 | 
481 | 		return this;
482 | 	},
483 | 
484 | 	clone: function( dataAndEvents, deepDataAndEvents ) {
485 | 		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
486 | 		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
487 | 
488 | 		return this.map(function() {
489 | 			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
490 | 		});
491 | 	},
492 | 
493 | 	html: function( value ) {
494 | 		return access( this, function( value ) {
495 | 			var elem = this[ 0 ] || {},
496 | 				i = 0,
497 | 				l = this.length;
498 | 
499 | 			if ( value === undefined && elem.nodeType === 1 ) {
500 | 				return elem.innerHTML;
501 | 			}
502 | 
503 | 			// See if we can take a shortcut and just use innerHTML
504 | 			if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
505 | 				!wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
506 | 
507 | 				value = value.replace( rxhtmlTag, "<$1></$2>" );
508 | 
509 | 				try {
510 | 					for ( ; i < l; i++ ) {
511 | 						elem = this[ i ] || {};
512 | 
513 | 						// Remove element nodes and prevent memory leaks
514 | 						if ( elem.nodeType === 1 ) {
515 | 							jQuery.cleanData( getAll( elem, false ) );
516 | 							elem.innerHTML = value;
517 | 						}
518 | 					}
519 | 
520 | 					elem = 0;
521 | 
522 | 				// If using innerHTML throws an exception, use the fallback method
523 | 				} catch ( e ) {}
524 | 			}
525 | 
526 | 			if ( elem ) {
527 | 				this.empty().append( value );
528 | 			}
529 | 		}, null, value, arguments.length );
530 | 	},
531 | 
532 | 	replaceWith: function() {
533 | 		var arg = arguments[ 0 ];
534 | 
535 | 		// Make the changes, replacing each context element with the new content
536 | 		this.domManip( arguments, function( elem ) {
537 | 			arg = this.parentNode;
538 | 
539 | 			jQuery.cleanData( getAll( this ) );
540 | 
541 | 			if ( arg ) {
542 | 				arg.replaceChild( elem, this );
543 | 			}
544 | 		});
545 | 
546 | 		// Force removal if there was no new content (e.g., from empty arguments)
547 | 		return arg && (arg.length || arg.nodeType) ? this : this.remove();
548 | 	},
549 | 
550 | 	detach: function( selector ) {
551 | 		return this.remove( selector, true );
552 | 	},
553 | 
554 | 	domManip: function( args, callback ) {
555 | 
556 | 		// Flatten any nested arrays
557 | 		args = concat.apply( [], args );
558 | 
559 | 		var fragment, first, scripts, hasScripts, node, doc,
560 | 			i = 0,
561 | 			l = this.length,
562 | 			set = this,
563 | 			iNoClone = l - 1,
564 | 			value = args[ 0 ],
565 | 			isFunction = jQuery.isFunction( value );
566 | 
567 | 		// We can't cloneNode fragments that contain checked, in WebKit
568 | 		if ( isFunction ||
569 | 				( l > 1 && typeof value === "string" &&
570 | 					!support.checkClone && rchecked.test( value ) ) ) {
571 | 			return this.each(function( index ) {
572 | 				var self = set.eq( index );
573 | 				if ( isFunction ) {
574 | 					args[ 0 ] = value.call( this, index, self.html() );
575 | 				}
576 | 				self.domManip( args, callback );
577 | 			});
578 | 		}
579 | 
580 | 		if ( l ) {
581 | 			fragment = jQuery.buildFragment( args, this[ 0 ].ownerDocument, false, this );
582 | 			first = fragment.firstChild;
583 | 
584 | 			if ( fragment.childNodes.length === 1 ) {
585 | 				fragment = first;
586 | 			}
587 | 
588 | 			if ( first ) {
589 | 				scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
590 | 				hasScripts = scripts.length;
591 | 
592 | 				// Use the original fragment for the last item
593 | 				// instead of the first because it can end up
594 | 				// being emptied incorrectly in certain situations (#8070).
595 | 				for ( ; i < l; i++ ) {
596 | 					node = fragment;
597 | 
598 | 					if ( i !== iNoClone ) {
599 | 						node = jQuery.clone( node, true, true );
600 | 
601 | 						// Keep references to cloned scripts for later restoration
602 | 						if ( hasScripts ) {
603 | 							// Support: QtWebKit
604 | 							// jQuery.merge because push.apply(_, arraylike) throws
605 | 							jQuery.merge( scripts, getAll( node, "script" ) );
606 | 						}
607 | 					}
608 | 
609 | 					callback.call( this[ i ], node, i );
610 | 				}
611 | 
612 | 				if ( hasScripts ) {
613 | 					doc = scripts[ scripts.length - 1 ].ownerDocument;
614 | 
615 | 					// Reenable scripts
616 | 					jQuery.map( scripts, restoreScript );
617 | 
618 | 					// Evaluate executable scripts on first document insertion
619 | 					for ( i = 0; i < hasScripts; i++ ) {
620 | 						node = scripts[ i ];
621 | 						if ( rscriptType.test( node.type || "" ) &&
622 | 							!dataPriv.access( node, "globalEval" ) &&
623 | 							jQuery.contains( doc, node ) ) {
624 | 
625 | 							if ( node.src ) {
626 | 								// Optional AJAX dependency, but won't run scripts if not present
627 | 								if ( jQuery._evalUrl ) {
628 | 									jQuery._evalUrl( node.src );
629 | 								}
630 | 							} else {
631 | 								jQuery.globalEval( node.textContent.replace( rcleanScript, "" ) );
632 | 							}
633 | 						}
634 | 					}
635 | 				}
636 | 			}
637 | 		}
638 | 
639 | 		return this;
640 | 	}
641 | });
642 | 
643 | jQuery.each({
644 | 	appendTo: "append",
645 | 	prependTo: "prepend",
646 | 	insertBefore: "before",
647 | 	insertAfter: "after",
648 | 	replaceAll: "replaceWith"
649 | }, function( name, original ) {
650 | 	jQuery.fn[ name ] = function( selector ) {
651 | 		var elems,
652 | 			ret = [],
653 | 			insert = jQuery( selector ),
654 | 			last = insert.length - 1,
655 | 			i = 0;
656 | 
657 | 		for ( ; i <= last; i++ ) {
658 | 			elems = i === last ? this : this.clone( true );
659 | 			jQuery( insert[ i ] )[ original ]( elems );
660 | 
661 | 			// Support: QtWebKit
662 | 			// .get() because push.apply(_, arraylike) throws
663 | 			push.apply( ret, elems.get() );
664 | 		}
665 | 
666 | 		return this.pushStack( ret );
667 | 	};
668 | });
669 | 
670 | return jQuery;
671 | });
672 | 


--------------------------------------------------------------------------------
/core.js:
--------------------------------------------------------------------------------
  1 | define([
  2 | 	"./var/arr",
  3 | 	"./var/slice",
  4 | 	"./var/concat",
  5 | 	"./var/push",
  6 | 	"./var/indexOf",
  7 | 	"./var/class2type",
  8 | 	"./var/toString",
  9 | 	"./var/hasOwn",
 10 | 	"./var/support"
 11 | ], function( arr, slice, concat, push, indexOf, class2type, toString, hasOwn, support ) {
 12 | 	 // 模块化
 13 | 	// IDE  集成开发环境
 14 | 
 15 | var
 16 | 	// Use the correct document accordingly with window argument (sandbox)
 17 | 	// 从参数 window 获取正确的相应的 document
 18 | 	document = window.document,
 19 | 
 20 | 	// jQuery版本号
 21 | 	version = "@VERSION",
 22 | 
 23 | 	// Define a local copy of jQuery
 24 | 	// 定义一份局部的jQuery的拷贝
 25 | 	//  $('div')
 26 | 	jQuery = function( selector, context ) {
 27 | 
 28 | 		// The jQuery object is actually just the init constructor 'enhanced'
 29 | 		// jQuery 对象是实际上只是 '加强' 的初始化构造函数
 30 | 		// Need init if jQuery is called (just allow error to be thrown if not included)
 31 | 		// 如果调用 jQuery，需要init (如果不是包括，只允许错误抛出)
 32 | 
 33 | 		// 可以看出来，jQuery对象其实是jQuery.fn.init是实例
 34 | 		return new jQuery.fn.init( selector, context );
 35 | 	},
 36 | 
 37 | 	// Support: Android<4.1
 38 | 	// Make sure we trim BOM and NBSP
 39 | 	// 此正则匹配头尾的空白符
 40 | 	// 也匹配全角字符
 41 | 	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
 42 | 
 43 | 	// Matches dashed string for camelizing
 44 | 	// 用于匹配ie
 45 | 	rmsPrefix = /^-ms-/,
 46 | 
 47 | 	// 用于匹配类似-webkit-transform中的-w -t之类的
 48 | 	rdashAlpha = /-([\da-z])/gi,
 49 | 
 50 | 	// Used by jQuery.camelCase as callback to replace()
 51 | 	// jQuery.camelCase 使用 fcamelCase 作为 replace() 的回调函数
 52 | 	fcamelCase = function( all, letter ) {
 53 | 		//将$1转换为大写并返回
 54 | 		return letter.toUpperCase();
 55 | 	};
 56 | 
 57 | jQuery.fn = jQuery.prototype = {
 58 | 	// The current version of jQuery being used
 59 | 	// jQuery当前的版本号
 60 | 	jquery: version,
 61 | 
 62 | 	// 修正jQuery的构造函数的指针
 63 | 	constructor: jQuery,
 64 | 
 65 | 	// Start with an empty selector
 66 | 	// 保存jQuery对象的选择器 默认为 ""
 67 | 	selector: "",
 68 | 
 69 | 	// The default length of a jQuery object is 0
 70 | 	// jQuery对象是一个类数组，默认 长度为 0
 71 | 	length: 0,
 72 | 
 73 | 	// 把jQuery对象转换成 dom元素集合
 74 | 	toArray: function() {
 75 | 		return slice.call( this );
 76 | 	},
 77 | 
 78 | 	// Get the Nth element in the matched element set OR
 79 | 	// Get the whole matched element set as a clean array
 80 | 	// 检索匹配jQuery对象获取对应的DOM元素 或者
 81 | 	// 检索匹配jQuery对象设置为一个干净的数组 (与toArray一样)
 82 | 	// 此方法用于获取jQuery中某个dom元素, 当无参时获取全部dom元素的集合
 83 | 	get: function( num ) {
 84 | 		// num不为空
 85 | 		return num != null ?
 86 | 
 87 | 			// Return just the one element from the set
 88 | 			// 返回匹配的某个dom元素
 89 | 			// 当参数 num 小于0时从 元素匹配集合中(jQuery对象是一个类数组) 末尾开始倒数
 90 | 			// 否则从 0 开始计数
 91 | 			( num < 0 ? this[ num + this.length ] : this[ num ] ) :
 92 | 
 93 | 			// Return all the elements in a clean array
 94 | 			// 当 num 为空时返回所有的元素在一个干净的数组
 95 | 			slice.call( this );
 96 | 	},
 97 | 
 98 | 	// Take an array of elements and push it onto the stack
 99 | 	// 将一个元素压入jQuery对象栈中
100 | 	// (returning the new matched element set)
101 | 	// (返回一个新的匹配元素的集合)
102 | 	pushStack: function( elems ) {
103 | 
104 | 		// Build a new jQuery matched element set
105 | 		// 建立一个新的jQuery 匹配元素集合
106 | 		var ret = jQuery.merge( this.constructor(), elems );
107 | 
108 | 		// Add the old object onto the stack (as a reference)
109 | 		// 旧对象添加到堆栈上(作为参考)
110 | 		// jQuery中的回溯设计
111 | 		// 保存旧对象
112 | 		ret.prevObject = this;
113 | 		// 保存旧对象的 context 属性在新的jQuery对象的 context
114 | 		// 上下文不变
115 | 		ret.context = this.context;
116 | 
117 | 		// Return the newly-formed element set
118 | 		// 返回新的元素集(jQuery对象)
119 | 		return ret;
120 | 	},
121 | 
122 | 	// Execute a callback for every element in the matched set.
123 | 	// 匹配集合中执行的每个元素的回调。
124 | 	// (You can seed the arguments with an array of args, but this is
125 | 	// only used internally.)
126 | 	// 你可以使用参数数组args，但这只是在内部使用
127 | 	// 此方法用于遍历当前jQuery对象，为每个匹配元素执行一个函数。
128 | 	each: function( callback, args ) {
129 | 		//返回  jQuery 工具方法 each 把当前的jQuery对象、以及回调函数和args数组作为参数传入执行结果
130 | 		return jQuery.each( this, callback, args );
131 | 	},
132 | 
133 | 	// 此方法用于遍历当前jQuery对象，产生一个包含新的jQuery对象
134 | 	map: function( callback ) {
135 | 		// 经过工具方法 map 来遍历当前jQuery对象，返回一个数组(合并每个元素调用 callback 的返回值)
136 | 		// 将返回的数组 通过 pushStack 方法产生一个新的jQuery对象并返回
137 | 		return this.pushStack( jQuery.map(this, function( elem, i ) {
138 | 			return callback.call( elem, i, elem );
139 | 		}));
140 | 	},
141 | 
142 | 	// 取指定下标范围的元素，产生一个新的jQuery对象
143 | 	slice: function() {
144 | 		// 调用数组的 slice 方法 取指定下标范围的元素，通过 pushStack 方法产生一个新的jQuery对象并返回
145 | 		return this.pushStack( slice.apply( this, arguments ) );
146 | 	},
147 | 
148 | 	// 取jQuery对象中的第一个元素
149 | 	first: function() {
150 | 		return this.eq( 0 );
151 | 	},
152 | 
153 | 	// 取jQuery对象中的最后一个元素
154 | 	last: function() {
155 | 		return this.eq( -1 );
156 | 	},
157 | 
158 | 	// 匹配指定索引的元素 (参数i为负数时，从后面匹配)
159 | 	eq: function( i ) {
160 | 		// 保存当前jQuery对象的length
161 | 		var len = this.length,
162 | 
163 | 			// 修正为负数的索引
164 | 			j = +i + ( i < 0 ? len : 0 );
165 | 		// 如果修正后的索引越过了 当前jQuery对象length的范围
166 | 		return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
167 | 	},
168 | 
169 | 	// 返回上一个对象，如果没有返回一个空jQuery对象
170 | 	end: function() {
171 | 		return this.prevObject || this.constructor(null);
172 | 	},
173 | 
174 | 	// For internal use only.
175 | 	// 仅供内部使用
176 | 	// Behaves like an Array's method, not like a jQuery method.
177 | 	// 就象一个数组的方法,不像一个jQuery方法。
178 | 	push: push,
179 | 	sort: arr.sort,
180 | 	splice: arr.splice
181 | };
182 | 
183 | jQuery.extend = jQuery.fn.extend = function() {
184 | 	// options 指向某源对象
185 | 	// name 指向某源对象的key
186 | 	// src 指向目标对象的某个value
187 | 	// copy 指向某源对象的某个value
188 | 	// copyIsArray 指求copy是否为数组
189 | 	// clone 深拷贝时原始值的修正
190 | 	var options, name, src, copy, copyIsArray, clone,
191 | 		// target 保存第1个参数或者是空对象
192 | 		target = arguments[0] || {},
193 | 		// 拷贝位置
194 | 		i = 1,
195 | 		// 保存参数的长度
196 | 		length = arguments.length,
197 | 		// 默认是浅拷贝
198 | 		deep = false;
199 | 
200 | 	// Handle a deep copy situation
201 | 	// 处理深拷贝的情况
202 | 	// 如果target是boolean
203 | 	// $.extend(deep,target)
204 | 	if ( typeof target === "boolean" ) {
205 | 
206 | 		// target赋值给deep，表示拷贝程度
207 | 		deep = target;
208 | 
209 | 		// Skip the boolean and the target
210 | 		// 并将第2个参数或{}作为target
211 | 		target = arguments[ i ] || {};
212 | 
213 | 		// 拷贝位置+1
214 | 		i++;
215 | 	}
216 | 
217 | 	// Handle case when target is a string or something (possible in deep copy)
218 | 	// 处理target是一个string或者是其他时(可能是在深拷贝)
219 | 	// 如果target不是一个对象或函数
220 | 	// $.extend("string")
221 | 	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
222 | 
223 | 		// 修正target为{}
224 | 		target = {};
225 | 	}
226 | 
227 | 	// Extend jQuery itself if only one argument is passed
228 | 	// 只有一个参数时，扩展jQuery对象本身
229 | 	// $.extend({ a:1 })
230 | 	if ( i === length ) {
231 | 
232 | 		// 目标为 this, this指向了jQuery或者是jQuery.prototype, 扩展jQuery的工具方法或者是jQuery的实例方法
233 | 		target = this;
234 | 
235 | 		// 拷贝位置-1
236 | 		i--;
237 | 	}
238 | 
239 | 	for ( ; i < length; i++ ) {
240 | 		// Only deal with non-null/undefined values
241 | 		// $.extend( target,null/undefined )
242 | 		// 遍历源对象并保证不是null或undefined
243 | 		if ( (options = arguments[ i ]) != null ) {
244 | 			// Extend the base object
245 | 			for ( name in options ) {
246 | 
247 | 				// 当前target的value(原始值)
248 | 				src = target[ name ];
249 | 
250 | 				// 当前源对象的value(复制值)
251 | 				copy = options[ name ];
252 | 
253 | 				// Prevent never-ending loop
254 | 				// 避免循环引用
255 | 				if ( target === copy ) {
256 | 					// 跳过本次循环
257 | 					continue;
258 | 				}
259 | 
260 | 				// Recurse if we're merging plain objects or arrays
261 | 				// 如果是 深拷贝 且 copy不能转为false 并且 copy是一个纯粹的对象或者是一个数组
262 | 				if ( deep && copy && ( jQuery.isPlainObject(copy) ||
263 | 					(copyIsArray = jQuery.isArray(copy)) ) ) {
264 | 
265 | 					// 如果 copy是一个数组
266 | 					if ( copyIsArray ) {
267 | 
268 | 						// copyIsArray 重新赋值 false
269 | 						copyIsArray = false;
270 | 
271 | 						// 如果src不能转为false 且 src是一个数组，就把src赋值给clone
272 | 						// 否则用空数组 []，原始值修正
273 | 						clone = src && jQuery.isArray(src) ? src : [];
274 | 
275 | 					// 如果不是一个数组，是一个对象
276 | 					} else {
277 | 
278 | 						// 如果src不能转为false 且 src是一个纯粹的对象，就把src赋值给clone
279 | 						// 否则用空对象 {}，原始值修正
280 | 						clone = src && jQuery.isPlainObject(src) ? src : {};
281 | 					}
282 | 
283 | 					// Never move original objects, clone them
284 | 					// 不移动原始对象，复制他们
285 | 					target[ name ] = jQuery.extend( deep, clone, copy );
286 | 
287 | 				// Don't bring in undefined values
288 | 				// 非undefined的值
289 | 				} else if ( copy !== undefined ) {
290 | 					target[ name ] = copy;
291 | 				}
292 | 			}
293 | 		}
294 | 	}
295 | 
296 | 	// Return the modified object
297 | 	// 返回已修改的对象
298 | 	return target;
299 | };
300 | 
301 | jQuery.extend({
302 | 	// Unique for each copy of jQuery on the page
303 | 	// 生成类似 "jQuery1110028437914578794354" 的字符串
304 | 	// 内部key（随即生成），之后会作为key添加到dom的属性集中，而key对应的value则是该dom对应的缓存对象
305 | 	// 用于数据缓存
306 | 	// 而replace将( version + Math.random() ) 生成的字符串中的.替换为空
307 | 	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
308 | 
309 | 	// Assume jQuery is ready without the ready module
310 | 	// 假设jQuery准备好了所有模块
311 | 	isReady: true,
312 | 
313 | 	// 抛一个新的错误消息
314 | 	error: function( msg ) {
315 | 		throw new Error( msg );
316 | 	},
317 | 
318 | 	// 空函数
319 | 	noop: function() {},
320 | 
321 | 	// 此方法用于检测obj是否为函数
322 | 	isFunction: function( obj ) {
323 | 		return jQuery.type(obj) === "function";
324 | 	},
325 | 
326 | 	// 此方法用于检测obj是否为数组( 引用原生Array.isArray )
327 | 	isArray: Array.isArray,
328 | 
329 | 	// 此方法用于检测obj是否为window
330 | 	isWindow: function( obj ) {
331 | 		return obj != null && obj === obj.window;
332 | 	},
333 | 
334 | 	// 此方法用于检测obj是否是有效的数字(包括字符串型 如 "12313.11321")
335 | 	isNumeric: function( obj ) {
336 | 		// parseFloat NaNs numeric-cast false positives (null|true|false|"")
337 | 		// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
338 | 		// subtraction forces infinities to NaN
339 | 		// adding 1 corrects loss of precision from parseFloat (#15100)
340 | 		// parseFloat将(null|true|false|"")转为NaN
341 | 		// 但是在数字字符串，特殊是在十六进制时 parseFloat 会转换成0  parseFloat('0xff') => 0
342 | 		// +1 用于是纠正精度损失的情况
343 | 		// http://bugs.jquery.com/ticket/15100
344 | 		// !jQuery.isArray( obj ) 是为了防止 parseFloat([1]) 返回1而不是NaN的奇葩情况
345 | 		// https://github.com/jquery/jquery/commit/10efa1f5b44046aab6bcc8423322a41923faa290
346 | 		return !jQuery.isArray( obj ) && (obj - parseFloat( obj ) + 1) >= 0;
347 | 	},
348 | 
349 | 	// 此方法用于检测对象是否是纯粹的对象 ({} 或者 new Object 创建)
350 | 	isPlainObject: function( obj ) {
351 | 
352 | 		// Not plain objects:
353 | 		// 不是一个纯粹的对象：
354 | 		// Any object or value whose internal [[Class]] property is not "[object Object]"
355 | 		// 任何 对象或值 内部的[[Class]]属性不是 "[object Object]"
356 | 		// DOM nodes
357 | 		// DOM 节点
358 | 		// window
359 | 		// window对象
360 | 
361 | 		// jQuery.type(obj) 返回的是obj的类型，当自定义对象时返回的是object
362 | 		if ( jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
363 | 			return false;
364 | 		}
365 | 
366 | 		// obj的构造函数存在 且 obj的构造函数的原型对象下没有 isPrototypeOf 方法
367 | 		if ( obj.constructor &&
368 | 				// !({}).hasOwnProperty.call( obj.constructor.prototype, "isPrototypeOf" )
369 | 				// 只有Object.prototype才拥有isPrototypeOf的方法
370 | 				!hasOwn.call( obj.constructor.prototype, "isPrototypeOf" ) ) {
371 | 
372 | 			// 说明不是 {} 或者 new Object创建
373 | 			return false;
374 | 		}
375 | 
376 | 		// If the function hasn't returned already, we're confident that
377 | 		// |obj| is a plain object, created by {} or constructed with new Object
378 | 		// 如果方法没有返回，我们相信这是一个纯粹的对象，由{} 或者 new Object 创建
379 | 		return true;
380 | 	},
381 | 
382 | 	// 此方法于检测obj是否是一个空对象
383 | 	isEmptyObject: function( obj ) {
384 | 		// 变量name用于key的迭代
385 | 		var name;
386 | 		for ( name in obj ) {
387 | 			// 如果能进入for……in循环那就直接返回false
388 | 			return false;
389 | 		}
390 | 		// 如果能执行到这里说明obj是一个空对象
391 | 		return true;
392 | 	},
393 | 
394 | 	// 此方法是用于JavaScript对象的类型检测
395 | 	type: function( obj ) {
396 | 		// 如果obj是null
397 | 		if ( obj == null ) {
398 | 			// 返回 "null"
399 | 			return obj + "";
400 | 		}
401 | 		// Support: Android<4.0, iOS<6 (functionish RegExp)
402 | 		// 如果obj是对象object或者是function
403 | 		return typeof obj === "object" || typeof obj === "function" ?
404 | 			// 则返回 class2type[({}).toString.call(obj)]  或者是 "object"
405 | 			class2type[ toString.call(obj) ] || "object" :
406 | 			// 否则返回 typeof obj;
407 | 			typeof obj;
408 | 	},
409 | 
410 | 	// Evaluates a script in a global context
411 | 	// 此方法用于在全局作用域下调用 javascript 代码
412 | 	globalEval: function( code ) {
413 | 
414 | 		// 创建 script 标签
415 | 		var script = document.createElement( "script" );
416 | 
417 | 		// 放入代码
418 | 		script.text = code;
419 | 
420 | 		// 在文档head插入 script 标签 ，并删除掉 script标签
421 | 		document.head.appendChild( script ).parentNode.removeChild( script );
422 | 	},
423 | 
424 | 	// Convert dashed to camelCase; used by the css and data modules
425 | 	// 此方法用于将字符串转换成小驼峰，用于css以及数据模块
426 | 	// Support: IE9-11+
427 | 	// Microsoft forgot to hump their vendor prefix (#9572)
428 | 	// jQuery.camelCase 用于类似-webkit-transform转化为驼峰表示法 例如：-webkit-transform 转成 WebkitTransform
429 | 	// 而在ie -ms-transform 转化为驼峰表示法 msTransform
430 | 	camelCase: function( string ) {
431 | 		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
432 | 	},
433 | 
434 | 	// 此方法用于检测是否存在指定节点名称( 忽略大小写 )
435 | 	nodeName: function( elem, name ) {
436 | 		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
437 | 	},
438 | 
439 | 	// 此方法用于遍历数组或者是类数组
440 | 	// args is for internal usage only
441 | 	// args 只供内部使用
442 | 	each: function( obj, callback, args ) {
443 | 
444 | 		// value 保存 callback 的返回值，用于跳出循环
445 | 		var value,
446 | 			// 当前遍历的索引
447 | 			i = 0,
448 | 			// 保存对象的长度
449 | 			length = obj.length,
450 | 			// 判断obj是否长得像数组
451 | 			isArray = isArraylike( obj );
452 | 
453 | 		// 如果参数args存在
454 | 		if ( args ) {
455 | 
456 | 			// 如果obj长的像数组
457 | 			if ( isArray ) {
458 | 
459 | 				// 长得数组用for遍历
460 | 				for ( ; i < length; i++ ) {
461 | 
462 | 					// 当前元素附出一个callback，且将参数args数组传入函数
463 | 					// 保存当前callback的返回值
464 | 					value = callback.apply( obj[ i ], args );
465 | 					// 当前回调的返回值为false
466 | 					if ( value === false ) {
467 | 						// 直接终止循环
468 | 						break;
469 | 					}
470 | 				}
471 | 
472 | 			// 如果长的不像数组
473 | 			} else {
474 | 
475 | 				// 那就用for...in遍历
476 | 				for ( i in obj ) {
477 | 
478 | 					// 当前元素附出一个callback，且将参数args数组传入函数
479 | 					// 保存当前callback的返回值
480 | 					value = callback.apply( obj[ i ], args );
481 | 					// 当前回调的返回值为false
482 | 					if ( value === false ) {
483 | 						// 直接终止循环
484 | 						break;
485 | 					}
486 | 				}
487 | 			}
488 | 
489 | 		// A special, fast, case for the most common use of each
490 | 		// 如果参数args不存在
491 | 		} else {
492 | 
493 | 			// 如果obj长的像数组
494 | 			if ( isArray ) {
495 | 
496 | 				// 长得数组用for遍历
497 | 				for ( ; i < length; i++ ) {
498 | 
499 | 					// 当前元素附出一个callback，且将当前元素以及key和value传入
500 | 					// 保存当前callback的返回值
501 | 					value = callback.call( obj[ i ], i, obj[ i ] );
502 | 
503 | 					// 当前回调的返回值为false
504 | 					if ( value === false ) {
505 | 						// 直接终止循环
506 | 						break;
507 | 					}
508 | 				}
509 | 
510 | 			// 如果长的不像数组
511 | 			} else {
512 | 
513 | 				// 那就用for...in遍历
514 | 				for ( i in obj ) {
515 | 
516 | 					// 当前元素附出一个callback，且将当前元素以及key和value传入
517 | 					// 保存当前callback的返回值
518 | 					value = callback.call( obj[ i ], i, obj[ i ] );
519 | 
520 | 					// 当前回调的返回值为false
521 | 					if ( value === false ) {
522 | 						// 直接终止循环
523 | 						break;
524 | 					}
525 | 				}
526 | 			}
527 | 		}
528 | 
529 | 		//
530 | 		return obj;
531 | 	},
532 | 
533 | 	// Support: Android<4.1
534 | 	// 此方法用于去掉头尾空格符
535 | 	trim: function( text ) {
536 | 		// 如果 text不为空
537 | 		return text == null ?
538 | 			//直接返回空字符串
539 | 			"" :
540 | 			// 为了确保text是字符串先将text和空字符串拼接
541 | 			// 然后用正则rtrim匹配空格符将其替换成空字符串
542 | 			( text + "" ).replace( rtrim, "" );
543 | 	},
544 | 
545 | 	// 此方法用于把类数组对象转换成一个直正的数组
546 | 	// results is for internal usage only
547 | 	// results 仅供内部使用
548 | 	makeArray: function( arr, results ) {
549 | 
550 | 		// 如果 results 存在，就直接用results，否则用[]
551 | 		var ret = results || [];
552 | 
553 | 		// 如果 arr不为空
554 | 		if ( arr != null ) {
555 | 
556 | 			// 如果 arr(一律用Object(arr)来转换) 长的是像数组，调用jQuery.merge方法合并
557 | 			// http://javascript.ruanyifeng.com/stdlib/object.html#toc2
558 | 			if ( isArraylike( Object(arr) ) ) {
559 | 				jQuery.merge( ret,
560 | 					// typeof Object("xxxx") =>  "object" , 所以此次要再检测是"string"
561 | 					typeof arr === "string" ?
562 | 					[ arr ] : arr
563 | 				);
564 | 			} else {
565 | 				// 如果arr长的不像数组，那么直接将arr push进ret
566 | 				push.call( ret, arr );
567 | 			}
568 | 		}
569 | 
570 | 		// 返回转换后的结果
571 | 		return ret;
572 | 	},
573 | 
574 | 	// 此方法用于在数组中查找指定值并返回它的索引
575 | 	// 参数i 指定查找开始位置
576 | 	// 如果没有找到，则返回-1
577 | 	inArray: function( elem, arr, i ) {
578 | 		// 如果arr为空返回-1，否则调用原生数组的indexOf方法
579 | 		return arr == null ? -1 : indexOf.call( arr, elem, i );
580 | 	},
581 | 
582 | 	// 此方法用于合并两个数组内容到第一个数组
583 | 	merge: function( first, second ) {
584 | 
585 | 		// 保存第二个数组的length, 为避免 length的值是字符串类型前面加+来转换类型
586 | 		var len = +second.length,
587 | 			j = 0,
588 | 			i = first.length;
589 | 
590 | 		// 遍历第二个数组
591 | 		for ( ; j < len; j++ ) {
592 | 			// 将第二个数组的每个元素从第一数组的尾部插入
593 | 			first[ i++ ] = second[ j ];
594 | 		}
595 | 
596 | 		// 修正第一个数组的length (有可能是jQuery对象)
597 | 		first.length = i;
598 | 
599 | 		// 返回合并后的第一个数组 (有可能是jQuery对象)
600 | 		return first;
601 | 	},
602 | 
603 | 	// 此方法用于查找满足此过滤函数的元素，原数组不受影响
604 | 	// 如果 invert 为 false 取过滤函数返回true的元素
605 | 	// 如果 invert 为 true  则相反 取过滤函数返回false的元素
606 | 	grep: function( elems, callback, invert ) {
607 | 
608 | 		// 用于保存过滤函数回调求反的返回值
609 | 		var callbackInverse,
610 | 			// 匹配的结果集
611 | 			matches = [],
612 | 			// 初始索引
613 | 			i = 0,
614 | 			// 元素的长度
615 | 			length = elems.length,
616 | 
617 | 			// 回调返回的期望值
618 | 			// 当参数 invert 值为 true 时，取得是没有通过验证的 items
619 | 			// 默认值为 false , 取得是 通过验证的 items
620 | 
621 | 			// 求反之后更直观的表示
622 | 			// false 代表没有通过验证的 items
623 | 			// true 代表通过验证的 items
624 | 			callbackExpect = !invert;
625 | 
626 | 		// Go through the array, only saving the items
627 | 		// that pass the validator function
628 | 		// 过滤该数组，仅保存通过验证函数的 items
629 | 		// 遍历数组
630 | 		for ( ; i < length; i++ ) {
631 | 
632 | 			// 由于invert求反了，所以把返回值也求反了，这样更方便比较也是为了防止类型不同
633 | 			// 函数没有返回值的时候 默认为 undefined
634 | 			callbackInverse = !callback( elems[ i ], i );
635 | 			// 实际反转后返回值 不等于 期待返回值
636 | 			if ( callbackInverse !== callbackExpect ) {
637 | 				// 就把元素插入结果集
638 | 				matches.push( elems[ i ] );
639 | 			}
640 | 		}
641 | 
642 | 		// 返回最终结果集
643 | 		return matches;
644 | 	},
645 | 
646 | 	// 此方法用于将一个数组中的所有元素转换到另一个数组中
647 | 	// arg is for internal usage only
648 | 	// arg 仅供内部使用
649 | 	map: function( elems, callback, arg ) {
650 | 		// 用于保存临时保存返回值
651 | 		var value,
652 | 			// 保存 index
653 | 			i = 0,
654 | 			// 保存 elems的长度
655 | 			length = elems.length,
656 | 			// 判断 elems 长得像数组
657 | 			isArray = isArraylike( elems ),
658 | 			// 用于ret保存回调返回值的集合
659 | 			ret = [];
660 | 
661 | 		// Go through the array, translating each of the items to their new values
662 | 		// 通过数组，遍历每项转换新值
663 | 		if ( isArray ) {
664 | 			// 遍历数组
665 | 			for ( ; i < length; i++ ) {
666 | 				// 保存claaback的返回值
667 | 				value = callback( elems[ i ], i, arg );
668 | 
669 | 				// value非空
670 | 				if ( value != null ) {
671 | 					// 将返回值push到ret里
672 | 					ret.push( value );
673 | 				}
674 | 			}
675 | 
676 | 		// Go through every key on the object,
677 | 		} else {
678 | 			// 遍历对象
679 | 			for ( i in elems ) {
680 | 				// 保存claaback的返回值
681 | 				value = callback( elems[ i ], i, arg );
682 | 
683 | 				// value非空
684 | 				if ( value != null ) {
685 | 					// 将返回值push到ret里
686 | 					ret.push( value );
687 | 				}
688 | 			}
689 | 		}
690 | 
691 | 		// Flatten any nested arrays
692 | 		// 返回拼合任何嵌套的数组
693 | 		return concat.apply( [], ret );
694 | 	},
695 | 
696 | 	// A global GUID counter for objects
697 | 	// 一个全局的计数器，用于事件模块和缓存模块
698 | 	// 唯一标识，用于关联
699 | 	guid: 1,
700 | 
701 | 	// Bind a function to a context, optionally partially applying any
702 | 	// arguments.
703 | 	// 绑定一个函数到一个指定的上下文、任意数量的附加参数
704 | 	// 此方法用于接受一个函数，然后返回一个保持特定上下文的函数
705 | 	proxy: function( fn, context ) {
706 | 		// tmp 用于临时交换fn和context
707 | 		// args 用于保存fn的参数
708 | 		// proxy 代理函数
709 | 		var tmp, args, proxy;
710 | 
711 | 		// 参数context是一个字符串
712 | 		// 那么就是这种情况 var context = {  fn: function(){ console.log(this); } }
713 | 		// $.proxy( context, 'fn')
714 | 		// 那么就要 交换 fn、context的位置
715 | 		if ( typeof context === "string" ) {
716 | 			tmp = fn[ context ];
717 | 			context = fn;
718 | 			fn = tmp;
719 | 		}
720 | 
721 | 		// Quick check to determine if target is callable, in the spec
722 | 		// this throws a TypeError, but we will just return undefined.
723 | 		// 快速检测目标是否可调用的，在 spec 中会引发 TypeError ,但仅将返回 undefined
724 | 		if ( !jQuery.isFunction( fn ) ) {
725 | 			return undefined;
726 | 		}
727 | 
728 | 		// Simulated bind
729 | 		// 模拟绑定
730 | 		// 保存任意数量的附加参数(去除参数 fn 和 context)
731 | 		args = slice.call( arguments, 2 );
732 | 		proxy = function() {
733 | 			// 返回一个指定上下文的函数
734 | 			// 当context为null或undefined,代理函数将this对象作为context
735 | 			return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
736 | 		};
737 | 
738 | 		// Set the guid of unique handler to the same of original handler, so it can be removed
739 | 		// 统一guid，所以它可以被删除
740 | 		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
741 | 
742 | 		// 返回处理后的代理函数
743 | 		return proxy;
744 | 	},
745 | 
746 | 	// 用于获取当前时间戳
747 | 	now: Date.now,
748 | 
749 | 	// jQuery.support is not used in Core but other projects attach their
750 | 	// properties to it so it needs to exist.
751 | 	// jQuery.support 不用在Core中，但其他附加模块会用，因此需要存在
752 | 	support: support
753 | });
754 | 
755 | // Populate the class2type map
756 | // 填充 class2type
757 | // 储存JavaScript内置对象(包括宿主)
758 | // 用于JavaScript对象的检测结果对应匹配
759 | // 如：匹配 key:"[object Boolean]"得到value:boolean
760 | jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "),
761 | function(i, name) {
762 | 	class2type[ "[object " + name + "]" ] = name.toLowerCase();
763 | });
764 | 
765 | // 此方法用于检测obj是否长得像数组
766 | function isArraylike( obj ) {
767 | 	// 保存 obj的length属性
768 | 	var length = obj.length,
769 | 		// 执行 jQuery.type 工具方法 返回 obj 的类型
770 | 		type = jQuery.type( obj );
771 | 
772 |     // 判断 obj 是否为 function 或 obj 是 window 全局对象
773 |     // 如果是返回 false
774 | 	if ( type === "function" || jQuery.isWindow( obj ) ) {
775 | 		return false;
776 | 	}
777 | 
778 |     // 判断 obj 是否为 dom元素 且 其长度存在
779 |     // 说白了就是一个有元素的元素集
780 |     // 如果是返回 true
781 | 	if ( obj.nodeType === 1 && length ) {
782 | 		return true;
783 | 	}
784 | 
785 |     // obj类型既不是 function 也不是 window 更不是dom元素集时
786 |     // obj类型是 array,直接返回 true 如：[1,2,3]
787 |     // 若 obj的类型不是 array,则其 length 为 0 返回true  如：({ length:0 }).length 这样的类数组对象
788 | 	return type === "array" || length === 0 ||
789 | 	    // 若 obj的类型不是 array,且其 length不为 0 时  如： { 0:"first key", length:1 }
790 | 		// 其 length的类型应为 number、大于0且 (长度-1) 的 key在 obj里。
791 | 		// type length ！== 'number' 如： { length:"1" }
792 | 		// !( length > 0 )  如： { length:-1 }  如果length === 0之前已经判断，所以此处只有负数才不符合条件
793 | 		// !(( length - 1 ) in obj)  如： ({ length:3 }).length  而 3(length) - 1，key 为 2 , 压根 在{ length:3 } 就没有
794 | 		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
795 | }
796 | 
797 | return jQuery;
798 | });
799 | 


--------------------------------------------------------------------------------