git.roojs.org Git - roojs1/blob - 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
 132
 133             </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">((</span><span class="jsdoc-string">' '</span><span class="jsdoc-syntax">+
 134                 ( (</span><span class="jsdoc-var">ci </span><span class="jsdoc-keyword">instanceof </span><span class="jsdoc-var">SVGElement</span><span class="jsdoc-syntax">) ? </span><span class="jsdoc-var">ci.className.baseVal </span><span class="jsdoc-syntax">: </span><span class="jsdoc-var">ci.className</span><span class="jsdoc-syntax">)
 135                  +</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){
 136                 </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">;
 137             }
 138         }
 139         </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 140     };
 141
 142     </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">){
 143         </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">){
 144             </span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">[0];
 145         }
 146         </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(!</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">){
 147             </span><span class="jsdoc-keyword">return null</span><span class="jsdoc-syntax">;
 148         }
 149         </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">){
 150             </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">n.htmlFor</span><span class="jsdoc-syntax">;
 151         }
 152         </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">){
 153             </span><span class="jsdoc-keyword">return </span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n </span><span class="jsdoc-keyword">instanceof </span><span class="jsdoc-var">SVGElement</span><span class="jsdoc-syntax">) ? </span><span class="jsdoc-var">n.className.baseVal </span><span class="jsdoc-syntax">: </span><span class="jsdoc-var">n.className</span><span class="jsdoc-syntax">;
 154         }
 155         </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">];
 156
 157     };
 158
 159     </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">){
 160         </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">;
 161         </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(!</span><span class="jsdoc-var">ns</span><span class="jsdoc-syntax">){
 162             </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">result</span><span class="jsdoc-syntax">;
 163         }
 164         </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">;
 165         </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">){
 166             </span><span class="jsdoc-var">ns </span><span class="jsdoc-syntax">= [</span><span class="jsdoc-var">ns</span><span class="jsdoc-syntax">];
 167         }
 168         </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(!</span><span class="jsdoc-var">mode</span><span class="jsdoc-syntax">){
 169             </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">++){
 170                 </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">);
 171                 </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">++){
 172                     </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">;
 173                 }
 174             }
 175         }</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">){
 176             </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">();
 177             </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">++){
 178                 </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">;
 179                 </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">++){
 180                     </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">){
 181                         </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">;
 182                     }
 183                 }
 184             }
 185         }</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">){
 186             </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">();
 187             </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">++){
 188                 </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);
 189                 </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">)){
 190                     </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">;
 191                 }
 192             }
 193         }</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">){
 194             </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">++){
 195                 </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">)));
 196                 </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">){
 197                     </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">;
 198                 }
 199             }
 200         }
 201         </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">result</span><span class="jsdoc-syntax">;
 202     };
 203
 204     </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">){
 205         </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b.slice</span><span class="jsdoc-syntax">){
 206             </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">);
 207         }
 208         </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">++){
 209             </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">];
 210         }
 211         </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">;
 212     }
 213
 214     </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">){
 215         </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">){
 216             </span><span class="jsdoc-var">cs </span><span class="jsdoc-syntax">= [</span><span class="jsdoc-var">cs</span><span class="jsdoc-syntax">];
 217         }
 218         </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(!</span><span class="jsdoc-var">tagName</span><span class="jsdoc-syntax">){
 219             </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">cs</span><span class="jsdoc-syntax">;
 220         }
 221         </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;
 222         </span><span class="jsdoc-var">tagName </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">tagName.toLowerCase</span><span class="jsdoc-syntax">();
 223         </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">++){
 224             </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">){
 225                 </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">;
 226             }
 227         }
 228         </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 229     };
 230
 231     </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">){
 232         </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">){
 233             </span><span class="jsdoc-var">cs </span><span class="jsdoc-syntax">= [</span><span class="jsdoc-var">cs</span><span class="jsdoc-syntax">];
 234         }
 235         </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(!</span><span class="jsdoc-var">id</span><span class="jsdoc-syntax">){
 236             </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">cs</span><span class="jsdoc-syntax">;
 237         }
 238         </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;
 239         </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">++){
 240             </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">){
 241                 </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">;
 242                 </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 243             }
 244         }
 245         </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 246     };
 247
 248     </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">){
 249         </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">;
 250         </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">];
 251         </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">++){
 252             </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">;
 253             </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">st</span><span class="jsdoc-syntax">){
 254                 </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">);
 255             }
 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;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">){
 257                 </span><span class="jsdoc-var">a </span><span class="jsdoc-syntax">= (</span><span class="jsdoc-var">ci </span><span class="jsdoc-keyword">instanceof </span><span class="jsdoc-var">SVGElement</span><span class="jsdoc-syntax">) ? </span><span class="jsdoc-var">ci.className.baseVal </span><span class="jsdoc-syntax">: </span><span class="jsdoc-var">ci.className</span><span class="jsdoc-syntax">;
 258             }</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">){
 259                 </span><span class="jsdoc-var">a </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">ci.htmlFor</span><span class="jsdoc-syntax">;
 260             }</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">){
 261                 </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);
 262             }</span><span class="jsdoc-keyword">else</span><span class="jsdoc-syntax">{
 263                 </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">);
 264             }
 265             </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">)){
 266                 </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">;
 267             }
 268         }
 269         </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 270     };
 271
 272     </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">){
 273         </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">);
 274     };
 275
 276     </span><span class="jsdoc-comment">// This is for IE MSXML which does not support expandos.
 277     // IE runs the same speed using setAttribute, however FF slows way down
 278     // and Safari completely fails so they need to continue to use expandos.
 279     </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">;
 280
 281     </span><span class="jsdoc-comment">// this eval is stop the compressor from
 282     // renaming the variable to something shorter
 283
 284     /** eval:var:batch */
 285     </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">batch </span><span class="jsdoc-syntax">= 30803;
 286
 287     </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">key </span><span class="jsdoc-syntax">= 30803;
 288
 289     </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">){
 290         </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">;
 291         </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">);
 292         </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]];
 293         </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">++){
 294             </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">];
 295             </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">){
 296                 </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">);
 297                 </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">;
 298             }
 299         }
 300         </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">++){
 301             </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">);
 302         }
 303         </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 304     }
 305
 306     </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">){
 307         </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(!</span><span class="jsdoc-var">cs</span><span class="jsdoc-syntax">){
 308             </span><span class="jsdoc-keyword">return </span><span class="jsdoc-syntax">[];
 309         }
 310         </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;
 311         </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){
 312             </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">cs</span><span class="jsdoc-syntax">;
 313         }
 314         </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">){
 315             </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">);
 316         }
 317         </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">;
 318         </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">;
 319         </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">++){
 320             </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">){
 321                 </span><span class="jsdoc-var">c._nodup </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">d</span><span class="jsdoc-syntax">;
 322             }</span><span class="jsdoc-keyword">else</span><span class="jsdoc-syntax">{
 323                 </span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">= [];
 324                 </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">++){
 325                     </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">];
 326                 }
 327                 </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">++){
 328                     </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">){
 329                         </span><span class="jsdoc-var">cj._nodup </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">d</span><span class="jsdoc-syntax">;
 330                         </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">;
 331                     }
 332                 }
 333                 </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 334             }
 335         }
 336         </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 337     }
 338
 339     </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">){
 340         </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">;
 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">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">++){
 342             </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">);
 343         }
 344         </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">= [];
 345         </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">++){
 346             </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">){
 347                 </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">];
 348             }
 349         }
 350         </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">++){
 351            </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">);
 352         }
 353         </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 354     }
 355
 356     </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">){
 357         </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">;
 358         </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(!</span><span class="jsdoc-var">len1</span><span class="jsdoc-syntax">){
 359             </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">c2</span><span class="jsdoc-syntax">;
 360         }
 361         </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">){
 362             </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">);
 363         }
 364         </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">;
 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">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">++){
 366             </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">;
 367         }
 368         </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">= [];
 369         </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">++){
 370             </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">){
 371                 </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">];
 372             }
 373         }
 374         </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 375     }
 376
 377     </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">){
 378         </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">){
 379            </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">;
 380            </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">);
 381         }
 382         </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">);
 383         </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">);
 384     }
 385
 386     </span><span class="jsdoc-keyword">return </span><span class="jsdoc-syntax">{
 387         </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">){
 388             </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">);
 389         },
 390         </span><span class="jsdoc-comment">/**
 391          * Compiles a selector/xpath query into a reusable function. The returned function
 392          * takes one parameter &quot;root&quot; (optional), which is the context node from where the query should start.
 393          * @param {String} selector The selector/xpath query
 394          * @param {String} type (optional) Either &quot;select&quot; (the default) or &quot;simple&quot; for a simple selector match
 395          * @return {Function}
 396          */
 397         </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">){
 398             </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">;
 399
 400             </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">];
 401             </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">;
 402             </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">;
 403             </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">;
 404             </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">mm</span><span class="jsdoc-syntax">;
 405
 406             </span><span class="jsdoc-comment">// accept leading mode switch
 407             </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">);
 408             </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]){
 409                 </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">;
 410                 </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">);
 411             }
 412             </span><span class="jsdoc-comment">// strip leading slashes
 413             </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">){
 414                 </span><span class="jsdoc-var">path </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">path.substr</span><span class="jsdoc-syntax">(1);
 415             }
 416
 417             </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">){
 418                 </span><span class="jsdoc-var">lq </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">q</span><span class="jsdoc-syntax">;
 419                 </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">);
 420                 </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">){
 421                     </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">tm</span><span class="jsdoc-syntax">){
 422                         </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">){
 423                             </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">;
 424                         }</span><span class="jsdoc-keyword">else</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;'</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">;
 426                         }
 427                         </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">);
 428                     }</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">){
 429                         </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">;
 430                     }
 431                 }</span><span class="jsdoc-keyword">else</span><span class="jsdoc-syntax">{
 432                     </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">tm</span><span class="jsdoc-syntax">){
 433                         </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">){
 434                             </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">;
 435                         }</span><span class="jsdoc-keyword">else</span><span class="jsdoc-syntax">{
 436                             </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">;
 437                         }
 438                         </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">);
 439                     }
 440                 }
 441                 </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">))){
 442                     </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">;
 443                     </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">++){
 444                         </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">];
 445                         </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">);
 446                         </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">m</span><span class="jsdoc-syntax">){
 447                             </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">){
 448                                                     </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">];
 449                                                 });
 450                             </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">);
 451                             </span><span class="jsdoc-var">matched </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">true</span><span class="jsdoc-syntax">;
 452                             </span><span class="jsdoc-keyword">break</span><span class="jsdoc-syntax">;
 453                         }
 454                     }
 455                     </span><span class="jsdoc-comment">// prevent infinite loop on bad selector
 456                     </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(!</span><span class="jsdoc-var">matched</span><span class="jsdoc-syntax">){
 457                         </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">;
 458                     }
 459                 }
 460                 </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">mm</span><span class="jsdoc-syntax">[1]){
 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">'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">;
 462                     </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">);
 463                 }
 464             }
 465             </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">;
 466
 467              </span><span class="jsdoc-comment">/**
 468               * list of variables that need from compression as they are used by eval.
 469              *  eval:var:batch
 470              *  eval:var:nodup
 471              *  eval:var:byTag
 472              *  eval:var:ById
 473              *  eval:var:getNodes
 474              *  eval:var:quickId
 475              *  eval:var:mode
 476              *  eval:var:root
 477              *  eval:var:n
 478              *  eval:var:byClassName
 479              *  eval:var:byPseudo
 480              *  eval:var:byAttribute
 481              *  eval:var:attrValue
 482              *
 483              **/
 484             </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">));
 485             </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">f</span><span class="jsdoc-syntax">;
 486         },
 487
 488         </span><span class="jsdoc-comment">/**
 489          * Selects a group of elements.
 490          * @param {String} selector The selector/xpath query (can be a comma separated list of selectors)
 491          * @param {Node} root (optional) The start of the query (defaults to document).
 492          * @return {Array}
 493          */
 494         </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">){
 495             </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">){
 496                 </span><span class="jsdoc-var">root </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">document</span><span class="jsdoc-syntax">;
 497             }
 498             </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">){
 499                 </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">);
 500             }
 501             </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">);
 502             </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">results </span><span class="jsdoc-syntax">= [];
 503             </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">++){
 504                 </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">);
 505                 </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">]){
 506                     </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">);
 507                     </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">]){
 508                         </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">;
 509                     }
 510                 }
 511                 </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">);
 512                 </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">){
 513                     </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">);
 514                 }
 515             }
 516             </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){
 517                 </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">);
 518             }
 519             </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">results</span><span class="jsdoc-syntax">;
 520         },
 521
 522         </span><span class="jsdoc-comment">/**
 523          * Selects a single element.
 524          * @param {String} selector The selector/xpath query
 525          * @param {Node} root (optional) The start of the query (defaults to document).
 526          * @return {Element}
 527          */
 528         </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">){
 529             </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];
 530         },
 531
 532         </span><span class="jsdoc-comment">/**
 533          * Selects the value of a node, optionally replacing null with the defaultValue.
 534          * @param {String} selector The selector/xpath query
 535          * @param {Node} root (optional) The start of the query (defaults to document).
 536          * @param {String} defaultValue
 537          */
 538         </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">){
 539             </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">);
 540             </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">]){
 541                 </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">);
 542             }
 543             </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">);
 544             </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">;
 545             </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">);
 546             </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">);
 547         },
 548
 549         </span><span class="jsdoc-comment">/**
 550          * Selects the value of a node, parsing integers and floats.
 551          * @param {String} selector The selector/xpath query
 552          * @param {Node} root (optional) The start of the query (defaults to document).
 553          * @param {Number} defaultValue
 554          * @return {Number}
 555          */
 556         </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">){
 557             </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);
 558             </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">);
 559         },
 560
 561         </span><span class="jsdoc-comment">/**
 562          * Returns true if the passed element(s) match the passed simple selector (e.g. div.some-class or span:first-child)
 563          * @param {String/HTMLElement/Array} el An element id, element or array of elements
 564          * @param {String} selector The simple selector to test
 565          * @return {Boolean}
 566          */
 567         </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">){
 568             </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">){
 569                 </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">);
 570             }
 571             </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">);
 572             </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">);
 573             </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);
 574         },
 575
 576         </span><span class="jsdoc-comment">/**
 577          * Filters an array of elements to only include matches of a simple selector (e.g. div.some-class or span:first-child)
 578          * @param {Array} el An array of elements to filter
 579          * @param {String} selector The simple selector to test
 580          * @param {Boolean} nonMatches If true, it returns the elements that DON'T match
 581          * the selector instead of the ones that match
 582          * @return {Array}
 583          */
 584         </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">){
 585             </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">);
 586             </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">]){
 587                 </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">);
 588             }
 589             </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">);
 590             </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">;
 591         },
 592
 593         </span><span class="jsdoc-comment">/**
 594          * Collection of matching regular expressions and code snippets.
 595          */
 596         </span><span class="jsdoc-var">matchers </span><span class="jsdoc-syntax">: [{
 597                 </span><span class="jsdoc-var">re</span><span class="jsdoc-syntax">: /^\.([\w-]+)/,
 598                 </span><span class="jsdoc-var">select</span><span class="jsdoc-syntax">: </span><span class="jsdoc-string">'n = byClassName(n, null, &quot; {1} &quot;);'
 599             </span><span class="jsdoc-syntax">}, {
 600                 </span><span class="jsdoc-var">re</span><span class="jsdoc-syntax">: /^\:([\w-]+)(?:\(((?:[^\s&gt;\/]*|.*?))\))?/,
 601                 </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;);'
 602             </span><span class="jsdoc-syntax">},{
 603                 </span><span class="jsdoc-var">re</span><span class="jsdoc-syntax">: /^(?:([\[\{])(?:@)?([\w-]+)\s?(?:(=|.=)\s?['&quot;]?(.*?)[&quot;']?)?[\]\}])/,
 604                 </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;);'
 605             </span><span class="jsdoc-syntax">}, {
 606                 </span><span class="jsdoc-var">re</span><span class="jsdoc-syntax">: /^#([\w-]+)/,
 607                 </span><span class="jsdoc-var">select</span><span class="jsdoc-syntax">: </span><span class="jsdoc-string">'n = byId(n, null, &quot;{1}&quot;);'
 608             </span><span class="jsdoc-syntax">},{
 609                 </span><span class="jsdoc-var">re</span><span class="jsdoc-syntax">: /^@([\w-]+)/,
 610                 </span><span class="jsdoc-var">select</span><span class="jsdoc-syntax">: </span><span class="jsdoc-string">'return {firstChild:{nodeValue:attrValue(n, &quot;{1}&quot;)}};'
 611             </span><span class="jsdoc-syntax">}
 612         ],
 613
 614         </span><span class="jsdoc-comment">/**
 615          * Collection of operator comparison functions. The default operators are =, !=, ^=, $=, *=, %=, |= and ~=.
 616          * 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;.
 617          */
 618         </span><span class="jsdoc-var">operators </span><span class="jsdoc-syntax">: {
 619             </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">){
 620                 </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">;
 621             },
 622             </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">){
 623                 </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">;
 624             },
 625             </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">){
 626                 </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">;
 627             },
 628             </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">){
 629                 </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">;
 630             },
 631             </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">){
 632                 </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;
 633             },
 634             </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">){
 635                 </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;
 636             },
 637             </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">){
 638                 </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">);
 639             },
 640             </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">){
 641                 </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;
 642             }
 643         },
 644
 645         </span><span class="jsdoc-comment">/**
 646          * Collection of &quot;pseudo class&quot; processors. Each processor is passed the current nodeset (array)
 647          * and the argument (if any) supplied in the selector.
 648          */
 649         </span><span class="jsdoc-var">pseudos </span><span class="jsdoc-syntax">: {
 650             </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">){
 651                 </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">;
 652                 </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">++){
 653                     </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);
 654                     </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(!</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">){
 655                         </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">;
 656                     }
 657                 }
 658                 </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 659             },
 660
 661             </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">){
 662                 </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">;
 663                 </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">++){
 664                     </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);
 665                     </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(!</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">){
 666                         </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">;
 667                     }
 668                 }
 669                 </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 670             },
 671
 672             </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">) {
 673                 </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;
 674                 </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">);
 675                 </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;
 676                 </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">++){
 677                     </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">;
 678                     </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">) {
 679                         </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">j </span><span class="jsdoc-syntax">= 0;
 680                         </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">){
 681                             </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">cn.nodeType </span><span class="jsdoc-syntax">== 1){
 682                                </span><span class="jsdoc-var">cn.nodeIndex </span><span class="jsdoc-syntax">= ++</span><span class="jsdoc-var">j</span><span class="jsdoc-syntax">;
 683                             }
 684                         }
 685                         </span><span class="jsdoc-var">pn._batch </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">batch</span><span class="jsdoc-syntax">;
 686                     }
 687                     </span><span class="jsdoc-keyword">if </span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">f </span><span class="jsdoc-syntax">== 1) {
 688                         </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">){
 689                             </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">;
 690                         }
 691                     } </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){
 692                         </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">;
 693                     }
 694                 }
 695
 696                 </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 697             },
 698
 699             </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">){
 700                 </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;;
 701                 </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">++){
 702                     </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">)){
 703                         </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">;
 704                     }
 705                 }
 706                 </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 707             },
 708
 709             </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">){
 710                 </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;
 711                 </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">++){
 712                     </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">;
 713                     </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">]){
 714                         ++</span><span class="jsdoc-var">j</span><span class="jsdoc-syntax">;
 715                         </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){
 716                             </span><span class="jsdoc-var">empty </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">false</span><span class="jsdoc-syntax">;
 717                             </span><span class="jsdoc-keyword">break</span><span class="jsdoc-syntax">;
 718                         }
 719                     }
 720                     </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">empty</span><span class="jsdoc-syntax">){
 721                         </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">;
 722                     }
 723                 }
 724                 </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 725             },
 726
 727             </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">){
 728                 </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;
 729                 </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">++){
 730                     </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){
 731                         </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">;
 732                     }
 733                 }
 734                 </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 735             },
 736
 737             </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">){
 738                 </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;
 739                 </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">++){
 740                     </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">){
 741                         </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">;
 742                     }
 743                 }
 744                 </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 745             },
 746
 747             </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">){
 748                 </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;
 749                 </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">++){
 750                     </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">){
 751                         </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">;
 752                     }
 753                 }
 754                 </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 755             },
 756
 757             </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">){
 758                 </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">);
 759             },
 760
 761             </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">){
 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;odd&quot;</span><span class="jsdoc-syntax">);
 763             },
 764
 765             </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">){
 766                 </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">);
 767             },
 768
 769             </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">){
 770                 </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] || [];
 771             },
 772
 773             </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">){
 774                 </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">c</span><span class="jsdoc-syntax">[0] || [];
 775             },
 776
 777             </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">){
 778                 </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] || [];
 779             },
 780
 781             </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">){
 782                 </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">;
 783                 </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;
 784                 </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">++){
 785                     </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){
 786                         </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">;
 787                     }
 788                 }
 789                 </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 790             },
 791
 792             </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">){
 793                 </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">;
 794                 </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;
 795                 </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">++){
 796                     </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">);
 797                     </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">)){
 798                         </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">;
 799                     }
 800                 }
 801                 </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 802             },
 803
 804             </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">){
 805                 </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">;
 806                 </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;
 807                 </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">++){
 808                     </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">);
 809                     </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">)){
 810                         </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">;
 811                     }
 812                 }
 813                 </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
 814             }
 815         }
 816     };
 817 }();
 818
 819 </span><span class="jsdoc-comment">/**
 820  * Selects an array of DOM nodes by CSS/XPath selector. Shorthand of {@link Roo.DomQuery#select}
 821  * @param {String} path The selector/xpath query
 822  * @param {Node} root (optional) The start of the query (defaults to document).
 823  * @return {Array}
 824  * @member Roo
 825  * @method query
 826  */
 827 </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">;
 828 </span></code></body></html>