Reviewed by Darin.
[WebKit-https.git] / WebKitSite / perf / slickspeed / frameworks / DomQuery.js
1 /*\r
2  * Ext JS Library 2.0\r
3  * Copyright(c) 2006-2007, Ext JS, LLC.\r
4  * licensing@extjs.com\r
5  * \r
6  * http://extjs.com/license\r
7  */\r
8 \r
9 /*\r
10  * This is code is also distributed under MIT license for use\r
11  * with jQuery and prototype JavaScript libraries.\r
12  */\r
13 /**\r
14  * @class Ext.DomQuery\r
15 Provides high performance selector/xpath processing by compiling queries into reusable functions. New pseudo classes and matchers can be plugged. It works on HTML and XML documents (if a content node is passed in).\r
16 <p>\r
17 DomQuery supports most of the <a href="http://www.w3.org/TR/2005/WD-css3-selectors-20051215/#selectors">CSS3 selectors spec</a>, along with some custom selectors and basic XPath.</p>\r
18 \r
19 <p>\r
20 All selectors, attribute filters and pseudos below can be combined infinitely in any order. For example "div.foo:nth-child(odd)[@foo=bar].bar:first" would be a perfectly valid selector. Node filters are processed in the order in which they appear, which allows you to optimize your queries for your document structure.\r
21 </p>\r
22 <h4>Element Selectors:</h4>\r
23 <ul class="list">\r
24     <li> <b>*</b> any element</li>\r
25     <li> <b>E</b> an element with the tag E</li>\r
26     <li> <b>E F</b> All descendent elements of E that have the tag F</li>\r
27     <li> <b>E > F</b> or <b>E/F</b> all direct children elements of E that have the tag F</li>\r
28     <li> <b>E + F</b> all elements with the tag F that are immediately preceded by an element with the tag E</li>\r
29     <li> <b>E ~ F</b> all elements with the tag F that are preceded by a sibling element with the tag E</li>\r
30 </ul>\r
31 <h4>Attribute Selectors:</h4>\r
32 <p>The use of @ and quotes are optional. For example, div[@foo='bar'] is also a valid attribute selector.</p>\r
33 <ul class="list">\r
34     <li> <b>E[foo]</b> has an attribute "foo"</li>\r
35     <li> <b>E[foo=bar]</b> has an attribute "foo" that equals "bar"</li>\r
36     <li> <b>E[foo^=bar]</b> has an attribute "foo" that starts with "bar"</li>\r
37     <li> <b>E[foo$=bar]</b> has an attribute "foo" that ends with "bar"</li>\r
38     <li> <b>E[foo*=bar]</b> has an attribute "foo" that contains the substring "bar"</li>\r
39     <li> <b>E[foo%=2]</b> has an attribute "foo" that is evenly divisible by 2</li>\r
40     <li> <b>E[foo!=bar]</b> has an attribute "foo" that does not equal "bar"</li>\r
41 </ul>\r
42 <h4>Pseudo Classes:</h4>\r
43 <ul class="list">\r
44     <li> <b>E:first-child</b> E is the first child of its parent</li>\r
45     <li> <b>E:last-child</b> E is the last child of its parent</li>\r
46     <li> <b>E:nth-child(<i>n</i>)</b> E is the <i>n</i>th child of its parent (1 based as per the spec)</li>\r
47     <li> <b>E:nth-child(odd)</b> E is an odd child of its parent</li>\r
48     <li> <b>E:nth-child(even)</b> E is an even child of its parent</li>\r
49     <li> <b>E:only-child</b> E is the only child of its parent</li>\r
50     <li> <b>E:checked</b> E is an element that is has a checked attribute that is true (e.g. a radio or checkbox) </li>\r
51     <li> <b>E:first</b> the first E in the resultset</li>\r
52     <li> <b>E:last</b> the last E in the resultset</li>\r
53     <li> <b>E:nth(<i>n</i>)</b> the <i>n</i>th E in the resultset (1 based)</li>\r
54     <li> <b>E:odd</b> shortcut for :nth-child(odd)</li>\r
55     <li> <b>E:even</b> shortcut for :nth-child(even)</li>\r
56     <li> <b>E:contains(foo)</b> E's innerHTML contains the substring "foo"</li>\r
57     <li> <b>E:nodeValue(foo)</b> E contains a textNode with a nodeValue that equals "foo"</li>\r
58     <li> <b>E:not(S)</b> an E element that does not match simple selector S</li>\r
59     <li> <b>E:has(S)</b> an E element that has a descendent that matches simple selector S</li>\r
60     <li> <b>E:next(S)</b> an E element whose next sibling matches simple selector S</li>\r
61     <li> <b>E:prev(S)</b> an E element whose previous sibling matches simple selector S</li>\r
62 </ul>\r
63 <h4>CSS Value Selectors:</h4>\r
64 <ul class="list">\r
65     <li> <b>E{display=none}</b> css value "display" that equals "none"</li>\r
66     <li> <b>E{display^=none}</b> css value "display" that starts with "none"</li>\r
67     <li> <b>E{display$=none}</b> css value "display" that ends with "none"</li>\r
68     <li> <b>E{display*=none}</b> css value "display" that contains the substring "none"</li>\r
69     <li> <b>E{display%=2}</b> css value "display" that is evenly divisible by 2</li>\r
70     <li> <b>E{display!=none}</b> css value "display" that does not equal "none"</li>\r
71 </ul>\r
72  * @singleton\r
73  */\r
74 Ext = {};\r
75  \r
76 Ext.DomQuery = function(){\r
77     var cache = {}, simpleCache = {}, valueCache = {};\r
78     var nonSpace = /\S/;\r
79     var trimRe = /^\s+|\s+$/g;\r
80     var tplRe = /\{(\d+)\}/g;\r
81     var modeRe = /^(\s?[\/>+~]\s?|\s|$)/;\r
82     var tagTokenRe = /^(#)?([\w-\*]+)/;\r
83     var nthRe = /(\d*)n\+?(\d*)/, nthRe2 = /\D/;\r
84 \r
85     function child(p, index){\r
86         var i = 0;\r
87         var n = p.firstChild;\r
88         while(n){\r
89             if(n.nodeType == 1){\r
90                if(++i == index){\r
91                    return n;\r
92                }\r
93             }\r
94             n = n.nextSibling;\r
95         }\r
96         return null;\r
97     };\r
98 \r
99     function next(n){\r
100         while((n = n.nextSibling) && n.nodeType != 1);\r
101         return n;\r
102     };\r
103 \r
104     function prev(n){\r
105         while((n = n.previousSibling) && n.nodeType != 1);\r
106         return n;\r
107     };\r
108 \r
109     function children(d){\r
110         var n = d.firstChild, ni = -1;\r
111             while(n){\r
112                 var nx = n.nextSibling;\r
113                 if(n.nodeType == 3 && !nonSpace.test(n.nodeValue)){\r
114                     d.removeChild(n);\r
115                 }else{\r
116                     n.nodeIndex = ++ni;\r
117                 }\r
118                 n = nx;\r
119             }\r
120             return this;\r
121         };\r
122 \r
123     function byClassName(c, a, v){\r
124         if(!v){\r
125             return c;\r
126         }\r
127         var r = [], ri = -1, cn;\r
128         for(var i = 0, ci; ci = c[i]; i++){\r
129             if((' '+ci.className+' ').indexOf(v) != -1){\r
130                 r[++ri] = ci;\r
131             }\r
132         }\r
133         return r;\r
134     };\r
135 \r
136     function attrValue(n, attr){\r
137         if(!n.tagName && typeof n.length != "undefined"){\r
138             n = n[0];\r
139         }\r
140         if(!n){\r
141             return null;\r
142         }\r
143         if(attr == "for"){\r
144             return n.htmlFor;\r
145         }\r
146         if(attr == "class" || attr == "className"){\r
147             return n.className;\r
148         }\r
149         return n.getAttribute(attr) || n[attr];\r
150 \r
151     };\r
152 \r
153     function getNodes(ns, mode, tagName){\r
154         var result = [], ri = -1, cs;\r
155         if(!ns){\r
156             return result;\r
157         }\r
158         tagName = tagName || "*";\r
159         if(typeof ns.getElementsByTagName != "undefined"){\r
160             ns = [ns];\r
161         }\r
162         if(!mode){\r
163             for(var i = 0, ni; ni = ns[i]; i++){\r
164                 cs = ni.getElementsByTagName(tagName);\r
165                 for(var j = 0, ci; ci = cs[j]; j++){\r
166                     result[++ri] = ci;\r
167                 }\r
168             }\r
169         }else if(mode == "/" || mode == ">"){\r
170             var utag = tagName.toUpperCase();\r
171             for(var i = 0, ni, cn; ni = ns[i]; i++){\r
172                 cn = ni.children || ni.childNodes;\r
173                 for(var j = 0, cj; cj = cn[j]; j++){\r
174                     if(cj.nodeName == utag || cj.nodeName == tagName  || tagName == '*'){\r
175                         result[++ri] = cj;\r
176                     }\r
177                 }\r
178             }\r
179         }else if(mode == "+"){\r
180             var utag = tagName.toUpperCase();\r
181             for(var i = 0, n; n = ns[i]; i++){\r
182                 while((n = n.nextSibling) && n.nodeType != 1);\r
183                 if(n && (n.nodeName == utag || n.nodeName == tagName || tagName == '*')){\r
184                     result[++ri] = n;\r
185                 }\r
186             }\r
187         }else if(mode == "~"){\r
188             for(var i = 0, n; n = ns[i]; i++){\r
189                 while((n = n.nextSibling) && (n.nodeType != 1 || (tagName == '*' || n.tagName.toLowerCase()!=tagName)));\r
190                 if(n){\r
191                     result[++ri] = n;\r
192                 }\r
193             }\r
194         }\r
195         return result;\r
196     };\r
197 \r
198     function concat(a, b){\r
199         if(b.slice){\r
200             return a.concat(b);\r
201         }\r
202         for(var i = 0, l = b.length; i < l; i++){\r
203             a[a.length] = b[i];\r
204         }\r
205         return a;\r
206     }\r
207 \r
208     function byTag(cs, tagName){\r
209         if(cs.tagName || cs == document){\r
210             cs = [cs];\r
211         }\r
212         if(!tagName){\r
213             return cs;\r
214         }\r
215         var r = [], ri = -1;\r
216         tagName = tagName.toLowerCase();\r
217         for(var i = 0, ci; ci = cs[i]; i++){\r
218             if(ci.nodeType == 1 && ci.tagName.toLowerCase()==tagName){\r
219                 r[++ri] = ci;\r
220             }\r
221         }\r
222         return r;\r
223     };\r
224 \r
225     function byId(cs, attr, id){\r
226         if(cs.tagName || cs == document){\r
227             cs = [cs];\r
228         }\r
229         if(!id){\r
230             return cs;\r
231         }\r
232         var r = [], ri = -1;\r
233         for(var i = 0,ci; ci = cs[i]; i++){\r
234             if(ci && ci.id == id){\r
235                 r[++ri] = ci;\r
236                 return r;\r
237             }\r
238         }\r
239         return r;\r
240     };\r
241 \r
242     function byAttribute(cs, attr, value, op, custom){\r
243         var r = [], ri = -1, st = custom=="{";\r
244         var f = Ext.DomQuery.operators[op];\r
245         for(var i = 0, ci; ci = cs[i]; i++){\r
246             var a;\r
247             if(st){\r
248                 a = Ext.DomQuery.getStyle(ci, attr);\r
249             }\r
250             else if(attr == "class" || attr == "className"){\r
251                 a = ci.className;\r
252             }else if(attr == "for"){\r
253                 a = ci.htmlFor;\r
254             }else if(attr == "href"){\r
255                 a = ci.getAttribute("href", 2);\r
256             }else{\r
257                 a = ci.getAttribute(attr);\r
258             }\r
259             if((f && f(a, value)) || (!f && a)){\r
260                 r[++ri] = ci;\r
261             }\r
262         }\r
263         return r;\r
264     };\r
265 \r
266     function byPseudo(cs, name, value){\r
267         return Ext.DomQuery.pseudos[name](cs, value);\r
268     };\r
269 \r
270     // This is for IE MSXML which does not support expandos.\r
271     // IE runs the same speed using setAttribute, however FF slows way down\r
272     // and Safari completely fails so they need to continue to use expandos.\r
273     var isIE = window.ActiveXObject ? true : false;\r
274 \r
275     // this eval is stop the compressor from\r
276     // renaming the variable to something shorter\r
277     eval("var batch = 30803;");\r
278 \r
279     var key = 30803;\r
280 \r
281     function nodupIEXml(cs){\r
282         var d = ++key;\r
283         cs[0].setAttribute("_nodup", d);\r
284         var r = [cs[0]];\r
285         for(var i = 1, len = cs.length; i < len; i++){\r
286             var c = cs[i];\r
287             if(!c.getAttribute("_nodup") != d){\r
288                 c.setAttribute("_nodup", d);\r
289                 r[r.length] = c;\r
290             }\r
291         }\r
292         for(var i = 0, len = cs.length; i < len; i++){\r
293             cs[i].removeAttribute("_nodup");\r
294         }\r
295         return r;\r
296     }\r
297 \r
298     function nodup(cs){\r
299         if(!cs){\r
300             return [];\r
301         }\r
302         var len = cs.length, c, i, r = cs, cj, ri = -1;\r
303         if(!len || typeof cs.nodeType != "undefined" || len == 1){\r
304             return cs;\r
305         }\r
306         if(isIE && typeof cs[0].selectSingleNode != "undefined"){\r
307             return nodupIEXml(cs);\r
308         }\r
309         var d = ++key;\r
310         cs[0]._nodup = d;\r
311         for(i = 1; c = cs[i]; i++){\r
312             if(c._nodup != d){\r
313                 c._nodup = d;\r
314             }else{\r
315                 r = [];\r
316                 for(var j = 0; j < i; j++){\r
317                     r[++ri] = cs[j];\r
318                 }\r
319                 for(j = i+1; cj = cs[j]; j++){\r
320                     if(cj._nodup != d){\r
321                         cj._nodup = d;\r
322                         r[++ri] = cj;\r
323                     }\r
324                 }\r
325                 return r;\r
326             }\r
327         }\r
328         return r;\r
329     }\r
330 \r
331     function quickDiffIEXml(c1, c2){\r
332         var d = ++key;\r
333         for(var i = 0, len = c1.length; i < len; i++){\r
334             c1[i].setAttribute("_qdiff", d);\r
335         }\r
336         var r = [];\r
337         for(var i = 0, len = c2.length; i < len; i++){\r
338             if(c2[i].getAttribute("_qdiff") != d){\r
339                 r[r.length] = c2[i];\r
340             }\r
341         }\r
342         for(var i = 0, len = c1.length; i < len; i++){\r
343            c1[i].removeAttribute("_qdiff");\r
344         }\r
345         return r;\r
346     }\r
347 \r
348     function quickDiff(c1, c2){\r
349         var len1 = c1.length;\r
350         if(!len1){\r
351             return c2;\r
352         }\r
353         if(isIE && c1[0].selectSingleNode){\r
354             return quickDiffIEXml(c1, c2);\r
355         }\r
356         var d = ++key;\r
357         for(var i = 0; i < len1; i++){\r
358             c1[i]._qdiff = d;\r
359         }\r
360         var r = [];\r
361         for(var i = 0, len = c2.length; i < len; i++){\r
362             if(c2[i]._qdiff != d){\r
363                 r[r.length] = c2[i];\r
364             }\r
365         }\r
366         return r;\r
367     }\r
368 \r
369     function quickId(ns, mode, root, id){\r
370         if(ns == root){\r
371            var d = root.ownerDocument || root;\r
372            return d.getElementById(id);\r
373         }\r
374         ns = getNodes(ns, mode, "*");\r
375         return byId(ns, null, id);\r
376     }\r
377 \r
378     return {\r
379         getStyle : function(el, name){\r
380             return Ext.fly(el).getStyle(name);\r
381         },\r
382         /**\r
383          * Compiles a selector/xpath query into a reusable function. The returned function\r
384          * takes one parameter "root" (optional), which is the context node from where the query should start.\r
385          * @param {String} selector The selector/xpath query\r
386          * @param {String} type (optional) Either "select" (the default) or "simple" for a simple selector match\r
387          * @return {Function}\r
388          */\r
389         compile : function(path, type){\r
390             type = type || "select";\r
391 \r
392             var fn = ["var f = function(root){\n var mode; ++batch; var n = root || document;\n"];\r
393             var q = path, mode, lq;\r
394             var tk = Ext.DomQuery.matchers;\r
395             var tklen = tk.length;\r
396             var mm;\r
397 \r
398             // accept leading mode switch\r
399             var lmode = q.match(modeRe);\r
400             if(lmode && lmode[1]){\r
401                 fn[fn.length] = 'mode="'+lmode[1].replace(trimRe, "")+'";';\r
402                 q = q.replace(lmode[1], "");\r
403             }\r
404             // strip leading slashes\r
405             while(path.substr(0, 1)=="/"){\r
406                 path = path.substr(1);\r
407             }\r
408 \r
409             while(q && lq != q){\r
410                 lq = q;\r
411                 var tm = q.match(tagTokenRe);\r
412                 if(type == "select"){\r
413                     if(tm){\r
414                         if(tm[1] == "#"){\r
415                             fn[fn.length] = 'n = quickId(n, mode, root, "'+tm[2]+'");';\r
416                         }else{\r
417                             fn[fn.length] = 'n = getNodes(n, mode, "'+tm[2]+'");';\r
418                         }\r
419                         q = q.replace(tm[0], "");\r
420                     }else if(q.substr(0, 1) != '@'){\r
421                         fn[fn.length] = 'n = getNodes(n, mode, "*");';\r
422                     }\r
423                 }else{\r
424                     if(tm){\r
425                         if(tm[1] == "#"){\r
426                             fn[fn.length] = 'n = byId(n, null, "'+tm[2]+'");';\r
427                         }else{\r
428                             fn[fn.length] = 'n = byTag(n, "'+tm[2]+'");';\r
429                         }\r
430                         q = q.replace(tm[0], "");\r
431                     }\r
432                 }\r
433                 while(!(mm = q.match(modeRe))){\r
434                     var matched = false;\r
435                     for(var j = 0; j < tklen; j++){\r
436                         var t = tk[j];\r
437                         var m = q.match(t.re);\r
438                         if(m){\r
439                             fn[fn.length] = t.select.replace(tplRe, function(x, i){\r
440                                                     return m[i];\r
441                                                 });\r
442                             q = q.replace(m[0], "");\r
443                             matched = true;\r
444                             break;\r
445                         }\r
446                     }\r
447                     // prevent infinite loop on bad selector\r
448                     if(!matched){\r
449                         throw 'Error parsing selector, parsing failed at "' + q + '"';\r
450                     }\r
451                 }\r
452                 if(mm[1]){\r
453                     fn[fn.length] = 'mode="'+mm[1].replace(trimRe, "")+'";';\r
454                     q = q.replace(mm[1], "");\r
455                 }\r
456             }\r
457             fn[fn.length] = "return nodup(n);\n}";\r
458             eval(fn.join(""));\r
459             return f;\r
460         },\r
461 \r
462         /**\r
463          * Selects a group of elements.\r
464          * @param {String} selector The selector/xpath query (can be a comma separated list of selectors)\r
465          * @param {Node} root (optional) The start of the query (defaults to document).\r
466          * @return {Array}\r
467          */\r
468         select : function(path, root, type){\r
469             if(!root || root == document){\r
470                 root = document;\r
471             }\r
472             if(typeof root == "string"){\r
473                 root = document.getElementById(root);\r
474             }\r
475             var paths = path.split(",");\r
476             var results = [];\r
477             for(var i = 0, len = paths.length; i < len; i++){\r
478                 var p = paths[i].replace(trimRe, "");\r
479                 if(!cache[p]){\r
480                     cache[p] = Ext.DomQuery.compile(p);\r
481                     if(!cache[p]){\r
482                         throw p + " is not a valid selector";\r
483                     }\r
484                 }\r
485                 var result = cache[p](root);\r
486                 if(result && result != document){\r
487                     results = results.concat(result);\r
488                 }\r
489             }\r
490             if(paths.length > 1){\r
491                 return nodup(results);\r
492             }\r
493             return results;\r
494         },\r
495 \r
496         /**\r
497          * Selects a single element.\r
498          * @param {String} selector The selector/xpath query\r
499          * @param {Node} root (optional) The start of the query (defaults to document).\r
500          * @return {Element}\r
501          */\r
502         selectNode : function(path, root){\r
503             return Ext.DomQuery.select(path, root)[0];\r
504         },\r
505 \r
506         /**\r
507          * Selects the value of a node, optionally replacing null with the defaultValue.\r
508          * @param {String} selector The selector/xpath query\r
509          * @param {Node} root (optional) The start of the query (defaults to document).\r
510          * @param {String} defaultValue\r
511          */\r
512         selectValue : function(path, root, defaultValue){\r
513             path = path.replace(trimRe, "");\r
514             if(!valueCache[path]){\r
515                 valueCache[path] = Ext.DomQuery.compile(path, "select");\r
516             }\r
517             var n = valueCache[path](root);\r
518             n = n[0] ? n[0] : n;\r
519             var v = (n && n.firstChild ? n.firstChild.nodeValue : null);\r
520             return ((v === null||v === undefined||v==='') ? defaultValue : v);\r
521         },\r
522 \r
523         /**\r
524          * Selects the value of a node, parsing integers and floats.\r
525          * @param {String} selector The selector/xpath query\r
526          * @param {Node} root (optional) The start of the query (defaults to document).\r
527          * @param {Number} defaultValue\r
528          * @return {Number}\r
529          */\r
530         selectNumber : function(path, root, defaultValue){\r
531             var v = Ext.DomQuery.selectValue(path, root, defaultValue || 0);\r
532             return parseFloat(v);\r
533         },\r
534 \r
535         /**\r
536          * Returns true if the passed element(s) match the passed simple selector (e.g. div.some-class or span:first-child)\r
537          * @param {String/HTMLElement/Array} el An element id, element or array of elements\r
538          * @param {String} selector The simple selector to test\r
539          * @return {Boolean}\r
540          */\r
541         is : function(el, ss){\r
542             if(typeof el == "string"){\r
543                 el = document.getElementById(el);\r
544             }\r
545             var isArray = (el instanceof Array);\r
546             var result = Ext.DomQuery.filter(isArray ? el : [el], ss);\r
547             return isArray ? (result.length == el.length) : (result.length > 0);\r
548         },\r
549 \r
550         /**\r
551          * Filters an array of elements to only include matches of a simple selector (e.g. div.some-class or span:first-child)\r
552          * @param {Array} el An array of elements to filter\r
553          * @param {String} selector The simple selector to test\r
554          * @param {Boolean} nonMatches If true, it returns the elements that DON'T match\r
555          * the selector instead of the ones that match\r
556          * @return {Array}\r
557          */\r
558         filter : function(els, ss, nonMatches){\r
559             ss = ss.replace(trimRe, "");\r
560             if(!simpleCache[ss]){\r
561                 simpleCache[ss] = Ext.DomQuery.compile(ss, "simple");\r
562             }\r
563             var result = simpleCache[ss](els);\r
564             return nonMatches ? quickDiff(result, els) : result;\r
565         },\r
566 \r
567         /**\r
568          * Collection of matching regular expressions and code snippets.\r
569          */\r
570         matchers : [{\r
571                 re: /^\.([\w-]+)/,\r
572                 select: 'n = byClassName(n, null, " {1} ");'\r
573             }, {\r
574                 re: /^\:([\w-]+)(?:\(((?:[^\s>\/]*|.*?))\))?/,\r
575                 select: 'n = byPseudo(n, "{1}", "{2}");'\r
576             },{\r
577                 re: /^(?:([\[\{])(?:@)?([\w-]+)\s?(?:(=|.=)\s?['"]?(.*?)["']?)?[\]\}])/,\r
578                 select: 'n = byAttribute(n, "{2}", "{4}", "{3}", "{1}");'\r
579             }, {\r
580                 re: /^#([\w-]+)/,\r
581                 select: 'n = byId(n, null, "{1}");'\r
582             },{\r
583                 re: /^@([\w-]+)/,\r
584                 select: 'return {firstChild:{nodeValue:attrValue(n, "{1}")}};'\r
585             }\r
586         ],\r
587 \r
588         /**\r
589          * Collection of operator comparison functions. The default operators are =, !=, ^=, $=, *=, %=, |= and ~=.\r
590          * New operators can be added as long as the match the format <i>c</i>= where <i>c</i> is any character other than space, &gt; &lt;.\r
591          */\r
592         operators : {\r
593             "=" : function(a, v){\r
594                 return a == v;\r
595             },\r
596             "!=" : function(a, v){\r
597                 return a != v;\r
598             },\r
599             "^=" : function(a, v){\r
600                 return a && a.substr(0, v.length) == v;\r
601             },\r
602             "$=" : function(a, v){\r
603                 return a && a.substr(a.length-v.length) == v;\r
604             },\r
605             "*=" : function(a, v){\r
606                 return a && a.indexOf(v) !== -1;\r
607             },\r
608             "%=" : function(a, v){\r
609                 return (a % v) == 0;\r
610             },\r
611             "|=" : function(a, v){\r
612                 return a && (a == v || a.substr(0, v.length+1) == v+'-');\r
613             },\r
614             "~=" : function(a, v){\r
615                 return a && (' '+a+' ').indexOf(' '+v+' ') != -1;\r
616             }\r
617         },\r
618 \r
619         /**\r
620          * Collection of "pseudo class" processors. Each processor is passed the current nodeset (array)\r
621          * and the argument (if any) supplied in the selector.\r
622          */\r
623         pseudos : {\r
624             "first-child" : function(c){\r
625                 var r = [], ri = -1, n;\r
626                 for(var i = 0, ci; ci = n = c[i]; i++){\r
627                     while((n = n.previousSibling) && n.nodeType != 1);\r
628                     if(!n){\r
629                         r[++ri] = ci;\r
630                     }\r
631                 }\r
632                 return r;\r
633             },\r
634 \r
635             "last-child" : function(c){\r
636                 var r = [], ri = -1, n;\r
637                 for(var i = 0, ci; ci = n = c[i]; i++){\r
638                     while((n = n.nextSibling) && n.nodeType != 1);\r
639                     if(!n){\r
640                         r[++ri] = ci;\r
641                     }\r
642                 }\r
643                 return r;\r
644             },\r
645 \r
646             "nth-child" : function(c, a) {\r
647                 var r = [], ri = -1;\r
648                 var m = nthRe.exec(a == "even" && "2n" || a == "odd" && "2n+1" || !nthRe2.test(a) && "n+" + a || a);\r
649                 var f = (m[1] || 1) - 0, l = m[2] - 0;\r
650                 for(var i = 0, n; n = c[i]; i++){\r
651                     var pn = n.parentNode;\r
652                     if (batch != pn._batch) {\r
653                         var j = 0;\r
654                         for(var cn = pn.firstChild; cn; cn = cn.nextSibling){\r
655                             if(cn.nodeType == 1){\r
656                                cn.nodeIndex = ++j;\r
657                             }\r
658                         }\r
659                         pn._batch = batch;\r
660                     }\r
661                     if (f == 1) {\r
662                         if (l == 0 || n.nodeIndex == l){\r
663                             r[++ri] = n;\r
664                         }\r
665                     } else if ((n.nodeIndex + l) % f == 0){\r
666                         r[++ri] = n;\r
667                     }\r
668                 }\r
669 \r
670                 return r;\r
671             },\r
672 \r
673             "only-child" : function(c){\r
674                 var r = [], ri = -1;;\r
675                 for(var i = 0, ci; ci = c[i]; i++){\r
676                     if(!prev(ci) && !next(ci)){\r
677                         r[++ri] = ci;\r
678                     }\r
679                 }\r
680                 return r;\r
681             },\r
682 \r
683             "empty" : function(c){\r
684                 var r = [], ri = -1;\r
685                 for(var i = 0, ci; ci = c[i]; i++){\r
686                     var cns = ci.childNodes, j = 0, cn, empty = true;\r
687                     while(cn = cns[j]){\r
688                         ++j;\r
689                         if(cn.nodeType == 1 || cn.nodeType == 3){\r
690                             empty = false;\r
691                             break;\r
692                         }\r
693                     }\r
694                     if(empty){\r
695                         r[++ri] = ci;\r
696                     }\r
697                 }\r
698                 return r;\r
699             },\r
700 \r
701             "contains" : function(c, v){\r
702                 var r = [], ri = -1;\r
703                 for(var i = 0, ci; ci = c[i]; i++){\r
704                     if((ci.textContent||ci.innerText||'').indexOf(v) != -1){\r
705                         r[++ri] = ci;\r
706                     }\r
707                 }\r
708                 return r;\r
709             },\r
710 \r
711             "nodeValue" : function(c, v){\r
712                 var r = [], ri = -1;\r
713                 for(var i = 0, ci; ci = c[i]; i++){\r
714                     if(ci.firstChild && ci.firstChild.nodeValue == v){\r
715                         r[++ri] = ci;\r
716                     }\r
717                 }\r
718                 return r;\r
719             },\r
720 \r
721             "checked" : function(c){\r
722                 var r = [], ri = -1;\r
723                 for(var i = 0, ci; ci = c[i]; i++){\r
724                     if(ci.checked == true){\r
725                         r[++ri] = ci;\r
726                     }\r
727                 }\r
728                 return r;\r
729             },\r
730 \r
731             "not" : function(c, ss){\r
732                 return Ext.DomQuery.filter(c, ss, true);\r
733             },\r
734 \r
735             "any" : function(c, selectors){\r
736                 var ss = selectors.split('|');\r
737                 var r = [], ri = -1, s;\r
738                 for(var i = 0, ci; ci = c[i]; i++){\r
739                     for(var j = 0; s = ss[j]; j++){\r
740                         if(Ext.DomQuery.is(ci, s)){\r
741                             r[++ri] = ci;\r
742                             break;\r
743                         }\r
744                     }\r
745                 }\r
746                 return r;\r
747             },\r
748 \r
749             "odd" : function(c){\r
750                 return this["nth-child"](c, "odd");\r
751             },\r
752 \r
753             "even" : function(c){\r
754                 return this["nth-child"](c, "even");\r
755             },\r
756 \r
757             "nth" : function(c, a){\r
758                 return c[a-1] || [];\r
759             },\r
760 \r
761             "first" : function(c){\r
762                 return c[0] || [];\r
763             },\r
764 \r
765             "last" : function(c){\r
766                 return c[c.length-1] || [];\r
767             },\r
768 \r
769             "has" : function(c, ss){\r
770                 var s = Ext.DomQuery.select;\r
771                 var r = [], ri = -1;\r
772                 for(var i = 0, ci; ci = c[i]; i++){\r
773                     if(s(ss, ci).length > 0){\r
774                         r[++ri] = ci;\r
775                     }\r
776                 }\r
777                 return r;\r
778             },\r
779 \r
780             "next" : function(c, ss){\r
781                 var is = Ext.DomQuery.is;\r
782                 var r = [], ri = -1;\r
783                 for(var i = 0, ci; ci = c[i]; i++){\r
784                     var n = next(ci);\r
785                     if(n && is(n, ss)){\r
786                         r[++ri] = ci;\r
787                     }\r
788                 }\r
789                 return r;\r
790             },\r
791 \r
792             "prev" : function(c, ss){\r
793                 var is = Ext.DomQuery.is;\r
794                 var r = [], ri = -1;\r
795                 for(var i = 0, ci; ci = c[i]; i++){\r
796                     var n = prev(ci);\r
797                     if(n && is(n, ss)){\r
798                         r[++ri] = ci;\r
799                     }\r
800                 }\r
801                 return r;\r
802             }\r
803         }\r
804     };\r
805 }();\r
806 \r
807 /**\r
808  * Selects an array of DOM nodes by CSS/XPath selector. Shorthand of {@link Ext.DomQuery#select}\r
809  * @param {String} path The selector/xpath query\r
810  * @param {Node} root (optional) The start of the query (defaults to document).\r
811  * @return {Array}\r
812  * @member Ext\r
813  * @method query\r
814  */\r
815 Ext.query = Ext.DomQuery.select;\r