####

####

####

####

    /*
     * This is code is also distributed under MIT license for use
     * with jQuery and prototype JavaScript libraries.
     */
    /**
     * @class Ext.DomQuery
    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).

    DomQuery supports most of the CSS3 selectors spec, along with some custom selectors and basic XPath.

    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.

    Element Selectors:

         * any element
         E an element with the tag E
         E F All descendent elements of E that have the tag F
         E > F or E/F all direct children elements of E that have the tag F
         E + F all elements with the tag F that are immediately preceded by an element with the tag E
         E ~ F all elements with the tag F that are preceded by a sibling element with the tag E

    Attribute Selectors:
    The use of @ and quotes are optional. For example, div[@foo='bar'] is also a valid attribute selector.

         E[foo] has an attribute "foo"
         E[foo=bar] has an attribute "foo" that equals "bar"
         E[foo^=bar] has an attribute "foo" that starts with "bar"
         E[foo$=bar] has an attribute "foo" that ends with "bar"
         E[foo*=bar] has an attribute "foo" that contains the substring "bar"
         E[foo%=2] has an attribute "foo" that is evenly divisible by 2
         E[foo!=bar] has an attribute "foo" that does not equal "bar"

    Pseudo Classes:

         E:first-child E is the first child of its parent
         E:last-child E is the last child of its parent
         E:nth-child(n) E is the nth child of its parent (1 based as per the spec)
         E:nth-child(odd) E is an odd child of its parent
         E:nth-child(even) E is an even child of its parent
         E:only-child E is the only child of its parent
         E:checked E is an element that is has a checked attribute that is true (e.g. a radio or checkbox)
         E:first the first E in the resultset
         E:last the last E in the resultset
         E:nth(n) the nth E in the resultset (1 based)
         E:odd shortcut for :nth-child(odd)
         E:even shortcut for :nth-child(even)
         E:contains(foo) E's innerHTML contains the substring "foo"
         E:nodeValue(foo) E contains a textNode with a nodeValue that equals "foo"
         E:not(S) an E element that does not match simple selector S
         E:has(S) an E element that has a descendent that matches simple selector S
         E:next(S) an E element whose next sibling matches simple selector S
         E:prev(S) an E element whose previous sibling matches simple selector S

    CSS Value Selectors:

         E{display=none} css value "display" that equals "none"
         E{display^=none} css value "display" that starts with "none"
         E{display$=none} css value "display" that ends with "none"
         E{display*=none} css value "display" that contains the substring "none"
         E{display%=2} css value "display" that is evenly divisible by 2
         E{display!=none} css value "display" that does not equal "none"

     * @singleton
     */
    Ext.DomQuery = function(){
        var cache = {},
        	simpleCache = {},
        	valueCache = {},
        	nonSpace = /\S/,
        	trimRe = /^\s+|\s+$/g,
        	tplRe = /\{(\d+)\}/g,
        	modeRe = /^(\s?[\/>+~]\s?|\s|$)/,
        	tagTokenRe = /^(#)?([\w-\*]+)/,
        	nthRe = /(\d*)n\+?(\d*)/,
        	nthRe2 = /\D/,
        	// This is for IE MSXML which does not support expandos.
    	    // IE runs the same speed using setAttribute, however FF slows way down
    	    // and Safari completely fails so they need to continue to use expandos.
    	    isIE = window.ActiveXObject ? true : false,
    	    key = 30803;

        // this eval is stop the compressor from
    	// renaming the variable to something shorter
    	eval("var batch = 30803;");

        function child(p, index){
            var i = 0,
            	n = p.firstChild;
            while(n){
                if(n.nodeType == 1){
                   if(++i == index){
                       return n;
                   }
                }
                n = n.nextSibling;
            }
            return null;
        };

        function next(n){
            while((n = n.nextSibling) && n.nodeType != 1);
            return n;
        };

        function prev(n){
            while((n = n.previousSibling) && n.nodeType != 1);
            return n;
        };

        function children(d){
            var n = d.firstChild, ni = -1,
            	nx;
     	    while(n){
     	        nx = n.nextSibling;
     	        if(n.nodeType == 3 && !nonSpace.test(n.nodeValue)){
     	            d.removeChild(n);
     	        }else{
     	            n.nodeIndex = ++ni;
     	        }
     	        n = nx;
     	    }
     	    return this;
     	};

        function byClassName(c, a, v){
            if(!v){
                return c;
            }
            var r = [], ri = -1, cn;
            for(var i = 0, ci; ci = c[i]; i++){
                if((' '+ci.className+' ').indexOf(v) != -1){
                    r[++ri] = ci;
                }
            }
            return r;
        };

        function attrValue(n, attr){
            if(!n.tagName && typeof n.length != "undefined"){
                n = n[0];
            }
            if(!n){
                return null;
            }
            if(attr == "for"){
                return n.htmlFor;
            }
            if(attr == "class" || attr == "className"){
                return n.className;
            }
            return n.getAttribute(attr) || n[attr];

        };

        function getNodes(ns, mode, tagName){
            var result = [], ri = -1, cs;
            if(!ns){
                return result;
            }
            tagName = tagName || "*";
            if(typeof ns.getElementsByTagName != "undefined"){
                ns = [ns];
            }
            if(!mode){
                for(var i = 0, ni; ni = ns[i]; i++){
                    cs = ni.getElementsByTagName(tagName);
                    for(var j = 0, ci; ci = cs[j]; j++){
                        result[++ri] = ci;
                    }
                }
            }else if(mode == "/" || mode == ">"){
                var utag = tagName.toUpperCase();
                for(var i = 0, ni, cn; ni = ns[i]; i++){
                    cn = ni.children || ni.childNodes;
                    for(var j = 0, cj; cj = cn[j]; j++){
                        if(cj.nodeName == utag || cj.nodeName == tagName  || tagName == '*'){
                            result[++ri] = cj;
                        }
                    }
                }
            }else if(mode == "+"){
                var utag = tagName.toUpperCase();
                for(var i = 0, n; n = ns[i]; i++){
                    while((n = n.nextSibling) && n.nodeType != 1);
                    if(n && (n.nodeName == utag || n.nodeName == tagName || tagName == '*')){
                        result[++ri] = n;
                    }
                }
            }else if(mode == "~"){
                for(var i = 0, n; n = ns[i]; i++){
                    while((n = n.nextSibling) && (n.nodeType != 1 || (tagName == '*' || n.tagName.toLowerCase()!=tagName)));
                    if(n){
                        result[++ri] = n;
                    }
                }
            }
            return result;
        };

        function concat(a, b){
            if(b.slice){
                return a.concat(b);
            }
            for(var i = 0, l = b.length; i < l; i++){
                a[a.length] = b[i];
            }
            return a;
        }

        function byTag(cs, tagName){
            if(cs.tagName || cs == document){
                cs = [cs];
            }
            if(!tagName){
                return cs;
            }
            var r = [], ri = -1;
            tagName = tagName.toLowerCase();
            for(var i = 0, ci; ci = cs[i]; i++){
                if(ci.nodeType == 1 && ci.tagName.toLowerCase()==tagName){
                    r[++ri] = ci;
                }
            }
            return r;
        };

        function byId(cs, attr, id){
            if(cs.tagName || cs == document){
                cs = [cs];
            }
            if(!id){
                return cs;
            }
            var r = [], ri = -1;
            for(var i = 0,ci; ci = cs[i]; i++){
                if(ci && ci.id == id){
                    r[++ri] = ci;
                    return r;
                }
            }
            return r;
        };

        function byAttribute(cs, attr, value, op, custom){
            var r = [],
            	ri = -1,
            	st = custom=="{",
            	f = Ext.DomQuery.operators[op];
            for(var i = 0, ci; ci = cs[i]; i++){
                var a;
                if(st){
                    a = Ext.DomQuery.getStyle(ci, attr);
                }
                else if(attr == "class" || attr == "className"){
                    a = ci.className;
                }else if(attr == "for"){
                    a = ci.htmlFor;
                }else if(attr == "href"){
                    a = ci.getAttribute("href", 2);
                }else{
                    a = ci.getAttribute(attr);
                }
                if((f && f(a, value)) || (!f && a)){
                    r[++ri] = ci;
                }
            }
            return r;
        };

        function byPseudo(cs, name, value){
            return Ext.DomQuery.pseudos[name](cs, value);
        };

        function nodupIEXml(cs){
            var d = ++key,
            	r;
            cs[0].setAttribute("_nodup", d);
            r = [cs[0]];
            for(var i = 1, len = cs.length; i < len; i++){
                var c = cs[i];
                if(!c.getAttribute("_nodup") != d){
                    c.setAttribute("_nodup", d);
                    r[r.length] = c;
                }
            }
            for(var i = 0, len = cs.length; i < len; i++){
                cs[i].removeAttribute("_nodup");
            }
            return r;
        }

        function nodup(cs){
            if(!cs){
                return [];
            }
            var len = cs.length, c, i, r = cs, cj, ri = -1;
            if(!len || typeof cs.nodeType != "undefined" || len == 1){
                return cs;
            }
            if(isIE && typeof cs[0].selectSingleNode != "undefined"){
                return nodupIEXml(cs);
            }
            var d = ++key;
            cs[0]._nodup = d;
            for(i = 1; c = cs[i]; i++){
                if(c._nodup != d){
                    c._nodup = d;
                }else{
                    r = [];
                    for(var j = 0; j < i; j++){
                        r[++ri] = cs[j];
                    }
                    for(j = i+1; cj = cs[j]; j++){
                        if(cj._nodup != d){
                            cj._nodup = d;
                            r[++ri] = cj;
                        }
                    }
                    return r;
                }
            }
            return r;
        }

        function quickDiffIEXml(c1, c2){
            var d = ++key,
            	r = [];
            for(var i = 0, len = c1.length; i < len; i++){
                c1[i].setAttribute("_qdiff", d);
            }
            for(var i = 0, len = c2.length; i < len; i++){
                if(c2[i].getAttribute("_qdiff") != d){
                    r[r.length] = c2[i];
                }
            }
            for(var i = 0, len = c1.length; i < len; i++){
               c1[i].removeAttribute("_qdiff");
            }
            return r;
        }

        function quickDiff(c1, c2){
            var len1 = c1.length,
            	d = ++key,
            	r = [];
            if(!len1){
                return c2;
            }
            if(isIE && c1[0].selectSingleNode){
                return quickDiffIEXml(c1, c2);
            }
            for(var i = 0; i < len1; i++){
                c1[i]._qdiff = d;
            }
            for(var i = 0, len = c2.length; i < len; i++){
                if(c2[i]._qdiff != d){
                    r[r.length] = c2[i];
                }
            }
            return r;
        }

        function quickId(ns, mode, root, id){
            if(ns == root){
               var d = root.ownerDocument || root;
               return d.getElementById(id);
            }
            ns = getNodes(ns, mode, "*");
            return byId(ns, null, id);
        }

        return {
            getStyle : function(el, name){
                return Ext.fly(el).getStyle(name);
            },
            /**
             * Compiles a selector/xpath query into a reusable function. The returned function
             * takes one parameter "root" (optional), which is the context node from where the query should start.
             * @param {String} selector The selector/xpath query
             * @param {String} type (optional) Either "select" (the default) or "simple" for a simple selector match
             * @return {Function}
             */
            compile : function(path, type){
                type = type || "select";

                var fn = ["var f = function(root){\n var mode; ++batch; var n = root || document;\n"],
                	q = path, mode, lq,
                	tk = Ext.DomQuery.matchers,
                	tklen = tk.length,
                	mm,
                	// accept leading mode switch
                	lmode = q.match(modeRe);

                if(lmode && lmode[1]){
                    fn[fn.length] = 'mode="'+lmode[1].replace(trimRe, "")+'";';
                    q = q.replace(lmode[1], "");
                }
                // strip leading slashes
                while(path.substr(0, 1)=="/"){
                    path = path.substr(1);
                }

                while(q && lq != q){
                    lq = q;
                    var tm = q.match(tagTokenRe);
                    if(type == "select"){
                        if(tm){
                            if(tm[1] == "#"){
                                fn[fn.length] = 'n = quickId(n, mode, root, "'+tm[2]+'");';
                            }else{
                                fn[fn.length] = 'n = getNodes(n, mode, "'+tm[2]+'");';
                            }
                            q = q.replace(tm[0], "");
                        }else if(q.substr(0, 1) != '@'){
                            fn[fn.length] = 'n = getNodes(n, mode, "*");';
                        }
                    }else{
                        if(tm){
                            if(tm[1] == "#"){
                                fn[fn.length] = 'n = byId(n, null, "'+tm[2]+'");';
                            }else{
                                fn[fn.length] = 'n = byTag(n, "'+tm[2]+'");';
                            }
                            q = q.replace(tm[0], "");
                        }
                    }
                    while(!(mm = q.match(modeRe))){
                        var matched = false;
                        for(var j = 0; j < tklen; j++){
                            var t = tk[j];
                            var m = q.match(t.re);
                            if(m){
                                fn[fn.length] = t.select.replace(tplRe, function(x, i){
                                                        return m[i];
                                                    });
                                q = q.replace(m[0], "");
                                matched = true;
                                break;
                            }
                        }
                        // prevent infinite loop on bad selector
                        if(!matched){
                            throw 'Error parsing selector, parsing failed at "' + q + '"';
                        }
                    }
                    if(mm[1]){
                        fn[fn.length] = 'mode="'+mm[1].replace(trimRe, "")+'";';
                        q = q.replace(mm[1], "");
                    }
                }
                fn[fn.length] = "return nodup(n);\n}";
                eval(fn.join(""));
                return f;
            },

            /**
             * Selects a group of elements.
             * @param {String} selector The selector/xpath query (can be a comma separated list of selectors)
             * @param {Node} root (optional) The start of the query (defaults to document).
             * @return {Array} An Array of DOM elements which match the selector. If there are
             * no matches, and empty Array is returned.
             */
            select : function(path, root, type){
                if(!root || root == document){
                    root = document;
                }
                if(typeof root == "string"){
                    root = document.getElementById(root);
                }
                var paths = path.split(","),
                	results = [];
                for(var i = 0, len = paths.length; i < len; i++){
                    var p = paths[i].replace(trimRe, "");
                    if(!cache[p]){
                        cache[p] = Ext.DomQuery.compile(p);
                        if(!cache[p]){
                            throw p + " is not a valid selector";
                        }
                    }
                    var result = cache[p](root);
                    if(result && result != document){
                        results = results.concat(result);
                    }
                }
                if(paths.length > 1){
                    return nodup(results);
                }
                return results;
            },

            /**
             * Selects a single element.
             * @param {String} selector The selector/xpath query
             * @param {Node} root (optional) The start of the query (defaults to document).
             * @return {Element} The DOM element which matched the selector.
             */
            selectNode : function(path, root){
                return Ext.DomQuery.select(path, root)[0];
            },

            /**
             * Selects the value of a node, optionally replacing null with the defaultValue.
             * @param {String} selector The selector/xpath query
             * @param {Node} root (optional) The start of the query (defaults to document).
             * @param {String} defaultValue
             * @return {String}
             */
            selectValue : function(path, root, defaultValue){
                path = path.replace(trimRe, "");
                if(!valueCache[path]){
                    valueCache[path] = Ext.DomQuery.compile(path, "select");
                }
                var n = valueCache[path](root),
                	v;
                n = n[0] ? n[0] : n;
                v = (n && n.firstChild ? n.firstChild.nodeValue : null);
                return ((v === null||v === undefined||v==='') ? defaultValue : v);
            },

            /**
             * Selects the value of a node, parsing integers and floats. Returns the defaultValue, or 0 if none is specified.
             * @param {String} selector The selector/xpath query
             * @param {Node} root (optional) The start of the query (defaults to document).
             * @param {Number} defaultValue
             * @return {Number}
             */
            selectNumber : function(path, root, defaultValue){
                var v = Ext.DomQuery.selectValue(path, root, defaultValue || 0);
                return parseFloat(v);
            },

            /**
             * Returns true if the passed element(s) match the passed simple selector (e.g. div.some-class or span:first-child)
             * @param {String/HTMLElement/Array} el An element id, element or array of elements
             * @param {String} selector The simple selector to test
             * @return {Boolean}
             */
            is : function(el, ss){
                if(typeof el == "string"){
                    el = document.getElementById(el);
                }
                var isArray = Ext.isArray(el),
                	result = Ext.DomQuery.filter(isArray ? el : [el], ss);
                return isArray ? (result.length == el.length) : (result.length > 0);
            },

            /**
             * Filters an array of elements to only include matches of a simple selector (e.g. div.some-class or span:first-child)
             * @param {Array} el An array of elements to filter
             * @param {String} selector The simple selector to test
             * @param {Boolean} nonMatches If true, it returns the elements that DON'T match
             * the selector instead of the ones that match
             * @return {Array} An Array of DOM elements which match the selector. If there are
             * no matches, and empty Array is returned.
             */
            filter : function(els, ss, nonMatches){
                ss = ss.replace(trimRe, "");
                if(!simpleCache[ss]){
                    simpleCache[ss] = Ext.DomQuery.compile(ss, "simple");
                }
                var result = simpleCache[ss](els);
                return nonMatches ? quickDiff(result, els) : result;
            },

            /**
             * Collection of matching regular expressions and code snippets.
             */
            matchers : [{
                    re: /^\.([\w-]+)/,
                    select: 'n = byClassName(n, null, " {1} ");'
                }, {
                    re: /^\:([\w-]+)(?:\(((?:[^\s>\/]*|.*?))\))?/,
                    select: 'n = byPseudo(n, "{1}", "{2}");'
                },{
                    re: /^(?:([\[\{])(?:@)?([\w-]+)\s?(?:(=|.=)\s?['"]?(.*?)["']?)?[\]\}])/,
                    select: 'n = byAttribute(n, "{2}", "{4}", "{3}", "{1}");'
                }, {
                    re: /^#([\w-]+)/,
                    select: 'n = byId(n, null, "{1}");'
                },{
                    re: /^@([\w-]+)/,
                    select: 'return {firstChild:{nodeValue:attrValue(n, "{1}")}};'
                }
            ],

            /**
             * Collection of operator comparison functions. The default operators are =, !=, ^=, $=, *=, %=, |= and ~=.
             * New operators can be added as long as the match the format c= where c is any character other than space, > <.
             */
            operators : {
                "=" : function(a, v){
                    return a == v;
                },
                "!=" : function(a, v){
                    return a != v;
                },
                "^=" : function(a, v){
                    return a && a.substr(0, v.length) == v;
                },
                "$=" : function(a, v){
                    return a && a.substr(a.length-v.length) == v;
                },
                "*=" : function(a, v){
                    return a && a.indexOf(v) !== -1;
                },
                "%=" : function(a, v){
                    return (a % v) == 0;
                },
                "|=" : function(a, v){
                    return a && (a == v || a.substr(0, v.length+1) == v+'-');
                },
                "~=" : function(a, v){
                    return a && (' '+a+' ').indexOf(' '+v+' ') != -1;
                }
            },

            /**
             * Collection of "pseudo class" processors. Each processor is passed the current nodeset (array)
             * and the argument (if any) supplied in the selector.
             */
            pseudos : {
                "first-child" : function(c){
                    var r = [], ri = -1, n;
                    for(var i = 0, ci; ci = n = c[i]; i++){
                        while((n = n.previousSibling) && n.nodeType != 1);
                        if(!n){
                            r[++ri] = ci;
                        }
                    }
                    return r;
                },

                "last-child" : function(c){
                    var r = [], ri = -1, n;
                    for(var i = 0, ci; ci = n = c[i]; i++){
                        while((n = n.nextSibling) && n.nodeType != 1);
                        if(!n){
                            r[++ri] = ci;
                        }
                    }
                    return r;
                },

                "nth-child" : function(c, a) {
                    var r = [], ri = -1,
                    	m = nthRe.exec(a == "even" && "2n" || a == "odd" && "2n+1" || !nthRe2.test(a) && "n+" + a || a),
                    	f = (m[1] || 1) - 0, l = m[2] - 0;
                    for(var i = 0, n; n = c[i]; i++){
                        var pn = n.parentNode;
                        if (batch != pn._batch) {
                            var j = 0;
                            for(var cn = pn.firstChild; cn; cn = cn.nextSibling){
                                if(cn.nodeType == 1){
                                   cn.nodeIndex = ++j;
                                }
                            }
                            pn._batch = batch;
                        }
                        if (f == 1) {
                            if (l == 0 || n.nodeIndex == l){
                                r[++ri] = n;
                            }
                        } else if ((n.nodeIndex + l) % f == 0){
                            r[++ri] = n;
                        }
                    }

                    return r;
                },

                "only-child" : function(c){
                    var r = [], ri = -1;;
                    for(var i = 0, ci; ci = c[i]; i++){
                        if(!prev(ci) && !next(ci)){
                            r[++ri] = ci;
                        }
                    }
                    return r;
                },

                "empty" : function(c){
                    var r = [], ri = -1;
                    for(var i = 0, ci; ci = c[i]; i++){
                        var cns = ci.childNodes, j = 0, cn, empty = true;
                        while(cn = cns[j]){
                            ++j;
                            if(cn.nodeType == 1 || cn.nodeType == 3){
                                empty = false;
                                break;
                            }
                        }
                        if(empty){
                            r[++ri] = ci;
                        }
                    }
                    return r;
                },

                "contains" : function(c, v){
                    var r = [], ri = -1;
                    for(var i = 0, ci; ci = c[i]; i++){
                        if((ci.textContent||ci.innerText||'').indexOf(v) != -1){
                            r[++ri] = ci;
                        }
                    }
                    return r;
                },

                "nodeValue" : function(c, v){
                    var r = [], ri = -1;
                    for(var i = 0, ci; ci = c[i]; i++){
                        if(ci.firstChild && ci.firstChild.nodeValue == v){
                            r[++ri] = ci;
                        }
                    }
                    return r;
                },

                "checked" : function(c){
                    var r = [], ri = -1;
                    for(var i = 0, ci; ci = c[i]; i++){
                        if(ci.checked == true){
                            r[++ri] = ci;
                        }
                    }
                    return r;
                },

                "not" : function(c, ss){
                    return Ext.DomQuery.filter(c, ss, true);
                },

                "any" : function(c, selectors){
                    var ss = selectors.split('|'),
                    	r = [], ri = -1, s;
                    for(var i = 0, ci; ci = c[i]; i++){
                        for(var j = 0; s = ss[j]; j++){
                            if(Ext.DomQuery.is(ci, s)){
                                r[++ri] = ci;
                                break;
                            }
                        }
                    }
                    return r;
                },

                "odd" : function(c){
                    return this["nth-child"](c, "odd");
                },

                "even" : function(c){
                    return this["nth-child"](c, "even");
                },

                "nth" : function(c, a){
                    return c[a-1] || [];
                },

                "first" : function(c){
                    return c[0] || [];
                },

                "last" : function(c){
                    return c[c.length-1] || [];
                },

                "has" : function(c, ss){
                    var s = Ext.DomQuery.select,
                    	r = [], ri = -1;
                    for(var i = 0, ci; ci = c[i]; i++){
                        if(s(ss, ci).length > 0){
                            r[++ri] = ci;
                        }
                    }
                    return r;
                },

                "next" : function(c, ss){
                    var is = Ext.DomQuery.is,
                    	r = [], ri = -1;
                    for(var i = 0, ci; ci = c[i]; i++){
                        var n = next(ci);
                        if(n && is(n, ss)){
                            r[++ri] = ci;
                        }
                    }
                    return r;
                },

                "prev" : function(c, ss){
                    var is = Ext.DomQuery.is,
                    	r = [], ri = -1;
                    for(var i = 0, ci; ci = c[i]; i++){
                        var n = prev(ci);
                        if(n && is(n, ss)){
                            r[++ri] = ci;
                        }
                    }
                    return r;
                }
            }
        };
    }();

    /**
     * Selects an array of DOM nodes by CSS/XPath selector. Shorthand of {@link Ext.DomQuery#select}
     * @param {String} path The selector/xpath query
     * @param {Node} root (optional) The start of the query (defaults to document).
     * @return {Array}
     * @member Ext
     * @method query
     */
    Ext.query = Ext.DomQuery.select;