开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 中间件编程 > 查看源码
DomQuery.js
资源名称：ext-3.0.0.zip　[点击查看]
上传用户：shuoshiled
上传日期：2018-01-28
资源大小：10124k
文件大小：29k
源码类别：

中间件编程

开发平台：

JavaScript

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