projects / roojs1 / blob
? search:


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