3 "": "m[2]== '*'||a.nodeName.toUpperCase()==m[2].toUpperCase()",
4 "#": "a.getAttribute('id')==m[2]",
12 last: "i==r.length-1",
17 "nth-child": "jQuery.nth(a.parentNode.firstChild,m[3],'nextSibling')==a",
18 "first-child": "jQuery.nth(a.parentNode.firstChild,1,'nextSibling')==a",
19 "last-child": "jQuery.nth(a.parentNode.lastChild,1,'previousSibling')==a",
20 "only-child": "jQuery.sibling(a.parentNode.firstChild).length==1",
23 parent: "a.firstChild",
24 empty: "!a.firstChild",
27 contains: "jQuery.fn.text.apply([a]).indexOf(m[3])>=0",
30 visible: "a.type!='hidden'&&jQuery.css(a,'display')!='none'&&jQuery.css(a,'visibility')!='hidden'",
31 hidden: "a.type=='hidden'||jQuery.css(a,'display')=='none'||jQuery.css(a,'visibility')=='hidden'",
34 enabled: "!a.disabled",
35 disabled: "a.disabled",
37 selected: "a.selected || jQuery.attr(a, 'selected')",
40 text: "a.type=='text'",
41 radio: "a.type=='radio'",
42 checkbox: "a.type=='checkbox'",
43 file: "a.type=='file'",
44 password: "a.type=='password'",
45 submit: "a.type=='submit'",
46 image: "a.type=='image'",
47 reset: "a.type=='reset'",
48 button: "a.type=='button'||a.nodeName=='BUTTON'",
49 input: "/input|select|textarea|button/i.test(a.nodeName)"
51 ".": "jQuery.className.has(a,m[2])",
55 "^=": "z && !z.indexOf(m[4])",
56 "$=": "z && z.substr(z.length - m[4].length,m[4].length)==m[4]",
57 "*=": "z && z.indexOf(m[4])>=0",
60 return ["", m[1], m[3], m[2], m[5]];
62 _prefix: "z=a[m[3]]||jQuery.attr(a,m[3]);"
64 "[": "jQuery.find(m[2],a).length"
67 // The regular expressions that power the parsing engine
69 // Match: [@value='test'], [@foo]
70 "\\[ *(@)S *([!*$^=]*) *('?\"?)(.*?)\\4 *\\]",
72 // Match: [div], [div p]
73 "(\\[)\\s*(.*?(\\[.*?\\])?[^[]*?)\\s*\\]",
75 // Match: :contains('foo')
76 "(:)S\\(\"?'?(.*?(\\(.*?\\))?[^(]*?)\"?'?\\)",
78 // Match: :even, :last-chlid
83 "\\.\\.|/\\.\\.", "a.parentNode",
84 ">|/", "jQuery.sibling(a.firstChild)",
85 "\\+", "jQuery.nth(a,2,'nextSibling')",
87 var s = jQuery.sibling(a.parentNode.firstChild);
88 return s.slice(0, jQuery.inArray(a,s));
92 multiFilter: function( expr, elems, not ) {
95 while ( expr && expr != old ) {
96 console.log( cur, expr, elems, not );
97 var f = jQuery.filter( expr, elems, not );
98 expr = f.t.replace(/^\s*,\s*/, "" );
103 cur = jQuery.merge( cur, f.r );
105 console.log( "DONE", cur, expr, elems, not );
112 * @type Array<Element>
116 find: function( t, context ) {
117 // Quickly handle non-string expressions
118 if ( typeof t != "string" )
121 // Make sure that the context is a DOM Element
122 if ( context && !context.nodeType )
125 // Set the correct context (if none is provided)
126 context = context || document;
128 // Handle the common XPath // expression
129 if ( !t.indexOf("//") ) {
130 context = context.documentElement;
131 t = t.substr(2,t.length);
133 // And the / root expression
134 } else if ( !t.indexOf("/") ) {
135 context = context.documentElement;
136 t = t.substr(1,t.length);
137 if ( t.indexOf("/") >= 1 )
138 t = t.substr(t.indexOf("/"),t.length);
141 // Initialize the search
142 var ret = [context], done = [], last = null;
144 // Continue while a selector expression exists, and while
145 // we're no longer looping upon ourselves
146 while ( t && last != t ) {
150 t = jQuery.trim(t).replace( /^\/\//i, "" );
152 var foundToken = false;
154 // An attempt at speeding up child selectors that
155 // point to a specific element tag
156 var re = /^[\/>]\s*([a-z0-9*-]+)/i;
160 // Perform our own iteration and filter
161 for ( var i = 0, rl = ret.length; i < rl; i++ )
162 for ( var c = ret[i].firstChild; c; c = c.nextSibling )
163 if ( c.nodeType == 1 && ( c.nodeName == m[1].toUpperCase() || m[1] == "*" ) )
167 t = jQuery.trim( t.replace( re, "" ) );
170 // Look for pre-defined expression tokens
171 for ( var i = 0; i < jQuery.token.length; i += 2 ) {
172 // Attempt to match each, individual, token in
173 // the specified order
174 var re = new RegExp("^(" + jQuery.token[i] + ")");
177 // If the token match was found
179 // Map it against the token's handler
180 r = ret = jQuery.map( ret, jQuery.token[i+1].constructor == Function ?
182 function(a){ return eval(jQuery.token[i+1]); });
184 // And remove the token
185 t = jQuery.trim( t.replace( re, "" ) );
192 // See if there's still an expression, and that we haven't already
194 if ( t && !foundToken ) {
195 // Handle multiple expressions
196 if ( !t.indexOf(",") || !t.indexOf("|") ) {
197 // Clean teh result set
198 if ( ret[0] == context ) ret.shift();
200 // Merge the result sets
201 jQuery.merge( done, ret );
206 // Touch up the selector string
207 t = " " + t.substr(1,t.length);
210 // Optomize for the case nodeName#idName
211 var re2 = /^([a-z0-9_-]+)(#)([a-z0-9\\*_-]*)/i;
214 // Re-organize the results, so that they're consistent
216 m = [ 0, m[2], m[3], m[1] ];
219 // Otherwise, do a traditional filter check for
220 // ID, class, and element selectors
221 re2 = /^([#.]?)([a-z0-9\\*_-]*)/i;
225 // Try to do a global search by ID, where we can
226 if ( m[1] == "#" && ret[ret.length-1].getElementById ) {
227 // Optimization for HTML document case
228 var oid = ret[ret.length-1].getElementById(m[2]);
230 // Do a quick check for node name (where applicable) so
231 // that div#foo searches will be really fast
233 (!m[3] || oid.nodeName == m[3].toUpperCase()) ? [oid] : [];
236 // Pre-compile a regular expression to handle class searches
238 var rec = new RegExp("(^|\\s)" + m[2] + "(\\s|$)");
240 // We need to find all descendant elements, it is more
241 // efficient to use getAll() when we are already further down
242 // the tree - we try to recognize that here
243 for ( var i = 0, rl = ret.length; i < rl; i++ )
245 m[1] != "" && ret.length != 1 ?
246 jQuery.getAll( ret[i], [], m[1], m[2], rec ) :
247 ret[i].getElementsByTagName( m[1] != "" || m[0] == "" ? "*" : m[2] )
250 // It's faster to filter by class and be done with it
251 if ( m[1] == "." && ret.length == 1 )
252 r = jQuery.grep( r, function(e) {
253 return rec.test(e.className);
256 // Same with ID filtering
257 if ( m[1] == "#" && ret.length == 1 ) {
258 // Remember, then wipe out, the result set
262 // Then try to find the element with the ID
263 for ( var i = 0, tl = tmp.length; i < tl; i++ )
264 if ( tmp[i].getAttribute("id") == m[2] ) {
273 t = t.replace( re2, "" );
278 // If a selector string still exists
280 // Attempt to filter it
281 var val = jQuery.filter(t,r);
283 t = jQuery.trim(val.t);
287 // Remove the root context
288 if ( ret && ret[0] == context ) ret.shift();
290 // And combine the results
291 jQuery.merge( done, ret );
296 filter: function(t,r,not) {
297 // Look for common filter expressions
298 while ( t && /^[a-z[({<*:.#]/i.test(t) ) {
300 var p = jQuery.parse;
302 for ( var i = 0, pl = p.length; i < pl; i++ ) {
304 // Look for, and replace, string-like sequences
305 // and finally build a regexp out of it
307 "^" + p[i].replace("S", "([a-z*_-][a-z0-9_-]*)"), "i" );
309 var m = re.exec( t );
312 // Re-organize the first match
313 if ( jQuery.expr[ m[1] ]._resort )
314 m = jQuery.expr[ m[1] ]._resort( m );
316 // Remove what we just matched
317 t = t.replace( re, "" );
323 // :not() is a special case that can be optimized by
324 // keeping it out of the expression list
325 if ( m[1] == ":" && m[2] == "not" )
326 r = jQuery.filter(m[3], r, true).r;
328 // Handle classes as a special case (this will help to
329 // improve the speed, as the regexp will only be compiled once)
330 else if ( m[1] == "." ) {
332 var re = new RegExp("(^|\\s)" + m[2] + "(\\s|$)");
333 r = jQuery.grep( r, function(e){
334 return re.test(e.className || '');
337 // Otherwise, find the expression to execute
339 var f = jQuery.expr[m[1]];
340 if ( typeof f != "string" )
341 f = jQuery.expr[m[1]][m[2]];
343 // Build a custom macro to enclose it
344 eval("f = function(a,i){" +
345 ( jQuery.expr[ m[1] ]._prefix || "" ) +
346 "return " + f + "}");
348 // Execute it against the current filter
349 r = jQuery.grep( r, f, not );
353 // Return an array of filtered elements (r)
354 // and the modified expression string (t)
355 return { r: r, t: t };
358 getAll: function( o, r, token, name, re ) {
359 for ( var s = o.firstChild; s; s = s.nextSibling )
360 if ( s.nodeType == 1 ) {
364 add = s.className && re.test(s.className);
365 else if ( token == "#" )
366 add = s.getAttribute('id') == name;
371 if ( token == "#" && r.length ) break;
374 jQuery.getAll( s, r, token, name, re );
381 * All ancestors of a given element.
385 * @type Array<Element>
386 * @param Element elem The element to find the ancestors of.
387 * @cat DOM/Traversing
389 parents: function( elem ){
391 var cur = elem.parentNode;
392 while ( cur && cur != document ) {
394 cur = cur.parentNode;
400 * A handy, and fast, way to traverse in a particular direction and find
401 * a specific element.
406 * @param DOMElement cur The element to search from.
407 * @param Number|String num The Nth result to match. Can be a number or a string (like 'even' or 'odd').
408 * @param String dir The direction to move in (pass in something like 'previousSibling' or 'nextSibling').
409 * @cat DOM/Traversing
411 nth: function(cur,result,dir){
412 result = result || 1;
414 for ( ; cur; cur = cur[dir] ) {
415 if ( cur.nodeType == 1 ) num++;
416 if ( num == result || result == "even" && num % 2 == 0 && num > 1 ||
417 result == "odd" && num % 2 == 1 ) return cur;
422 * All elements on a specified axis.
427 * @param Element elem The element to find all the siblings of (including itself).
428 * @cat DOM/Traversing
430 sibling: function( n, elem ) {
433 for ( ; n; n = n.nextSibling ) {
434 if ( n.nodeType == 1 && (!elem || n != elem) )