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