closure 1.1.692

data/closure-library/third_party/closure/goog/dojo/dom/query.js

@@ -0,0 +1,1532 @@
+// Copyright 2005-2009, The Dojo Foundation
+// Modifications Copyright 2008 The Closure Library Authors.
+// All Rights Reserved.
+
+/**
+ * @license Portions of this code are from the Dojo Toolkit, received by
+ * The Closure Library Authors under the BSD license. All other code is
+ * Copyright 2005-2009 The Closure Library Authors. All Rights Reserved.
+
+The "New" BSD License:
+
+Copyright (c) 2005-2009, The Dojo Foundation
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+  * Neither the name of the Dojo Foundation nor the names of its contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/**
+ * @fileoverview This code was ported from the Dojo Toolkit
+   http://dojotoolkit.org and modified slightly for Closure.
+ *
+ *  goog.dom.query is a relatively full-featured CSS3 query function. It is
+ *  designed to take any valid CSS3 selector and return the nodes matching
+ *  the selector. To do this quickly, it processes queries in several
+ *  steps, applying caching where profitable.
+ *    The steps (roughly in reverse order of the way they appear in the code):
+ *    1.) check to see if we already have a "query dispatcher"
+ *      - if so, use that with the given parameterization. Skip to step 4.
+ *    2.) attempt to determine which branch to dispatch the query to:
+ *      - JS (optimized DOM iteration)
+ *      - native (FF3.1, Safari 3.2+, Chrome, some IE 8 doctypes). If native,
+ *        skip to step 4, using a stub dispatcher for QSA queries.
+ *    3.) tokenize and convert to executable "query dispatcher"
+ *        assembled as a chain of "yes/no" test functions pertaining to
+ *        a section of a simple query statement (".blah:nth-child(odd)"
+ *        but not "div div", which is 2 simple statements).
+ *    4.) the resulting query dispatcher is called in the passed scope
+ *        (by default the top-level document)
+ *      - for DOM queries, this results in a recursive, top-down
+ *        evaluation of nodes based on each simple query section
+ *      - querySelectorAll is used instead of DOM where possible. If a query
+ *        fails in this mode, it is re-run against the DOM evaluator and all
+ *        future queries using the same selector evaluate against the DOM branch
+ *        too.
+ *    5.) matched nodes are pruned to ensure they are unique
+ */
+
+goog.provide('goog.dom.query');
+
+goog.require('goog.array');
+goog.require('goog.dom');
+goog.require('goog.functions');
+goog.require('goog.string');
+goog.require('goog.userAgent');
+
+  /**
+   * Returns nodes which match the given CSS3 selector, searching the
+   * entire document by default but optionally taking a node to scope
+   * the search by.
+   *
+   * dojo.query() is the swiss army knife of DOM node manipulation in
+   * Dojo. Much like Prototype's "$$" (bling-bling) function or JQuery's
+   * "$" function, dojo.query provides robust, high-performance
+   * CSS-based node selector support with the option of scoping searches
+   * to a particular sub-tree of a document.
+   *
+   * Supported Selectors:
+   * --------------------
+   *
+   * dojo.query() supports a rich set of CSS3 selectors, including:
+   *
+   *   * class selectors (e.g., `.foo`)
+   *   * node type selectors like `span`
+   *   * ` ` descendant selectors
+   *   * `>` child element selectors
+   *   * `#foo` style ID selectors
+   *   * `*` universal selector
+   *   * `~`, the immediately preceeded-by sibling selector
+   *   * `+`, the preceeded-by sibling selector
+   *   * attribute queries:
+   *   |  * `[foo]` attribute presence selector
+   *   |  * `[foo='bar']` attribute value exact match
+   *   |  * `[foo~='bar']` attribute value list item match
+   *   |  * `[foo^='bar']` attribute start match
+   *   |  * `[foo$='bar']` attribute end match
+   *   |  * `[foo*='bar']` attribute substring match
+   *   * `:first-child`, `:last-child` positional selectors
+   *   * `:empty` content emtpy selector
+   *   * `:empty` content emtpy selector
+   *   * `:nth-child(n)`, `:nth-child(2n+1)` style positional calculations
+   *   * `:nth-child(even)`, `:nth-child(odd)` positional selectors
+   *   * `:not(...)` negation pseudo selectors
+   *
+   * Any legal combination of these selectors will work with
+   * `dojo.query()`, including compound selectors ("," delimited).
+   * Very complex and useful searches can be constructed with this
+   * palette of selectors and when combined with functions for
+   * maniplation presented by dojo.NodeList, many types of DOM
+   * manipulation operations become very straightforward.
+   *
+   * Unsupported Selectors:
+   * ----------------------
+   *
+   * While dojo.query handles many CSS3 selectors, some fall outside of
+   * what's resaonable for a programmatic node querying engine to
+   * handle. Currently unsupported selectors include:
+   *
+   *   * namespace-differentiated selectors of any form
+   *   * all `::` pseduo-element selectors
+   *   * certain pseudo-selectors which don't get a lot of day-to-day use:
+   *   |  * `:root`, `:lang()`, `:target`, `:focus`
+   *   * all visual and state selectors:
+   *   |  * `:root`, `:active`, `:hover`, `:visisted`, `:link`,
+   *       `:enabled`, `:disabled`, `:checked`
+   *   * `:*-of-type` pseudo selectors
+   *
+   * dojo.query and XML Documents:
+   * -----------------------------
+   *
+   * `dojo.query` currently only supports searching XML documents
+   * whose tags and attributes are 100% lower-case. This is a known
+   * limitation and will [be addressed soon]
+   * (http://trac.dojotoolkit.org/ticket/3866)
+   *
+   * Non-selector Queries:
+   * ---------------------
+   *
+   * If something other than a String is passed for the query,
+   * `dojo.query` will return a new `dojo.NodeList` constructed from
+   * that parameter alone and all further processing will stop. This
+   * means that if you have a reference to a node or NodeList, you
+   * can quickly construct a new NodeList from the original by
+   * calling `dojo.query(node)` or `dojo.query(list)`.
+   *
+   * example:
+   *   search the entire document for elements with the class "foo":
+   * |  dojo.query(".foo");
+   *   these elements will match:
+   * |  <span class="foo"></span>
+   * |  <span class="foo bar"></span>
+   * |  <p class="thud foo"></p>
+   * example:
+   *   search the entire document for elements with the classes "foo" *and*
+   *   "bar":
+   * |  dojo.query(".foo.bar");
+   *   these elements will match:
+   * |  <span class="foo bar"></span>
+   *   while these will not:
+   * |  <span class="foo"></span>
+   * |  <p class="thud foo"></p>
+   * example:
+   *   find `<span>` elements which are descendants of paragraphs and
+   *   which have a "highlighted" class:
+   * |  dojo.query("p span.highlighted");
+   *   the innermost span in this fragment matches:
+   * |  <p class="foo">
+   * |    <span>...
+   * |      <span class="highlighted foo bar">...</span>
+   * |    </span>
+   * |  </p>
+   * example:
+   *   find all odd table rows inside of the table
+   *   `#tabular_data`, using the `>` (direct child) selector to avoid
+   *   affecting any nested tables:
+   * |  dojo.query("#tabular_data > tbody > tr:nth-child(odd)");
+   *
+   * @param {string} query The CSS3 expression to match against. For details
+   *     on the syntax of CSS3 selectors, see
+   *     http://www.w3.org/TR/css3-selectors/#selectors.
+   * @param {(string|Node)=} opt_root A Node (or node id) to scope the search
+   *     from (optional).
+   * @return { {length: number} } The elements that matched the query.
+   */
+goog.dom.query = (function() {
+  ////////////////////////////////////////////////////////////////////////
+  // Global utilities
+  ////////////////////////////////////////////////////////////////////////
+
+  var cssCaseBug = (goog.userAgent.WEBKIT &&
+                     ((goog.dom.getDocument().compatMode) == 'BackCompat')
+                   );
+
+  // On browsers that support the "children" collection we can avoid a lot of
+  // iteration on chaff (non-element) nodes.
+  var childNodesName = !!goog.dom.getDocument().firstChild['children'] ?
+                          'children' :
+                          'childNodes';
+
+  var specials = '>~+';
+
+  // Global thunk to determine whether we should treat the current query as
+  // case sensitive or not. This switch is flipped by the query evaluator based
+  // on the document passed as the context to search.
+  var caseSensitive = false;
+
+
+  ////////////////////////////////////////////////////////////////////////
+  // Tokenizer
+  ////////////////////////////////////////////////////////////////////////
+
+  var getQueryParts = function(query) {
+    //  summary:
+    //    state machine for query tokenization
+    //  description:
+    //    instead of using a brittle and slow regex-based CSS parser,
+    //    dojo.query implements an AST-style query representation. This
+    //    representation is only generated once per query. For example,
+    //    the same query run multiple times or under different root nodes
+    //    does not re-parse the selector expression but instead uses the
+    //    cached data structure. The state machine implemented here
+    //    terminates on the last " " (space) charachter and returns an
+    //    ordered array of query component structures (or "parts"). Each
+    //    part represents an operator or a simple CSS filtering
+    //    expression. The structure for parts is documented in the code
+    //    below.
+
+
+    // NOTE:
+    //    this code is designed to run fast and compress well. Sacrifices
+    //    to readibility and maintainability have been made.
+    if (specials.indexOf(query.slice(-1)) >= 0) {
+      // If we end with a ">", "+", or "~", that means we're implicitly
+      // searching all children, so make it explicit.
+      query += ' * '
+    } else {
+      // if you have not provided a terminator, one will be provided for
+      // you...
+      query += ' ';
+    }
+
+    var ts = function(/*Integer*/ s, /*Integer*/ e) {
+      // trim and slice.
+
+      // take an index to start a string slice from and an end position
+      // and return a trimmed copy of that sub-string
+      return goog.string.trim(query.slice(s, e));
+    };
+
+    // The overall data graph of the full query, as represented by queryPart
+    // objects.
+    var queryParts = [];
+
+
+    // state keeping vars
+    var inBrackets = -1,
+        inParens = -1,
+        inMatchFor = -1,
+        inPseudo = -1,
+        inClass = -1,
+        inId = -1,
+        inTag = -1,
+        lc = '',
+        cc = '',
+        pStart;
+
+    // iteration vars
+    var x = 0, // index in the query
+        ql = query.length,
+        currentPart = null, // data structure representing the entire clause
+        cp = null; // the current pseudo or attr matcher
+
+    // several temporary variables are assigned to this structure durring a
+    // potential sub-expression match:
+    //    attr:
+    //      a string representing the current full attribute match in a
+    //      bracket expression
+    //    type:
+    //      if there's an operator in a bracket expression, this is
+    //      used to keep track of it
+    //    value:
+    //      the internals of parenthetical expression for a pseudo. for
+    //      :nth-child(2n+1), value might be '2n+1'
+
+    var endTag = function() {
+      // called when the tokenizer hits the end of a particular tag name.
+      // Re-sets state variables for tag matching and sets up the matcher
+      // to handle the next type of token (tag or operator).
+      if (inTag >= 0) {
+        var tv = (inTag == x) ? null : ts(inTag, x);
+        if (specials.indexOf(tv) < 0) {
+          currentPart.tag = tv;
+        } else {
+          currentPart.oper = tv;
+        }
+        inTag = -1;
+      }
+    };
+
+    var endId = function() {
+      // Called when the tokenizer might be at the end of an ID portion of a
+      // match.
+      if (inId >= 0) {
+        currentPart.id = ts(inId, x).replace(/\\/g, '');
+        inId = -1;
+      }
+    };
+
+    var endClass = function() {
+      // Called when the tokenizer might be at the end of a class name
+      // match. CSS allows for multiple classes, so we augment the
+      // current item with another class in its list.
+      if (inClass >= 0) {
+        currentPart.classes.push(ts(inClass + 1, x).replace(/\\/g, ''));
+        inClass = -1;
+      }
+    };
+
+    var endAll = function() {
+      // at the end of a simple fragment, so wall off the matches
+      endId(); endTag(); endClass();
+    };
+
+    var endPart = function() {
+      endAll();
+      if (inPseudo >= 0) {
+        currentPart.pseudos.push({ name: ts(inPseudo + 1, x) });
+      }
+      // Hint to the selector engine to tell it whether or not it
+      // needs to do any iteration. Many simple selectors don't, and
+      // we can avoid significant construction-time work by advising
+      // the system to skip them.
+      currentPart.loops = currentPart.pseudos.length ||
+                          currentPart.attrs.length ||
+                          currentPart.classes.length;
+
+      // save the full expression as a string
+      currentPart.oquery = currentPart.query = ts(pStart, x);
+
+
+      // otag/tag are hints to suggest to the system whether or not
+      // it's an operator or a tag. We save a copy of otag since the
+      // tag name is cast to upper-case in regular HTML matches. The
+      // system has a global switch to figure out if the current
+      // expression needs to be case sensitive or not and it will use
+      // otag or tag accordingly
+      currentPart.otag = currentPart.tag = (currentPart.oper) ?
+                                                     null :
+                                                     (currentPart.tag || '*');
+
+      if (currentPart.tag) {
+        // if we're in a case-insensitive HTML doc, we likely want
+        // the toUpperCase when matching on element.tagName. If we
+        // do it here, we can skip the string op per node
+        // comparison
+        currentPart.tag = currentPart.tag.toUpperCase();
+      }
+
+      // add the part to the list
+      if (queryParts.length && (queryParts[queryParts.length - 1].oper)) {
+        // operators are always infix, so we remove them from the
+        // list and attach them to the next match. The evaluator is
+        // responsible for sorting out how to handle them.
+        currentPart.infixOper = queryParts.pop();
+        currentPart.query = currentPart.infixOper.query + ' ' +
+            currentPart.query;
+      }
+      queryParts.push(currentPart);
+
+      currentPart = null;
+    }
+
+    // iterate over the query, charachter by charachter, building up a
+    // list of query part objects
+    for (; lc = cc, cc = query.charAt(x), x < ql; x++) {
+      //    cc: the current character in the match
+      //    lc: the last charachter (if any)
+
+      // someone is trying to escape something, so don't try to match any
+      // fragments. We assume we're inside a literal.
+      if (lc == '\\') {
+        continue;
+      }
+      if (!currentPart) { // a part was just ended or none has yet been created
+        // NOTE: I hate all this alloc, but it's shorter than writing tons of
+        // if's
+        pStart = x;
+        //  rules describe full CSS sub-expressions, like:
+        //    #someId
+        //    .className:first-child
+        //  but not:
+        //    thinger > div.howdy[type=thinger]
+        //  the indidual components of the previous query would be
+        //  split into 3 parts that would be represented a structure
+        //  like:
+        //    [
+        //      {
+        //        query: 'thinger',
+        //        tag: 'thinger',
+        //      },
+        //      {
+        //        query: 'div.howdy[type=thinger]',
+        //        classes: ['howdy'],
+        //        infixOper: {
+        //          query: '>',
+        //          oper: '>',
+        //        }
+        //      },
+        //    ]
+        currentPart = {
+          query: null, // the full text of the part's rule
+          pseudos: [], // CSS supports multiple pseud-class matches in a single
+              // rule
+          attrs: [],  // CSS supports multi-attribute match, so we need an array
+          classes: [], // class matches may be additive,
+              // e.g.: .thinger.blah.howdy
+          tag: null,  // only one tag...
+          oper: null, // ...or operator per component. Note that these wind up
+              // being exclusive.
+          id: null,   // the id component of a rule
+          getTag: function() {
+            return (caseSensitive) ? this.otag : this.tag;
+          }
+        };
+
+        // if we don't have a part, we assume we're going to start at
+        // the beginning of a match, which should be a tag name. This
+        // might fault a little later on, but we detect that and this
+        // iteration will still be fine.
+        inTag = x;
+      }
+
+      if (inBrackets >= 0) {
+        // look for a the close first
+        if (cc == ']') { // if we're in a [...] clause and we end, do assignment
+          if (!cp.attr) {
+            // no attribute match was previously begun, so we
+            // assume this is an attribute existance match in the
+            // form of [someAttributeName]
+            cp.attr = ts(inBrackets + 1, x);
+          } else {
+            // we had an attribute already, so we know that we're
+            // matching some sort of value, as in [attrName=howdy]
+            cp.matchFor = ts((inMatchFor || inBrackets + 1), x);
+          }
+          var cmf = cp.matchFor;
+          if (cmf) {
+            // try to strip quotes from the matchFor value. We want
+            // [attrName=howdy] to match the same
+            //  as [attrName = 'howdy' ]
+            if ((cmf.charAt(0) == '"') || (cmf.charAt(0) == "'")) {
+              cp.matchFor = cmf.slice(1, -1);
+            }
+          }
+          // end the attribute by adding it to the list of attributes.
+          currentPart.attrs.push(cp);
+          cp = null; // necessary?
+          inBrackets = inMatchFor = -1;
+        } else if (cc == '=') {
+          // if the last char was an operator prefix, make sure we
+          // record it along with the '=' operator.
+          var addToCc = ('|~^$*'.indexOf(lc) >= 0) ? lc : '';
+          cp.type = addToCc + cc;
+          cp.attr = ts(inBrackets + 1, x - addToCc.length);
+          inMatchFor = x + 1;
+        }
+        // now look for other clause parts
+      } else if (inParens >= 0) {
+        // if we're in a parenthetical expression, we need to figure
+        // out if it's attached to a pseduo-selector rule like
+        // :nth-child(1)
+        if (cc == ')') {
+          if (inPseudo >= 0) {
+            cp.value = ts(inParens + 1, x);
+          }
+          inPseudo = inParens = -1;
+        }
+      } else if (cc == '#') {
+        // start of an ID match
+        endAll();
+        inId = x + 1;
+      } else if (cc == '.') {
+        // start of a class match
+        endAll();
+        inClass = x;
+      } else if (cc == ':') {
+        // start of a pseudo-selector match
+        endAll();
+        inPseudo = x;
+      } else if (cc == '[') {
+        // start of an attribute match.
+        endAll();
+        inBrackets = x;
+        // provide a new structure for the attribute match to fill-in
+        cp = {
+          /*=====
+          attr: null, type: null, matchFor: null
+          =====*/
+        };
+      } else if (cc == '(') {
+        // we really only care if we've entered a parenthetical
+        // expression if we're already inside a pseudo-selector match
+        if (inPseudo >= 0) {
+          // provide a new structure for the pseudo match to fill-in
+          cp = {
+            name: ts(inPseudo + 1, x),
+            value: null
+          }
+          currentPart.pseudos.push(cp);
+        }
+        inParens = x;
+      } else if (
+        (cc == ' ') &&
+        // if it's a space char and the last char is too, consume the
+        // current one without doing more work
+        (lc != cc)
+      ) {
+        endPart();
+      }
+    }
+    return queryParts;
+  };
+
+
+  ////////////////////////////////////////////////////////////////////////
+  // DOM query infrastructure
+  ////////////////////////////////////////////////////////////////////////
+
+  var agree = function(first, second) {
+    // the basic building block of the yes/no chaining system. agree(f1,
+    // f2) generates a new function which returns the boolean results of
+    // both of the passed functions to a single logical-anded result. If
+    // either are not possed, the other is used exclusively.
+    if (!first) {
+      return second;
+    }
+    if (!second) {
+      return first;
+    }
+
+    return function() {
+      return first.apply(window, arguments) && second.apply(window, arguments);
+    }
+  };
+
+  /**
+   * @param {Array=} opt_arr
+   */
+  function getArr(i, opt_arr) {
+    // helps us avoid array alloc when we don't need it
+    var r = opt_arr || [];
+    if (i) {
+      r.push(i);
+    }
+    return r;
+  };
+
+  var isElement = function(n) {
+    return (1 == n.nodeType);
+  };
+
+  // FIXME: need to coalesce getAttr with defaultGetter
+  var blank = '';
+  var getAttr = function(elem, attr) {
+    if (!elem) {
+      return blank;
+    }
+    if (attr == 'class') {
+      return elem.className || blank;
+    }
+    if (attr == 'for') {
+      return elem.htmlFor || blank;
+    }
+    if (attr == 'style') {
+      return elem.style.cssText || blank;
+    }
+    return (caseSensitive ? elem.getAttribute(attr) :
+        elem.getAttribute(attr, 2)) || blank;
+  };
+
+  var attrs = {
+    '*=': function(attr, value) {
+      return function(elem) {
+        // E[foo*="bar"]
+        //    an E element whose "foo" attribute value contains
+        //    the substring "bar"
+        return (getAttr(elem, attr).indexOf(value) >= 0);
+      }
+    },
+    '^=': function(attr, value) {
+      // E[foo^="bar"]
+      //    an E element whose "foo" attribute value begins exactly
+      //    with the string "bar"
+      return function(elem) {
+        return (getAttr(elem, attr).indexOf(value) == 0);
+      }
+    },
+    '$=': function(attr, value) {
+      // E[foo$="bar"]
+      //    an E element whose "foo" attribute value ends exactly
+      //    with the string "bar"
+      var tval = ' ' + value;
+      return function(elem) {
+        var ea = ' ' + getAttr(elem, attr);
+        return (ea.lastIndexOf(value) == (ea.length - value.length));
+      }
+    },
+    '~=': function(attr, value) {
+      // E[foo~="bar"]
+      //    an E element whose "foo" attribute value is a list of
+      //    space-separated values, one of which is exactly equal
+      //    to "bar"
+
+      var tval = ' ' + value + ' ';
+      return function(elem) {
+        var ea = ' ' + getAttr(elem, attr) + ' ';
+        return (ea.indexOf(tval) >= 0);
+      }
+    },
+    '|=': function(attr, value) {
+      // E[hreflang|="en"]
+      //    an E element whose "hreflang" attribute has a
+      //    hyphen-separated list of values beginning (from the
+      //    left) with "en"
+      value = ' ' + value;
+      return function(elem) {
+        var ea = ' ' + getAttr(elem, attr);
+        return (
+          (ea == value) ||
+          (ea.indexOf(value + '-') == 0)
+        );
+      }
+    },
+    '=': function(attr, value) {
+      return function(elem) {
+        return (getAttr(elem, attr) == value);
+      }
+    }
+  };
+
+  // avoid testing for node type if we can. Defining this in the negative
+  // here to avoid negation in the fast path.
+  var noNextElementSibling = (
+    typeof goog.dom.getDocument().firstChild.nextElementSibling == 'undefined'
+  );
+  var nSibling = !noNextElementSibling ? 'nextElementSibling' : 'nextSibling';
+  var pSibling = !noNextElementSibling ?
+                    'previousElementSibling' :
+                    'previousSibling';
+  var simpleNodeTest = (noNextElementSibling ? isElement : goog.functions.TRUE);
+
+  var _lookLeft = function(node) {
+    while (node = node[pSibling]) {
+      if (simpleNodeTest(node)) {
+        return false;
+      }
+    }
+    return true;
+  };
+
+  var _lookRight = function(node) {
+    while (node = node[nSibling]) {
+      if (simpleNodeTest(node)) {
+        return false;
+      }
+    }
+    return true;
+  };
+
+  var getNodeIndex = function(node) {
+    var root = node.parentNode;
+    var i = 0,
+        tret = root[childNodesName],
+        ci = (node['_i'] || -1),
+        cl = (root['_l'] || -1);
+
+    if (!tret) {
+      return -1;
+    }
+    var l = tret.length;
+
+    // we calcuate the parent length as a cheap way to invalidate the
+    // cache. It's not 100% accurate, but it's much more honest than what
+    // other libraries do
+    if (cl == l && ci >= 0 && cl >= 0) {
+      // if it's legit, tag and release
+      return ci;
+    }
+
+    // else re-key things
+    root['_l'] = l;
+    ci = -1;
+    var te = root['firstElementChild'] || root['firstChild'];
+    for (; te; te = te[nSibling]) {
+      if (simpleNodeTest(te)) {
+        te['_i'] = ++i;
+        if (node === te) {
+          // NOTE:
+          //  shortcuting the return at this step in indexing works
+          //  very well for benchmarking but we avoid it here since
+          //  it leads to potential O(n^2) behavior in sequential
+          //  getNodexIndex operations on a previously un-indexed
+          //  parent. We may revisit this at a later time, but for
+          //  now we just want to get the right answer more often
+          //  than not.
+          ci = i;
+        }
+      }
+    }
+    return ci;
+  };
+
+  var isEven = function(elem) {
+    return !((getNodeIndex(elem)) % 2);
+  };
+
+  var isOdd = function(elem) {
+    return (getNodeIndex(elem)) % 2;
+  };
+
+  var pseudos = {
+    'checked': function(name, condition) {
+      return function(elem) {
+        return elem.checked || elem.attributes['checked'];
+      }
+    },
+    'first-child': function() {
+      return _lookLeft;
+    },
+    'last-child': function() {
+      return _lookRight;
+    },
+    'only-child': function(name, condition) {
+      return function(node) {
+        if (!_lookLeft(node)) {
+          return false;
+        }
+        if (!_lookRight(node)) {
+          return false;
+        }
+        return true;
+      };
+    },
+    'empty': function(name, condition) {
+      return function(elem) {
+        // DomQuery and jQuery get this wrong, oddly enough.
+        // The CSS 3 selectors spec is pretty explicit about it, too.
+        var cn = elem.childNodes;
+        var cnl = elem.childNodes.length;
+        // if(!cnl) { return true; }
+        for (var x = cnl - 1; x >= 0; x--) {
+          var nt = cn[x].nodeType;
+          if ((nt === 1) || (nt == 3)) {
+            return false;
+          }
+        }
+        return true;
+      }
+    },
+    'contains': function(name, condition) {
+      var cz = condition.charAt(0);
+      if (cz == '"' || cz == "'") { // Remove quotes.
+        condition = condition.slice(1, -1);
+      }
+      return function(elem) {
+        return (elem.innerHTML.indexOf(condition) >= 0);
+      }
+    },
+    'not': function(name, condition) {
+      var p = getQueryParts(condition)[0];
+      var ignores = { el: 1 };
+      if (p.tag != '*') {
+        ignores.tag = 1;
+      }
+      if (!p.classes.length) {
+        ignores.classes = 1;
+      }
+      var ntf = getSimpleFilterFunc(p, ignores);
+      return function(elem) {
+        return !ntf(elem);
+      }
+    },
+    'nth-child': function(name, condition) {
+      function pi(n) {
+        return parseInt(n, 10);
+      }
+      // avoid re-defining function objects if we can
+      if (condition == 'odd') {
+        return isOdd;
+      } else if (condition == 'even') {
+        return isEven;
+      }
+      // FIXME: can we shorten this?
+      if (condition.indexOf('n') != -1) {
+        var tparts = condition.split('n', 2);
+        var pred = tparts[0] ? ((tparts[0] == '-') ? -1 : pi(tparts[0])) : 1;
+        var idx = tparts[1] ? pi(tparts[1]) : 0;
+        var lb = 0, ub = -1;
+        if (pred > 0) {
+          if (idx < 0) {
+            idx = (idx % pred) && (pred + (idx % pred));
+          } else if (idx > 0) {
+            if (idx >= pred) {
+              lb = idx - idx % pred;
+            }
+            idx = idx % pred;
+          }
+        } else if (pred < 0) {
+          pred *= -1;
+          // idx has to be greater than 0 when pred is negative;
+          // shall we throw an error here?
+          if (idx > 0) {
+            ub = idx;
+            idx = idx % pred;
+          }
+        }
+        if (pred > 0) {
+          return function(elem) {
+            var i = getNodeIndex(elem);
+            return (i >= lb) && (ub < 0 || i <= ub) && ((i % pred) == idx);
+          }
+        } else {
+          condition = idx;
+        }
+      }
+      var ncount = pi(condition);
+      return function(elem) {
+        return (getNodeIndex(elem) == ncount);
+      }
+    }
+  };
+
+  var defaultGetter = (goog.userAgent.IE) ? function(cond) {
+    var clc = cond.toLowerCase();
+    if (clc == 'class') {
+      cond = 'className';
+    }
+    return function(elem) {
+      return caseSensitive ? elem.getAttribute(cond) : elem[cond] || elem[clc];
+    }
+  } : function(cond) {
+    return function(elem) {
+      return elem && elem.getAttribute && elem.hasAttribute(cond);
+    }
+  };
+
+  var getSimpleFilterFunc = function(query, ignores) {
+    // Generates a node tester function based on the passed query part. The
+    // query part is one of the structures generatd by the query parser when it
+    // creates the query AST. The 'ignores' object specifies which (if any)
+    // tests to skip, allowing the system to avoid duplicating work where it
+    // may have already been taken into account by other factors such as how
+    // the nodes to test were fetched in the first place.
+    if (!query) {
+      return goog.functions.TRUE;
+    }
+    ignores = ignores || {};
+
+    var ff = null;
+
+    if (!ignores.el) {
+      ff = agree(ff, isElement);
+    }
+
+    if (!ignores.tag) {
+      if (query.tag != '*') {
+        ff = agree(ff, function(elem) {
+          return (elem && (elem.tagName == query.getTag()));
+        });
+      }
+    }
+
+    if (!ignores.classes) {
+      goog.array.forEach(query.classes, function(cname, idx, arr) {
+        // Get the class name.
+        var re = new RegExp('(?:^|\\s)' + cname + '(?:\\s|$)');
+        ff = agree(ff, function(elem) {
+          return re.test(elem.className);
+        });
+        ff.count = idx;
+      });
+    }
+
+    if (!ignores.pseudos) {
+      goog.array.forEach(query.pseudos, function(pseudo) {
+        var pn = pseudo.name;
+        if (pseudos[pn]) {
+          ff = agree(ff, pseudos[pn](pn, pseudo.value));
+        }
+      });
+    }
+
+    if (!ignores.attrs) {
+      goog.array.forEach(query.attrs, function(attr) {
+        var matcher;
+        var a = attr.attr;
+        // type, attr, matchFor
+        if (attr.type && attrs[attr.type]) {
+          matcher = attrs[attr.type](a, attr.matchFor);
+        } else if (a.length) {
+          matcher = defaultGetter(a);
+        }
+        if (matcher) {
+          ff = agree(ff, matcher);
+        }
+      });
+    }
+
+    if (!ignores.id) {
+      if (query.id) {
+        ff = agree(ff, function(elem) {
+          return (!!elem && (elem.id == query.id));
+        });
+      }
+    }
+
+    if (!ff) {
+      if (!('default' in ignores)) {
+        ff = goog.functions.TRUE;
+      }
+    }
+    return ff;
+  };
+
+  var nextSiblingIterator = function(filterFunc) {
+    return function(node, ret, bag) {
+      while (node = node[nSibling]) {
+        if (noNextElementSibling && (!isElement(node))) {
+          continue;
+        }
+        if (
+          (!bag || _isUnique(node, bag)) &&
+          filterFunc(node)
+        ) {
+          ret.push(node);
+        }
+        break;
+      }
+      return ret;
+    };
+  };
+
+  var nextSiblingsIterator = function(filterFunc) {
+    return function(root, ret, bag) {
+      var te = root[nSibling];
+      while (te) {
+        if (simpleNodeTest(te)) {
+          if (bag && !_isUnique(te, bag)) {
+            break;
+          }
+          if (filterFunc(te)) {
+            ret.push(te);
+          }
+        }
+        te = te[nSibling];
+      }
+      return ret;
+    };
+  };
+
+  // Get an array of child *elements*, skipping text and comment nodes
+  var _childElements = function(filterFunc) {
+    filterFunc = filterFunc || goog.functions.TRUE;
+    return function(root, ret, bag) {
+      var te, x = 0, tret = root[childNodesName];
+      while (te = tret[x++]) {
+        if (
+          simpleNodeTest(te) &&
+          (!bag || _isUnique(te, bag)) &&
+          (filterFunc(te, x))
+        ) {
+          ret.push(te);
+        }
+      }
+      return ret;
+    };
+  };
+
+  // test to see if node is below root
+  var _isDescendant = function(node, root) {
+    var pn = node.parentNode;
+    while (pn) {
+      if (pn == root) {
+        break;
+      }
+      pn = pn.parentNode;
+    }
+    return !!pn;
+  };
+
+  var _getElementsFuncCache = {};
+
+  var getElementsFunc = function(query) {
+    var retFunc = _getElementsFuncCache[query.query];
+    // If we've got a cached dispatcher, just use that.
+    if (retFunc) {
+      return retFunc;
+    }
+    // Else, generate a new one.
+
+    // NOTE:
+    //    This function returns a function that searches for nodes and
+    //    filters them. The search may be specialized by infix operators
+    //    (">", "~", or "+") else it will default to searching all
+    //    descendants (the " " selector). Once a group of children is
+    //    founde, a test function is applied to weed out the ones we
+    //    don't want. Many common cases can be fast-pathed. We spend a
+    //    lot of cycles to create a dispatcher that doesn't do more work
+    //    than necessary at any point since, unlike this function, the
+    //    dispatchers will be called every time. The logic of generating
+    //    efficient dispatchers looks like this in pseudo code:
+    //
+    //    # if it's a purely descendant query (no ">", "+", or "~" modifiers)
+    //    if infixOperator == " ":
+    //      if only(id):
+    //        return def(root):
+    //          return d.byId(id, root);
+    //
+    //      elif id:
+    //        return def(root):
+    //          return filter(d.byId(id, root));
+    //
+    //      elif cssClass && getElementsByClassName:
+    //        return def(root):
+    //          return filter(root.getElementsByClassName(cssClass));
+    //
+    //      elif only(tag):
+    //        return def(root):
+    //          return root.getElementsByTagName(tagName);
+    //
+    //      else:
+    //        # search by tag name, then filter
+    //        return def(root):
+    //          return filter(root.getElementsByTagName(tagName||"*"));
+    //
+    //    elif infixOperator == ">":
+    //      # search direct children
+    //      return def(root):
+    //        return filter(root.children);
+    //
+    //    elif infixOperator == "+":
+    //      # search next sibling
+    //      return def(root):
+    //        return filter(root.nextElementSibling);
+    //
+    //    elif infixOperator == "~":
+    //      # search rightward siblings
+    //      return def(root):
+    //        return filter(nextSiblings(root));
+
+    var io = query.infixOper;
+    var oper = (io ? io.oper : '');
+    // The default filter func which tests for all conditions in the query
+    // part. This is potentially inefficient, so some optimized paths may
+    // re-define it to test fewer things.
+    var filterFunc = getSimpleFilterFunc(query, { el: 1 });
+    var qt = query.tag;
+    var wildcardTag = ('*' == qt);
+    var ecs = goog.dom.getDocument()['getElementsByClassName'];
+
+    if (!oper) {
+      // If there's no infix operator, then it's a descendant query. ID
+      // and "elements by class name" variants can be accelerated so we
+      // call them out explicitly:
+      if (query.id) {
+        // Testing shows that the overhead of goog.functions.TRUE() is
+        // acceptable and can save us some bytes vs. re-defining the function
+        // everywhere.
+        filterFunc = (!query.loops && wildcardTag) ?
+          goog.functions.TRUE :
+          getSimpleFilterFunc(query, { el: 1, id: 1 });
+
+        retFunc = function(root, arr) {
+          var te = goog.dom.getDomHelper(root).getElement(query.id);
+          if (!te || !filterFunc(te)) {
+            return;
+          }
+          if (9 == root.nodeType) { // If root's a doc, we just return directly.
+            return getArr(te, arr);
+          } else { // otherwise check ancestry
+            if (_isDescendant(te, root)) {
+              return getArr(te, arr);
+            }
+          }
+        }
+      } else if (
+        ecs &&
+        // isAlien check. Workaround for Prototype.js being totally evil/dumb.
+        /\{\s*\[native code\]\s*\}/.test(String(ecs)) &&
+        query.classes.length &&
+        // WebKit bug where quirks-mode docs select by class w/o case
+        // sensitivity.
+        !cssCaseBug
+      ) {
+        // it's a class-based query and we've got a fast way to run it.
+
+        // ignore class and ID filters since we will have handled both
+        filterFunc = getSimpleFilterFunc(query, { el: 1, classes: 1, id: 1 });
+        var classesString = query.classes.join(' ');
+        retFunc = function(root, arr) {
+          var ret = getArr(0, arr), te, x = 0;
+          var tret = root.getElementsByClassName(classesString);
+          while ((te = tret[x++])) {
+            if (filterFunc(te, root)) {
+              ret.push(te);
+            }
+          }
+          return ret;
+        };
+
+      } else if (!wildcardTag && !query.loops) {
+        // it's tag only. Fast-path it.
+        retFunc = function(root, arr) {
+          var ret = getArr(0, arr), te, x = 0;
+          var tret = root.getElementsByTagName(query.getTag());
+          while ((te = tret[x++])) {
+            ret.push(te);
+          }
+          return ret;
+        };
+      } else {
+        // the common case:
+        //    a descendant selector without a fast path. By now it's got
+        //    to have a tag selector, even if it's just "*" so we query
+        //    by that and filter
+        filterFunc = getSimpleFilterFunc(query, { el: 1, tag: 1, id: 1 });
+        retFunc = function(root, arr) {
+          var ret = getArr(0, arr), te, x = 0;
+          // we use getTag() to avoid case sensitivity issues
+          var tret = root.getElementsByTagName(query.getTag());
+          while (te = tret[x++]) {
+            if (filterFunc(te, root)) {
+              ret.push(te);
+            }
+          }
+          return ret;
+        };
+      }
+    } else {
+      // the query is scoped in some way. Instead of querying by tag we
+      // use some other collection to find candidate nodes
+      var skipFilters = { el: 1 };
+      if (wildcardTag) {
+        skipFilters.tag = 1;
+      }
+      filterFunc = getSimpleFilterFunc(query, skipFilters);
+      if ('+' == oper) {
+        retFunc = nextSiblingIterator(filterFunc);
+      } else if ('~' == oper) {
+        retFunc = nextSiblingsIterator(filterFunc);
+      } else if ('>' == oper) {
+        retFunc = _childElements(filterFunc);
+      }
+    }
+    // cache it and return
+    return _getElementsFuncCache[query.query] = retFunc;
+  };
+
+  var filterDown = function(root, queryParts) {
+    // NOTE:
+    //    this is the guts of the DOM query system. It takes a list of
+    //    parsed query parts and a root and finds children which match
+    //    the selector represented by the parts
+    var candidates = getArr(root), qp, x, te, qpl = queryParts.length, bag, ret;
+
+    for (var i = 0; i < qpl; i++) {
+      ret = [];
+      qp = queryParts[i];
+      x = candidates.length - 1;
+      if (x > 0) {
+        // if we have more than one root at this level, provide a new
+        // hash to use for checking group membership but tell the
+        // system not to post-filter us since we will already have been
+        // gauranteed to be unique
+        bag = {};
+        ret.nozip = true;
+      }
+      var gef = getElementsFunc(qp);
+      for (var j = 0; te = candidates[j]; j++) {
+        // for every root, get the elements that match the descendant
+        // selector, adding them to the 'ret' array and filtering them
+        // via membership in this level's bag. If there are more query
+        // parts, then this level's return will be used as the next
+        // level's candidates
+        gef(te, ret, bag);
+      }
+      if (!ret.length) { break; }
+      candidates = ret;
+    }
+    return ret;
+  };
+
+  ////////////////////////////////////////////////////////////////////////
+  // the query runner
+  ////////////////////////////////////////////////////////////////////////
+
+  // these are the primary caches for full-query results. The query
+  // dispatcher functions are generated then stored here for hash lookup in
+  // the future
+  var _queryFuncCacheDOM = {},
+    _queryFuncCacheQSA = {};
+
+  // this is the second level of spliting, from full-length queries (e.g.,
+  // 'div.foo .bar') into simple query expressions (e.g., ['div.foo',
+  // '.bar'])
+  var getStepQueryFunc = function(query) {
+    var qparts = getQueryParts(goog.string.trim(query));
+
+    // if it's trivial, avoid iteration and zipping costs
+    if (qparts.length == 1) {
+      // We optimize this case here to prevent dispatch further down the
+      // chain, potentially slowing things down. We could more elegantly
+      // handle this in filterDown(), but it's slower for simple things
+      // that need to be fast (e.g., '#someId').
+      var tef = getElementsFunc(qparts[0]);
+      return function(root) {
+        var r = tef(root, []);
+        if (r) { r.nozip = true; }
+        return r;
+      }
+    }
+
+    // otherwise, break it up and return a runner that iterates over the parts
+    // recursively
+    return function(root) {
+      return filterDown(root, qparts);
+    }
+  };
+
+  // NOTES:
+  //  * we can't trust QSA for anything but document-rooted queries, so
+  //    caching is split into DOM query evaluators and QSA query evaluators
+  //  * caching query results is dirty and leak-prone (or, at a minimum,
+  //    prone to unbounded growth). Other toolkits may go this route, but
+  //    they totally destroy their own ability to manage their memory
+  //    footprint. If we implement it, it should only ever be with a fixed
+  //    total element reference # limit and an LRU-style algorithm since JS
+  //    has no weakref support. Caching compiled query evaluators is also
+  //    potentially problematic, but even on large documents the size of the
+  //    query evaluators is often < 100 function objects per evaluator (and
+  //    LRU can be applied if it's ever shown to be an issue).
+  //  * since IE's QSA support is currently only for HTML documents and even
+  //    then only in IE 8's 'standards mode', we have to detect our dispatch
+  //    route at query time and keep 2 separate caches. Ugg.
+
+  var qsa = 'querySelectorAll';
+
+  // some versions of Safari provided QSA, but it was buggy and crash-prone.
+  // We need te detect the right 'internal' webkit version to make this work.
+  var qsaAvail = (
+    !!goog.dom.getDocument()[qsa] &&
+    // see #5832
+    (!goog.userAgent.WEBKIT || goog.userAgent.isVersion('526'))
+  );
+
+  /** @param {boolean=} opt_forceDOM */
+  var getQueryFunc = function(query, opt_forceDOM) {
+
+    if (qsaAvail) {
+      // if we've got a cached variant and we think we can do it, run it!
+      var qsaCached = _queryFuncCacheQSA[query];
+      if (qsaCached && !opt_forceDOM) {
+        return qsaCached;
+      }
+    }
+
+    // else if we've got a DOM cached variant, assume that we already know
+    // all we need to and use it
+    var domCached = _queryFuncCacheDOM[query];
+    if (domCached) {
+      return domCached;
+    }
+
+    // TODO:
+    //    today we're caching DOM and QSA branches separately so we
+    //    recalc useQSA every time. If we had a way to tag root+query
+    //    efficiently, we'd be in good shape to do a global cache.
+
+    var qcz = query.charAt(0);
+    var nospace = (-1 == query.indexOf(' '));
+
+    // byId searches are wicked fast compared to QSA, even when filtering
+    // is required
+    if ((query.indexOf('#') >= 0) && (nospace)) {
+      opt_forceDOM = true;
+    }
+
+    var useQSA = (
+      qsaAvail && (!opt_forceDOM) &&
+      // as per CSS 3, we can't currently start w/ combinator:
+      //    http://www.w3.org/TR/css3-selectors/#w3cselgrammar
+      (specials.indexOf(qcz) == -1) &&
+      // IE's QSA impl sucks on pseudos
+      (!goog.userAgent.IE || (query.indexOf(':') == -1)) &&
+
+      (!(cssCaseBug && (query.indexOf('.') >= 0))) &&
+
+      // FIXME:
+      //    need to tighten up browser rules on ':contains' and '|=' to
+      //    figure out which aren't good
+      (query.indexOf(':contains') == -1) &&
+      (query.indexOf('|=') == -1)
+    );
+
+    // TODO:
+    //    if we've got a descendant query (e.g., '> .thinger' instead of
+    //    just '.thinger') in a QSA-able doc, but are passed a child as a
+    //    root, it should be possible to give the item a synthetic ID and
+    //    trivially rewrite the query to the form '#synid > .thinger' to
+    //    use the QSA branch
+
+
+    if (useQSA) {
+      var tq = (specials.indexOf(query.charAt(query.length - 1)) >= 0) ?
+            (query + ' *') : query;
+      return _queryFuncCacheQSA[query] = function(root) {
+        try {
+          // the QSA system contains an egregious spec bug which
+          // limits us, effectively, to only running QSA queries over
+          // entire documents.  See:
+          //    http://ejohn.org/blog/thoughts-on-queryselectorall/
+          //  despite this, we can also handle QSA runs on simple
+          //  selectors, but we don't want detection to be expensive
+          //  so we're just checking for the presence of a space char
+          //  right now. Not elegant, but it's cheaper than running
+          //  the query parser when we might not need to
+          if (!((9 == root.nodeType) || nospace)) {
+            throw '';
+          }
+          var r = root[qsa](tq);
+          // IE QSA queries may incorrectly include comment nodes, so we throw
+          // the zipping function into 'remove' comments mode instead of the
+          // normal 'skip it' which every other QSA-clued browser enjoys
+          // skip expensive duplication checks and just wrap in a NodeList
+          if (goog.userAgent.IE) {
+            r.commentStrip = true;
+          } else {
+            r.nozip = true;
+          }
+          return r;
+        } catch (e) {
+          // else run the DOM branch on this query, ensuring that we
+          // default that way in the future
+          return getQueryFunc(query, true)(root);
+        }
+      }
+    } else {
+      // DOM branch
+      var parts = query.split(/\s*,\s*/);
+      return _queryFuncCacheDOM[query] = ((parts.length < 2) ?
+        // if not a compound query (e.g., '.foo, .bar'), cache and return a
+        // dispatcher
+        getStepQueryFunc(query) :
+        // if it *is* a complex query, break it up into its
+        // constituent parts and return a dispatcher that will
+        // merge the parts when run
+        function(root) {
+          var pindex = 0, // avoid array alloc for every invocation
+            ret = [],
+            tp;
+          while (tp = parts[pindex++]) {
+            ret = ret.concat(getStepQueryFunc(tp)(root));
+          }
+          return ret;
+        }
+      );
+    }
+  };
+
+  var _zipIdx = 0;
+
+  // NOTE:
+  //    this function is Moo inspired, but our own impl to deal correctly
+  //    with XML in IE
+  var _nodeUID = goog.userAgent.IE ? function(node) {
+    if (caseSensitive) {
+      // XML docs don't have uniqueID on their nodes
+      return node.getAttribute('_uid') ||
+          node.setAttribute('_uid', ++_zipIdx) || _zipIdx;
+
+    } else {
+      return node.uniqueID;
+    }
+  } :
+  function(node) {
+    return (node['_uid'] || (node['_uid'] = ++_zipIdx));
+  };
+
+  // determine if a node in is unique in a 'bag'. In this case we don't want
+  // to flatten a list of unique items, but rather just tell if the item in
+  // question is already in the bag. Normally we'd just use hash lookup to do
+  // this for us but IE's DOM is busted so we can't really count on that. On
+  // the upside, it gives us a built in unique ID function.
+  var _isUnique = function(node, bag) {
+    if (!bag) {
+      return 1;
+    }
+    var id = _nodeUID(node);
+    if (!bag[id]) {
+      return bag[id] = 1;
+    }
+    return 0;
+  };
+
+  // attempt to efficiently determine if an item in a list is a dupe,
+  // returning a list of 'uniques', hopefully in doucment order
+  var _zipIdxName = '_zipIdx';
+  var _zip = function(arr) {
+    if (arr && arr.nozip) {
+      return arr;
+    }
+    var ret = [];
+    if (!arr || !arr.length) {
+      return ret;
+    }
+    if (arr[0]) {
+      ret.push(arr[0]);
+    }
+    if (arr.length < 2) {
+      return ret;
+    }
+
+    _zipIdx++;
+
+    // we have to fork here for IE and XML docs because we can't set
+    // expandos on their nodes (apparently). *sigh*
+    if (goog.userAgent.IE && caseSensitive) {
+      var szidx = _zipIdx + '';
+      arr[0].setAttribute(_zipIdxName, szidx);
+      for (var x = 1, te; te = arr[x]; x++) {
+        if (arr[x].getAttribute(_zipIdxName) != szidx) {
+          ret.push(te);
+        }
+        te.setAttribute(_zipIdxName, szidx);
+      }
+    } else if (goog.userAgent.IE && arr.commentStrip) {
+      try {
+        for (var x = 1, te; te = arr[x]; x++) {
+          if (isElement(te)) {
+            ret.push(te);
+          }
+        }
+      } catch (e) { /* squelch */ }
+    } else {
+      if (arr[0]) {
+        arr[0][_zipIdxName] = _zipIdx;
+      }
+      for (var x = 1, te; te = arr[x]; x++) {
+        if (arr[x][_zipIdxName] != _zipIdx) {
+          ret.push(te);
+        }
+        te[_zipIdxName] = _zipIdx;
+      }
+    }
+    return ret;
+  };
+
+  // the main executor
+  var query = function(query, root) {
+    // NOTE: elementsById is not currently supported
+    // NOTE: ignores xpath-ish queries for now
+
+    //Set list constructor to desired value. This can change
+    //between calls, so always re-assign here.
+
+    if (!query) {
+      return [];
+    }
+
+    if (query.constructor == Array) {
+      return query;
+    }
+
+    if (!goog.isString(query)) {
+      return [query];
+    }
+
+    if (goog.isString(root)) {
+      root = goog.dom.getElement(root);
+      if (!root) {
+        return [];
+      }
+    }
+
+    root = root || goog.dom.getDocument();
+    var od = root.ownerDocument || root.documentElement;
+
+    // throw the big case sensitivity switch
+
+    // NOTE:
+    //    Opera in XHTML mode doesn't detect case-sensitivity correctly
+    //    and it's not clear that there's any way to test for it
+    caseSensitive =
+        root.contentType && root.contentType == 'application/xml' ||
+        goog.userAgent.OPERA &&
+          (root.doctype || od.toString() == '[object XMLDocument]') ||
+        !!od &&
+        (goog.userAgent.IE ? od.xml : (root.xmlVersion || od.xmlVersion));
+
+    // NOTE:
+    //    adding 'true' as the 2nd argument to getQueryFunc is useful for
+    //    testing the DOM branch without worrying about the
+    //    behavior/performance of the QSA branch.
+    var r = getQueryFunc(query)(root);
+
+    // FIXME(slightlyoff):
+    //    need to investigate this branch WRT dojo:#8074 and dojo:#8075
+    if (r && r.nozip) {
+      return r;
+    }
+    return _zip(r); // dojo.NodeList
+  }
+
+  // FIXME: need to add infrastructure for post-filtering pseudos, ala :last
+  query.pseudos = pseudos;
+
+  return query;
+})();
+
+// TODO(user): Please don't export here since it clobbers dead code elimination.
+goog.exportSymbol('goog.dom.query', goog.dom.query);
+goog.exportSymbol('goog.dom.query.pseudos', goog.dom.query.pseudos);