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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Java编程 > JavaScript > 查看源码
DomQuery.js
资源名称：ext-3.1.0.zip　[点击查看]
上传用户：dawnssy
上传日期：2022-08-06
资源大小：9345k
文件大小：31k
源码类别：

JavaScript

开发平台：

JavaScript

DomQuery.js：源码内容
  1. /*!  * Ext JS Library 3.1.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.     key = 30803;
  82.     
  83.     // this eval is stop the compressor from
  84. // renaming the variable to something shorter
  85. eval("var batch = 30803;");    
  87.     function child(p, index){
  88.         var i = 0,
  89.          n = p.firstChild;
  90.         while(n){
  91.             if(n.nodeType == 1){
  92.                if(++i == index){
  93.                    return n;
  94.                }
  95.             }
  96.             n = n.nextSibling;
  97.         }
  98.         return null;
  99.     };
  101.     function next(n){
  102.         while((n = n.nextSibling) && n.nodeType != 1);
  103.         return n;
  104.     };
  106.     function prev(n){
  107.         while((n = n.previousSibling) && n.nodeType != 1);
  108.         return n;
  109.     };
  111.     function children(d){
  112.         var n = d.firstChild, ni = -1,
  113.          nx;
  114.       while(n){
  115.           nx = n.nextSibling;
  116.           if(n.nodeType == 3 && !nonSpace.test(n.nodeValue)){
  117.               d.removeChild(n);
  118.           }else{
  119.               n.nodeIndex = ++ni;
  120.           }
  121.           n = nx;
  122.       }
  123.       return this;
  124.   };
  126.     function byClassName(c, a, v){
  127.         if(!v){
  128.             return c;
  129.         }
  130.         var r = [], ri = -1, cn;
  131.         for(var i = 0, ci; ci = c[i]; i++){
  132.             if((' '+ci.className+' ').indexOf(v) != -1){
  133.                 r[++ri] = ci;
  134.             }
  135.         }
  136.         return r;
  137.     };
  139.     function attrValue(n, attr){
  140.         if(!n.tagName && typeof n.length != "undefined"){
  141.             n = n[0];
  142.         }
  143.         if(!n){
  144.             return null;
  145.         }
  146.         if(attr == "for"){
  147.             return n.htmlFor;
  148.         }
  149.         if(attr == "class" || attr == "className"){
  150.             return n.className;
  151.         }
  152.         return n.getAttribute(attr) || n[attr];
  154.     };
  156.     function getNodes(ns, mode, tagName){
  157.         var result = [], ri = -1, cs;
  158.         if(!ns){
  159.             return result;
  160.         }
  161.         tagName = tagName || "*";
  162.         if(typeof ns.getElementsByTagName != "undefined"){
  163.             ns = [ns];
  164.         }
  165.         if(!mode){
  166.             for(var i = 0, ni; ni = ns[i]; i++){
  167.                 cs = ni.getElementsByTagName(tagName);
  168.                 for(var j = 0, ci; ci = cs[j]; j++){
  169.                     result[++ri] = ci;
  170.                 }
  171.             }
  172.         }else if(mode == "/" || mode == ">"){
  173.             var utag = tagName.toUpperCase();
  174.             for(var i = 0, ni, cn; ni = ns[i]; i++){
  175.                 cn = ni.childNodes;
  176.                 for(var j = 0, cj; cj = cn[j]; j++){
  177.                     if(cj.nodeName == utag || cj.nodeName == tagName  || tagName == '*'){
  178.                         result[++ri] = cj;
  179.                     }
  180.                 }
  181.             }
  182.         }else if(mode == "+"){
  183.             var utag = tagName.toUpperCase();
  184.             for(var i = 0, n; n = ns[i]; i++){
  185.                 while((n = n.nextSibling) && n.nodeType != 1);
  186.                 if(n && (n.nodeName == utag || n.nodeName == tagName || tagName == '*')){
  187.                     result[++ri] = n;
  188.                 }
  189.             }
  190.         }else if(mode == "~"){
  191.             var utag = tagName.toUpperCase();
  192.             for(var i = 0, n; n = ns[i]; i++){
  193.                 while((n = n.nextSibling)){
  194.                     if (n.nodeName == utag || n.nodeName == tagName || tagName == '*'){
  195.                         result[++ri] = n;
  196.                     }
  197.                 }
  198.             }
  199.         }
  200.         return result;
  201.     };
  203.     function concat(a, b){
  204.         if(b.slice){
  205.             return a.concat(b);
  206.         }
  207.         for(var i = 0, l = b.length; i < l; i++){
  208.             a[a.length] = b[i];
  209.         }
  210.         return a;
  211.     }
  213.     function byTag(cs, tagName){
  214.         if(cs.tagName || cs == document){
  215.             cs = [cs];
  216.         }
  217.         if(!tagName){
  218.             return cs;
  219.         }
  220.         var r = [], ri = -1;
  221.         tagName = tagName.toLowerCase();
  222.         for(var i = 0, ci; ci = cs[i]; i++){
  223.             if(ci.nodeType == 1 && ci.tagName.toLowerCase()==tagName){
  224.                 r[++ri] = ci;
  225.             }
  226.         }
  227.         return r;
  228.     };
  230.     function byId(cs, attr, id){
  231.         if(cs.tagName || cs == document){
  232.             cs = [cs];
  233.         }
  234.         if(!id){
  235.             return cs;
  236.         }
  237.         var r = [], ri = -1;
  238.         for(var i = 0,ci; ci = cs[i]; i++){
  239.             if(ci && ci.id == id){
  240.                 r[++ri] = ci;
  241.                 return r;
  242.             }
  243.         }
  244.         return r;
  245.     };
  247.     function byAttribute(cs, attr, value, op, custom){
  248.         var r = [], 
  249.          ri = -1, 
  250.          st = custom=="{",
  251.          f = Ext.DomQuery.operators[op];
  252.         for(var i = 0, ci; ci = cs[i]; i++){
  253.             if(ci.nodeType != 1){
  254.                 continue;
  255.             }
  256.             var a;
  257.             if(st){
  258.                 a = Ext.DomQuery.getStyle(ci, attr);
  259.             }
  260.             else if(attr == "class" || attr == "className"){
  261.                 a = ci.className;
  262.             }else if(attr == "for"){
  263.                 a = ci.htmlFor;
  264.             }else if(attr == "href"){
  265.                 a = ci.getAttribute("href", 2);
  266.             }else{
  267.                 a = ci.getAttribute(attr);
  268.             }
  269.             if((f && f(a, value)) || (!f && a)){
  270.                 r[++ri] = ci;
  271.             }
  272.         }
  273.         return r;
  274.     };
  276.     function byPseudo(cs, name, value){
  277.         return Ext.DomQuery.pseudos[name](cs, value);
  278.     };
  280.     function nodupIEXml(cs){
  281.         var d = ++key, 
  282.          r;
  283.         cs[0].setAttribute("_nodup", d);
  284.         r = [cs[0]];
  285.         for(var i = 1, len = cs.length; i < len; i++){
  286.             var c = cs[i];
  287.             if(!c.getAttribute("_nodup") != d){
  288.                 c.setAttribute("_nodup", d);
  289.                 r[r.length] = c;
  290.             }
  291.         }
  292.         for(var i = 0, len = cs.length; i < len; i++){
  293.             cs[i].removeAttribute("_nodup");
  294.         }
  295.         return r;
  296.     }
  298.     function nodup(cs){
  299.         if(!cs){
  300.             return [];
  301.         }
  302.         var len = cs.length, c, i, r = cs, cj, ri = -1;
  303.         if(!len || typeof cs.nodeType != "undefined" || len == 1){
  304.             return cs;
  305.         }
  306.         if(isIE && typeof cs[0].selectSingleNode != "undefined"){
  307.             return nodupIEXml(cs);
  308.         }
  309.         var d = ++key;
  310.         cs[0]._nodup = d;
  311.         for(i = 1; c = cs[i]; i++){
  312.             if(c._nodup != d){
  313.                 c._nodup = d;
  314.             }else{
  315.                 r = [];
  316.                 for(var j = 0; j < i; j++){
  317.                     r[++ri] = cs[j];
  318.                 }
  319.                 for(j = i+1; cj = cs[j]; j++){
  320.                     if(cj._nodup != d){
  321.                         cj._nodup = d;
  322.                         r[++ri] = cj;
  323.                     }
  324.                 }
  325.                 return r;
  326.             }
  327.         }
  328.         return r;
  329.     }
  331.     function quickDiffIEXml(c1, c2){
  332.         var d = ++key,
  333.          r = [];
  334.         for(var i = 0, len = c1.length; i < len; i++){
  335.             c1[i].setAttribute("_qdiff", d);
  336.         }        
  337.         for(var i = 0, len = c2.length; i < len; i++){
  338.             if(c2[i].getAttribute("_qdiff") != d){
  339.                 r[r.length] = c2[i];
  340.             }
  341.         }
  342.         for(var i = 0, len = c1.length; i < len; i++){
  343.            c1[i].removeAttribute("_qdiff");
  344.         }
  345.         return r;
  346.     }
  348.     function quickDiff(c1, c2){
  349.         var len1 = c1.length,
  350.          d = ++key,
  351.          r = [];
  352.         if(!len1){
  353.             return c2;
  354.         }
  355.         if(isIE && typeof c1[0].selectSingleNode != "undefined"){
  356.             return quickDiffIEXml(c1, c2);
  357.         }        
  358.         for(var i = 0; i < len1; i++){
  359.             c1[i]._qdiff = d;
  360.         }        
  361.         for(var i = 0, len = c2.length; i < len; i++){
  362.             if(c2[i]._qdiff != d){
  363.                 r[r.length] = c2[i];
  364.             }
  365.         }
  366.         return r;
  367.     }
  369.     function quickId(ns, mode, root, id){
  370.         if(ns == root){
  371.            var d = root.ownerDocument || root;
  372.            return d.getElementById(id);
  373.         }
  374.         ns = getNodes(ns, mode, "*");
  375.         return byId(ns, null, id);
  376.     }
  378.     return {
  379.         getStyle : function(el, name){
  380.             return Ext.fly(el).getStyle(name);
  381.         },
  382.         /**
  383.          * Compiles a selector/xpath query into a reusable function. The returned function
  384.          * takes one parameter "root" (optional), which is the context node from where the query should start.
  385.          * @param {String} selector The selector/xpath query
  386.          * @param {String} type (optional) Either "select" (the default) or "simple" for a simple selector match
  387.          * @return {Function}
  388.          */
  389.         compile : function(path, type){
  390.             type = type || "select";
  392.             var fn = ["var f = function(root){n var mode; ++batch; var n = root || document;n"],
  393.              q = path, mode, lq,
  394.              tk = Ext.DomQuery.matchers,
  395.              tklen = tk.length,
  396.              mm,
  397.              // accept leading mode switch
  398.              lmode = q.match(modeRe);
  399.             
  400.             if(lmode && lmode[1]){
  401.                 fn[fn.length] = 'mode="'+lmode[1].replace(trimRe, "")+'";';
  402.                 q = q.replace(lmode[1], "");
  403.             }
  404.             // strip leading slashes
  405.             while(path.substr(0, 1)=="/"){
  406.                 path = path.substr(1);
  407.             }
  409.             while(q && lq != q){
  410.                 lq = q;
  411.                 var tm = q.match(tagTokenRe);
  412.                 if(type == "select"){
  413.                     if(tm){
  414.                         if(tm[1] == "#"){
  415.                             fn[fn.length] = 'n = quickId(n, mode, root, "'+tm[2]+'");';
  416.                         }else{
  417.                             fn[fn.length] = 'n = getNodes(n, mode, "'+tm[2]+'");';
  418.                         }
  419.                         q = q.replace(tm[0], "");
  420.                     }else if(q.substr(0, 1) != '@'){
  421.                         fn[fn.length] = 'n = getNodes(n, mode, "*");';
  422.                     }
  423.                 }else{
  424.                     if(tm){
  425.                         if(tm[1] == "#"){
  426.                             fn[fn.length] = 'n = byId(n, null, "'+tm[2]+'");';
  427.                         }else{
  428.                             fn[fn.length] = 'n = byTag(n, "'+tm[2]+'");';
  429.                         }
  430.                         q = q.replace(tm[0], "");
  431.                     }
  432.                 }
  433.                 while(!(mm = q.match(modeRe))){
  434.                     var matched = false;
  435.                     for(var j = 0; j < tklen; j++){
  436.                         var t = tk[j];
  437.                         var m = q.match(t.re);
  438.                         if(m){
  439.                             fn[fn.length] = t.select.replace(tplRe, function(x, i){
  440.                                                     return m[i];
  441.                                                 });
  442.                             q = q.replace(m[0], "");
  443.                             matched = true;
  444.                             break;
  445.                         }
  446.                     }
  447.                     // prevent infinite loop on bad selector
  448.                     if(!matched){
  449.                         throw 'Error parsing selector, parsing failed at "' + q + '"';
  450.                     }
  451.                 }
  452.                 if(mm[1]){
  453.                     fn[fn.length] = 'mode="'+mm[1].replace(trimRe, "")+'";';
  454.                     q = q.replace(mm[1], "");
  455.                 }
  456.             }
  457.             fn[fn.length] = "return nodup(n);n}";
  458.             eval(fn.join(""));
  459.             return f;
  460.         },
  462.         /**
  463.          * Selects a group of elements.
  464.          * @param {String} selector The selector/xpath query (can be a comma separated list of selectors)
  465.          * @param {Node} root (optional) The start of the query (defaults to document).
  466.          * @return {Array} An Array of DOM elements which match the selector. If there are
  467.          * no matches, and empty Array is returned.
  468.          */
  469.         select : function(path, root, type){
  470.             if(!root || root == document){
  471.                 root = document;
  472.             }
  473.             if(typeof root == "string"){
  474.                 root = document.getElementById(root);
  475.             }
  476.             var paths = path.split(","),
  477.              results = [];
  478.             for(var i = 0, len = paths.length; i < len; i++){
  479.                 var p = paths[i].replace(trimRe, "");
  480.                 if(!cache[p]){
  481.                     cache[p] = Ext.DomQuery.compile(p);
  482.                     if(!cache[p]){
  483.                         throw p + " is not a valid selector";
  484.                     }
  485.                 }
  486.                 var result = cache[p](root);
  487.                 if(result && result != document){
  488.                     results = results.concat(result);
  489.                 }
  490.             }
  491.             if(paths.length > 1){
  492.                 return nodup(results);
  493.             }
  494.             return results;
  495.         },
  497.         /**
  498.          * Selects a single element.
  499.          * @param {String} selector The selector/xpath query
  500.          * @param {Node} root (optional) The start of the query (defaults to document).
  501.          * @return {Element} The DOM element which matched the selector.
  502.          */
  503.         selectNode : function(path, root){
  504.             return Ext.DomQuery.select(path, root)[0];
  505.         },
  507.         /**
  508.          * Selects the value of a node, optionally replacing null with the defaultValue.
  509.          * @param {String} selector The selector/xpath query
  510.          * @param {Node} root (optional) The start of the query (defaults to document).
  511.          * @param {String} defaultValue
  512.          * @return {String}
  513.          */
  514.         selectValue : function(path, root, defaultValue){
  515.             path = path.replace(trimRe, "");
  516.             if(!valueCache[path]){
  517.                 valueCache[path] = Ext.DomQuery.compile(path, "select");
  518.             }
  519.             var n = valueCache[path](root), v;
  520.             n = n[0] ? n[0] : n;
  521.             
  522.             if (typeof n.normalize == 'function') n.normalize();
  523.             
  524.             v = (n && n.firstChild ? n.firstChild.nodeValue : null);
  525.             return ((v === null||v === undefined||v==='') ? defaultValue : v);
  526.         },
  528.         /**
  529.          * Selects the value of a node, parsing integers and floats. Returns the defaultValue, or 0 if none is specified.
  530.          * @param {String} selector The selector/xpath query
  531.          * @param {Node} root (optional) The start of the query (defaults to document).
  532.          * @param {Number} defaultValue
  533.          * @return {Number}
  534.          */
  535.         selectNumber : function(path, root, defaultValue){
  536.             var v = Ext.DomQuery.selectValue(path, root, defaultValue || 0);
  537.             return parseFloat(v);
  538.         },
  540.         /**
  541.          * Returns true if the passed element(s) match the passed simple selector (e.g. div.some-class or span:first-child)
  542.          * @param {String/HTMLElement/Array} el An element id, element or array of elements
  543.          * @param {String} selector The simple selector to test
  544.          * @return {Boolean}
  545.          */
  546.         is : function(el, ss){
  547.             if(typeof el == "string"){
  548.                 el = document.getElementById(el);
  549.             }
  550.             var isArray = Ext.isArray(el),
  551.              result = Ext.DomQuery.filter(isArray ? el : [el], ss);
  552.             return isArray ? (result.length == el.length) : (result.length > 0);
  553.         },
  555.         /**
  556.          * Filters an array of elements to only include matches of a simple selector (e.g. div.some-class or span:first-child)
  557.          * @param {Array} el An array of elements to filter
  558.          * @param {String} selector The simple selector to test
  559.          * @param {Boolean} nonMatches If true, it returns the elements that DON'T match
  560.          * the selector instead of the ones that match
  561.          * @return {Array} An Array of DOM elements which match the selector. If there are
  562.          * no matches, and empty Array is returned.
  563.          */
  564.         filter : function(els, ss, nonMatches){
  565.             ss = ss.replace(trimRe, "");
  566.             if(!simpleCache[ss]){
  567.                 simpleCache[ss] = Ext.DomQuery.compile(ss, "simple");
  568.             }
  569.             var result = simpleCache[ss](els);
  570.             return nonMatches ? quickDiff(result, els) : result;
  571.         },
  573.         /**
  574.          * Collection of matching regular expressions and code snippets.
  575.          */
  576.         matchers : [{
  577.                 re: /^.([w-]+)/,
  578.                 select: 'n = byClassName(n, null, " {1} ");'
  579.             }, {
  580.                 re: /^:([w-]+)(?:(((?:[^s>/]*|.*?))))?/,
  581.                 select: 'n = byPseudo(n, "{1}", "{2}");'
  582.             },{
  583.                 re: /^(?:([[{])(?:@)?([w-]+)s?(?:(=|.=)s?['"]?(.*?)["']?)?[]}])/,
  584.                 select: 'n = byAttribute(n, "{2}", "{4}", "{3}", "{1}");'
  585.             }, {
  586.                 re: /^#([w-]+)/,
  587.                 select: 'n = byId(n, null, "{1}");'
  588.             },{
  589.                 re: /^@([w-]+)/,
  590.                 select: 'return {firstChild:{nodeValue:attrValue(n, "{1}")}};'
  591.             }
  592.         ],
  594.         /**
  595.          * Collection of operator comparison functions. The default operators are =, !=, ^=, $=, *=, %=, |= and ~=.
  596.          * 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;.
  597.          */
  598.         operators : {
  599.             "=" : function(a, v){
  600.                 return a == v;
  601.             },
  602.             "!=" : function(a, v){
  603.                 return a != v;
  604.             },
  605.             "^=" : function(a, v){
  606.                 return a && a.substr(0, v.length) == v;
  607.             },
  608.             "$=" : function(a, v){
  609.                 return a && a.substr(a.length-v.length) == v;
  610.             },
  611.             "*=" : function(a, v){
  612.                 return a && a.indexOf(v) !== -1;
  613.             },
  614.             "%=" : function(a, v){
  615.                 return (a % v) == 0;
  616.             },
  617.             "|=" : function(a, v){
  618.                 return a && (a == v || a.substr(0, v.length+1) == v+'-');
  619.             },
  620.             "~=" : function(a, v){
  621.                 return a && (' '+a+' ').indexOf(' '+v+' ') != -1;
  622.             }
  623.         },
  625.         /**
  626.          * <p>Object hash of "pseudo class" filter functions which are used when filtering selections. Each function is passed
  627.          * two parameters:</p><div class="mdetail-params"><ul>
  628.          * <li><b>c</b> : Array<div class="sub-desc">An Array of DOM elements to filter.</div></li>
  629.          * <li><b>v</b> : String<div class="sub-desc">The argument (if any) supplied in the selector.</div></li>
  630.          * </ul></div>
  631.          * <p>A filter function returns an Array of DOM elements which conform to the pseudo class.</p>
  632.          * <p>In addition to the provided pseudo classes listed above such as <code>first-child</code> and <code>nth-child</code>,
  633.          * developers may add additional, custom psuedo class filters to select elements according to application-specific requirements.</p>
  634.          * <p>For example, to filter <code>&lt;a></code> elements to only return links to <i>external</i> resources:</p>
  635.          * <code><pre>
  636. Ext.DomQuery.pseudos.external = function(c, v){
  637.     var r = [], ri = -1;
  638.     for(var i = 0, ci; ci = c[i]; i++){
  639. //      Include in result set only if it's a link to an external resource
  640.         if(ci.hostname != location.hostname){
  641.             r[++ri] = ci;
  642.         }
  643.     }
  644.     return r;
  645. };</pre></code>
  646.          * Then external links could be gathered with the following statement:<code><pre>
  647. var externalLinks = Ext.select("a:external");
  648. </code></pre>
  649.          */
  650.         pseudos : {
  651.             "first-child" : function(c){
  652.                 var r = [], ri = -1, n;
  653.                 for(var i = 0, ci; ci = n = c[i]; i++){
  654.                     while((n = n.previousSibling) && n.nodeType != 1);
  655.                     if(!n){
  656.                         r[++ri] = ci;
  657.                     }
  658.                 }
  659.                 return r;
  660.             },
  662.             "last-child" : function(c){
  663.                 var r = [], ri = -1, n;
  664.                 for(var i = 0, ci; ci = n = c[i]; i++){
  665.                     while((n = n.nextSibling) && n.nodeType != 1);
  666.                     if(!n){
  667.                         r[++ri] = ci;
  668.                     }
  669.                 }
  670.                 return r;
  671.             },
  673.             "nth-child" : function(c, a) {
  674.                 var r = [], ri = -1,
  675.                  m = nthRe.exec(a == "even" && "2n" || a == "odd" && "2n+1" || !nthRe2.test(a) && "n+" + a || a),
  676.                  f = (m[1] || 1) - 0, l = m[2] - 0;
  677.                 for(var i = 0, n; n = c[i]; i++){
  678.                     var pn = n.parentNode;
  679.                     if (batch != pn._batch) {
  680.                         var j = 0;
  681.                         for(var cn = pn.firstChild; cn; cn = cn.nextSibling){
  682.                             if(cn.nodeType == 1){
  683.                                cn.nodeIndex = ++j;
  684.                             }
  685.                         }
  686.                         pn._batch = batch;
  687.                     }
  688.                     if (f == 1) {
  689.                         if (l == 0 || n.nodeIndex == l){
  690.                             r[++ri] = n;
  691.                         }
  692.                     } else if ((n.nodeIndex + l) % f == 0){
  693.                         r[++ri] = n;
  694.                     }
  695.                 }
  697.                 return r;
  698.             },
  700.             "only-child" : function(c){
  701.                 var r = [], ri = -1;;
  702.                 for(var i = 0, ci; ci = c[i]; i++){
  703.                     if(!prev(ci) && !next(ci)){
  704.                         r[++ri] = ci;
  705.                     }
  706.                 }
  707.                 return r;
  708.             },
  710.             "empty" : function(c){
  711.                 var r = [], ri = -1;
  712.                 for(var i = 0, ci; ci = c[i]; i++){
  713.                     var cns = ci.childNodes, j = 0, cn, empty = true;
  714.                     while(cn = cns[j]){
  715.                         ++j;
  716.                         if(cn.nodeType == 1 || cn.nodeType == 3){
  717.                             empty = false;
  718.                             break;
  719.                         }
  720.                     }
  721.                     if(empty){
  722.                         r[++ri] = ci;
  723.                     }
  724.                 }
  725.                 return r;
  726.             },
  728.             "contains" : function(c, v){
  729.                 var r = [], ri = -1;
  730.                 for(var i = 0, ci; ci = c[i]; i++){
  731.                     if((ci.textContent||ci.innerText||'').indexOf(v) != -1){
  732.                         r[++ri] = ci;
  733.                     }
  734.                 }
  735.                 return r;
  736.             },
  738.             "nodeValue" : function(c, v){
  739.                 var r = [], ri = -1;
  740.                 for(var i = 0, ci; ci = c[i]; i++){
  741.                     if(ci.firstChild && ci.firstChild.nodeValue == v){
  742.                         r[++ri] = ci;
  743.                     }
  744.                 }
  745.                 return r;
  746.             },
  748.             "checked" : function(c){
  749.                 var r = [], ri = -1;
  750.                 for(var i = 0, ci; ci = c[i]; i++){
  751.                     if(ci.checked == true){
  752.                         r[++ri] = ci;
  753.                     }
  754.                 }
  755.                 return r;
  756.             },
  758.             "not" : function(c, ss){
  759.                 return Ext.DomQuery.filter(c, ss, true);
  760.             },
  762.             "any" : function(c, selectors){
  763.                 var ss = selectors.split('|'),
  764.                  r = [], ri = -1, s;
  765.                 for(var i = 0, ci; ci = c[i]; i++){
  766.                     for(var j = 0; s = ss[j]; j++){
  767.                         if(Ext.DomQuery.is(ci, s)){
  768.                             r[++ri] = ci;
  769.                             break;
  770.                         }
  771.                     }
  772.                 }
  773.                 return r;
  774.             },
  776.             "odd" : function(c){
  777.                 return this["nth-child"](c, "odd");
  778.             },
  780.             "even" : function(c){
  781.                 return this["nth-child"](c, "even");
  782.             },
  784.             "nth" : function(c, a){
  785.                 return c[a-1] || [];
  786.             },
  788.             "first" : function(c){
  789.                 return c[0] || [];
  790.             },
  792.             "last" : function(c){
  793.                 return c[c.length-1] || [];
  794.             },
  796.             "has" : function(c, ss){
  797.                 var s = Ext.DomQuery.select,
  798.                  r = [], ri = -1;
  799.                 for(var i = 0, ci; ci = c[i]; i++){
  800.                     if(s(ss, ci).length > 0){
  801.                         r[++ri] = ci;
  802.                     }
  803.                 }
  804.                 return r;
  805.             },
  807.             "next" : function(c, ss){
  808.                 var is = Ext.DomQuery.is,
  809.                  r = [], ri = -1;
  810.                 for(var i = 0, ci; ci = c[i]; i++){
  811.                     var n = next(ci);
  812.                     if(n && is(n, ss)){
  813.                         r[++ri] = ci;
  814.                     }
  815.                 }
  816.                 return r;
  817.             },
  819.             "prev" : function(c, ss){
  820.                 var is = Ext.DomQuery.is,
  821.                  r = [], ri = -1;
  822.                 for(var i = 0, ci; ci = c[i]; i++){
  823.                     var n = prev(ci);
  824.                     if(n && is(n, ss)){
  825.                         r[++ri] = ci;
  826.                     }
  827.                 }
  828.                 return r;
  829.             }
  830.         }
  831.     };
  832. }();
  834. /**
  835.  * Selects an array of DOM nodes by CSS/XPath selector. Shorthand of {@link Ext.DomQuery#select}
  836.  * @param {String} path The selector/xpath query
  837.  * @param {Node} root (optional) The start of the query (defaults to document).
  838.  * @return {Array}
  839.  * @member Ext
  840.  * @method query
  841.  */
  842. Ext.query = Ext.DomQuery.select;