closure 1.2.701 → 1.3.0

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

@@ -1,1537 +0,0 @@
-// 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|Array} 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. Type specification from above.
-   * @param {string|Array} query The query.
-   * @param {(string|Node)=} root The root.
-   * @return { {length: number} } The elements that matched the query.
-   */
-  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 /** @type {!Array} */ (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);