@qelos/aidev 0.10.0 → 1.0.0

package/ui/.output/server/node_modules/jsdom/lib/jsdom/level3/xpath.js

@@ -0,0 +1,1875 @@
+/** Here is yet another implementation of XPath 1.0 in Javascript.
+ *
+ * My goal was to make it relatively compact, but as I fixed all the axis bugs
+ * the axes became more and more complicated. :-(.
+ *
+ * I have not implemented namespaces or case-sensitive axes for XML yet.
+ *
+ * How to test it in Chrome: You can make a Chrome extension that replaces
+ * the WebKit XPath parser with this one. But it takes a bit of effort to
+ * get around isolated world and same-origin restrictions:
+ * manifest.json:
+    {
+      "name": "XPathTest",
+      "version": "0.1",
+      "content_scripts": [{
+        "matches": ["http://localhost/*"],  // or wildcard host
+        "js": ["xpath.js", "injection.js"],
+        "all_frames": true, "run_at": "document_start"
+      }]
+    }
+ * injection.js:
+    // goal: give my xpath object to the website's JS context.
+    var script = document.createElement('script');
+    script.textContent =
+        "document.addEventListener('xpathextend', function(e) {\n" +
+        "  console.log('extending document with xpath...');\n" +
+        "  e.detail(window);" +
+        "});";
+    document.documentElement.appendChild(script);
+    document.documentElement.removeChild(script);
+    var evt = document.createEvent('CustomEvent');
+    evt.initCustomEvent('xpathextend', true, true, this.xpath.extend);
+    document.dispatchEvent(evt);
+ */
+module.exports = core => {
+  var xpath = {};
+
+  // Helper function to deal with the migration of Attr to no longer have a nodeName property despite this codebase
+  // assuming it does.
+  function getNodeName(nodeOrAttr) {
+    return nodeOrAttr.constructor.name === 'Attr' ? nodeOrAttr.name : nodeOrAttr.nodeName;
+  }
+
+  /***************************************************************************
+   *                            Tokenization                                 *
+   ***************************************************************************/
+  /**
+   * The XPath lexer is basically a single regular expression, along with
+   * some helper functions to pop different types.
+   */
+  var Stream = xpath.Stream = function Stream(str) {
+    this.original = this.str = str;
+    this.peeked = null;
+    // TODO: not really needed, but supposedly tokenizer also disambiguates
+    // a * b vs. node test *
+    this.prev = null;  // for debugging
+    this.prevprev = null;
+  }
+  Stream.prototype = {
+    peek: function() {
+      if (this.peeked) return this.peeked;
+      var m = this.re.exec(this.str);
+      if (!m) return null;
+      this.str = this.str.substr(m[0].length);
+      return this.peeked = m[1];
+    },
+    /** Peek 2 tokens ahead. */
+    peek2: function() {
+      this.peek();  // make sure this.peeked is set
+      var m = this.re.exec(this.str);
+      if (!m) return null;
+      return m[1];
+    },
+    pop: function() {
+      var r = this.peek();
+      this.peeked = null;
+      this.prevprev = this.prev;
+      this.prev = r;
+      return r;
+    },
+    trypop: function(tokens) {
+      var tok = this.peek();
+      if (tok === tokens) return this.pop();
+      if (Array.isArray(tokens)) {
+        for (var i = 0; i < tokens.length; ++i) {
+          var t = tokens[i];
+          if (t == tok) return this.pop();;
+        }
+      }
+    },
+    trypopfuncname: function() {
+      var tok = this.peek();
+      if (!this.isQnameRe.test(tok))
+        return null;
+      switch (tok) {
+        case 'comment': case 'text': case 'processing-instruction': case 'node':
+          return null;
+      }
+      if ('(' != this.peek2()) return null;
+      return this.pop();
+    },
+    trypopaxisname: function() {
+      var tok = this.peek();
+      switch (tok) {
+        case 'ancestor': case 'ancestor-or-self': case 'attribute':
+        case 'child': case 'descendant': case 'descendant-or-self':
+        case 'following': case 'following-sibling': case 'namespace':
+        case 'parent': case 'preceding': case 'preceding-sibling': case 'self':
+          if ('::' == this.peek2()) return this.pop();
+      }
+      return null;
+    },
+    trypopnametest: function() {
+      var tok = this.peek();
+      if ('*' === tok || this.startsWithNcNameRe.test(tok)) return this.pop();
+      return null;
+    },
+    trypopliteral: function() {
+      var tok = this.peek();
+      if (null == tok) return null;
+      var first = tok.charAt(0);
+      var last = tok.charAt(tok.length - 1);
+      if ('"' === first && '"' === last ||
+          "'" === first && "'" === last) {
+        this.pop();
+        return tok.substr(1, tok.length - 2) ?? null;
+      }
+      return null;
+    },
+    trypopnumber: function() {
+      var tok = this.peek();
+      if (this.isNumberRe.test(tok)) return parseFloat(this.pop()) ?? null;
+      else return null;
+    },
+    trypopvarref: function() {
+      var tok = this.peek();
+      if (null == tok) return null;
+      if ('$' === tok.charAt(0)) return this.pop().substr(1) ?? null;
+      else return null;
+    },
+    position: function() {
+      return this.original.length - this.str.length;
+    }
+  };
+  (function() {
+    // http://www.w3.org/TR/REC-xml-names/#NT-NCName
+    var nameStartCharsExceptColon =
+        'A-Z_a-z\xc0-\xd6\xd8-\xf6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF' +
+        '\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF' +
+        '\uFDF0-\uFFFD';  // JS doesn't support [#x10000-#xEFFFF]
+    var nameCharExceptColon = nameStartCharsExceptColon +
+        '\\-\\.0-9\xb7\u0300-\u036F\u203F-\u2040';
+    var ncNameChars = '[' + nameStartCharsExceptColon +
+        '][' + nameCharExceptColon + ']*'
+    // http://www.w3.org/TR/REC-xml-names/#NT-QName
+    var qNameChars = ncNameChars + '(?::' + ncNameChars + ')?';
+    var otherChars = '\\.\\.|[\\(\\)\\[\\].@,]|::';  // .. must come before [.]
+    var operatorChars =
+        'and|or|mod|div|' +
+        '//|!=|<=|>=|[*/|+\\-=<>]';  // //, !=, <=, >= before individual ones.
+    var literal = '"[^"]*"|' + "'[^']*'";
+    var numberChars = '[0-9]+(?:\\.[0-9]*)?|\\.[0-9]+';
+    var variableReference = '\\$' + qNameChars;
+    var nameTestChars = '\\*|' + ncNameChars + ':\\*|' + qNameChars;
+    var optionalSpace = '[ \t\r\n]*';  // stricter than regexp \s.
+    var nodeType = 'comment|text|processing-instruction|node';
+    var re = new RegExp(
+        // numberChars before otherChars so that leading-decimal doesn't become .
+        '^' + optionalSpace + '(' + numberChars + '|' + otherChars + '|' +
+        nameTestChars + '|' + operatorChars + '|' + literal + '|' +
+        variableReference + ')'
+        // operatorName | nodeType | functionName | axisName are lumped into
+        // qName for now; we'll check them on pop.
+    );
+    Stream.prototype.re = re;
+    Stream.prototype.startsWithNcNameRe = new RegExp('^' + ncNameChars);
+    Stream.prototype.isQnameRe = new RegExp('^' + qNameChars + '$');
+    Stream.prototype.isNumberRe = new RegExp('^' + numberChars + '$');
+  })();
+
+  /***************************************************************************
+   *                               Parsing                                   *
+   ***************************************************************************/
+  var parse = xpath.parse = function parse(stream, a) {
+    var r = orExpr(stream,a);
+    var x, unparsed = [];
+    while (x = stream.pop()) {
+      unparsed.push(x);
+    }
+    if (unparsed.length)
+      throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                               'Position ' + stream.position() +
+                               ': Unparsed tokens: ' + unparsed.join(' '));
+    return r;
+  }
+
+  /**
+   * binaryL  ::= subExpr
+   *            | binaryL op subExpr
+   * so a op b op c becomes ((a op b) op c)
+   */
+  function binaryL(subExpr, stream, a, ops) {
+    var lhs = subExpr(stream, a);
+    if (lhs == null) return null;
+    var op;
+    while (op = stream.trypop(ops)) {
+      var rhs = subExpr(stream, a);
+      if (rhs == null)
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Expected something after ' + op);
+      lhs = a.node(op, lhs, rhs);
+    }
+    return lhs;
+  }
+  /**
+   * Too bad this is never used. If they made a ** operator (raise to power),
+   ( we would use it.
+   * binaryR  ::= subExpr
+   *            | subExpr op binaryR
+   * so a op b op c becomes (a op (b op c))
+   */
+  function binaryR(subExpr, stream, a, ops) {
+    var lhs = subExpr(stream, a);
+    if (lhs == null) return null;
+    var op = stream.trypop(ops);
+    if (op) {
+      var rhs = binaryR(stream, a);
+      if (rhs == null)
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Expected something after ' + op);
+      return a.node(op, lhs, rhs);
+    } else {
+      return lhs;// TODO
+    }
+  }
+  /** [1] LocationPath::= RelativeLocationPath | AbsoluteLocationPath
+   * e.g. a, a/b, //a/b
+   */
+  function locationPath(stream, a) {
+    return absoluteLocationPath(stream, a) ||
+           relativeLocationPath(null, stream, a);
+  }
+  /** [2] AbsoluteLocationPath::= '/' RelativeLocationPath? | AbbreviatedAbsoluteLocationPath
+   *  [10] AbbreviatedAbsoluteLocationPath::= '//' RelativeLocationPath
+   */
+  function absoluteLocationPath(stream, a) {
+    var op = stream.peek();
+    if ('/' === op || '//' === op) {
+      var lhs = a.node('Root');
+      return relativeLocationPath(lhs, stream, a, true);
+    } else {
+      return null;
+    }
+  }
+  /** [3] RelativeLocationPath::= Step | RelativeLocationPath '/' Step |
+   *                            | AbbreviatedRelativeLocationPath
+   *  [11] AbbreviatedRelativeLocationPath::= RelativeLocationPath '//' Step
+   * e.g. p/a, etc.
+   */
+  function relativeLocationPath(lhs, stream, a, isOnlyRootOk) {
+    if (null == lhs) {
+      lhs = step(stream, a);
+      if (null == lhs) return lhs;
+    }
+    var op;
+    while (op = stream.trypop(['/', '//'])) {
+      if ('//' === op) {
+        lhs = a.node('/', lhs,
+                     a.node('Axis', 'descendant-or-self', 'node', undefined));
+      }
+      var rhs = step(stream, a);
+      if (null == rhs && '/' === op && isOnlyRootOk) return lhs;
+      else isOnlyRootOk = false;
+      if (null == rhs)
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Expected step after ' + op);
+      lhs = a.node('/', lhs, rhs);
+    }
+    return lhs;
+  }
+  /** [4] Step::= AxisSpecifier NodeTest Predicate* | AbbreviatedStep
+   *  [12] AbbreviatedStep::= '.' | '..'
+   * e.g. @href, self::p, p, a[@href], ., ..
+   */
+  function step(stream, a) {
+    var abbrStep = stream.trypop(['.', '..']);
+    if ('.' === abbrStep)  // A location step of . is short for self::node().
+      return a.node('Axis', 'self', 'node');
+    if ('..' === abbrStep)  // A location step of .. is short for parent::node()
+      return a.node('Axis', 'parent', 'node');
+
+    var axis = axisSpecifier(stream, a);
+    var nodeType = nodeTypeTest(stream, a);
+    var nodeName;
+    if (null == nodeType) nodeName = nodeNameTest(stream, a);
+    if (null == axis && null == nodeType && null == nodeName) return null;
+    if (null == nodeType && null == nodeName)
+        throw new XPathException(
+            XPathException.INVALID_EXPRESSION_ERR,
+            'Position ' + stream.position() +
+            ': Expected nodeTest after axisSpecifier ' + axis);
+    if (null == axis) axis = 'child';
+    if (null == nodeType) {
+      // When there's only a node name, then the node type is forced to be the
+      // principal node type of the axis.
+      // see http://www.w3.org/TR/xpath/#dt-principal-node-type
+      if ('attribute' === axis) nodeType = 'attribute';
+      else if ('namespace' === axis) nodeType = 'namespace';
+      else nodeType = 'element';
+    }
+    var lhs = a.node('Axis', axis, nodeType, nodeName);
+    var pred;
+    while (null != (pred = predicate(lhs, stream, a))) {
+      lhs = pred;
+    }
+    return lhs;
+  }
+  /** [5] AxisSpecifier::= AxisName '::' | AbbreviatedAxisSpecifier
+   *  [6] AxisName::= 'ancestor' | 'ancestor-or-self' | 'attribute' | 'child'
+   *                | 'descendant' | 'descendant-or-self' | 'following'
+   *                | 'following-sibling' | 'namespace' | 'parent' |
+   *                | 'preceding' | 'preceding-sibling' | 'self'
+   *  [13] AbbreviatedAxisSpecifier::= '@'?
+   */
+  function axisSpecifier(stream, a) {
+    var attr = stream.trypop('@');
+    if (null != attr) return 'attribute';
+    var axisName = stream.trypopaxisname();
+    if (null != axisName) {
+      var coloncolon = stream.trypop('::');
+      if (null == coloncolon)
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Should not happen. Should be ::.');
+      return axisName;
+    }
+  }
+  /** [7] NodeTest::= NameTest | NodeType '(' ')' | 'processing-instruction' '(' Literal ')'
+   *  [38] NodeType::= 'comment' | 'text' | 'processing-instruction' | 'node'
+   * I've split nodeTypeTest from nodeNameTest for convenience.
+   */
+  function nodeTypeTest(stream, a) {
+    if ('(' !== stream.peek2()) {
+      return null;
+    }
+    var type = stream.trypop(['comment', 'text', 'processing-instruction', 'node']);
+    if (null != type) {
+      if (null == stream.trypop('('))
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Should not happen.');
+      var param = undefined;
+      if (type == 'processing-instruction') {
+        param = stream.trypopliteral();
+      }
+      if (null == stream.trypop(')'))
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Expected close parens.');
+      return type
+    }
+  }
+  function nodeNameTest(stream, a) {
+    var name = stream.trypopnametest();
+    if (name != null) return name;
+    else return null;
+  }
+  /** [8] Predicate::= '[' PredicateExpr ']'
+   *  [9] PredicateExpr::= Expr
+   */
+  function predicate(lhs, stream, a) {
+    if (null == stream.trypop('[')) return null;
+    var expr = orExpr(stream, a);
+    if (null == expr)
+      throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                               'Position ' + stream.position() +
+                               ': Expected expression after [');
+    if (null == stream.trypop(']'))
+      throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                               'Position ' + stream.position() +
+                               ': Expected ] after expression.');
+    return a.node('Predicate', lhs, expr);
+  }
+  /** [14] Expr::= OrExpr
+   */
+  /** [15] PrimaryExpr::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall
+   * e.g. $x,  (3+4),  "hi",  32,  f(x)
+   */
+  function primaryExpr(stream, a) {
+    var x = stream.trypopliteral();
+    if (null == x)
+      x = stream.trypopnumber();
+    if (null != x) {
+      return x;
+    }
+    var varRef = stream.trypopvarref();
+    if (null != varRef) return a.node('VariableReference', varRef);
+    var funCall = functionCall(stream, a);
+    if (null != funCall) {
+      return funCall;
+    }
+    if (stream.trypop('(')) {
+      var e = orExpr(stream, a);
+      if (null == e)
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Expected expression after (.');
+      if (null == stream.trypop(')'))
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Expected ) after expression.');
+      return e;
+    }
+    return null;
+  }
+  /** [16] FunctionCall::= FunctionName '(' ( Argument ( ',' Argument )* )? ')'
+   *  [17] Argument::= Expr
+   */
+  function functionCall(stream, a) {
+    var name = stream.trypopfuncname(stream, a);
+    if (null == name) return null;
+    if (null == stream.trypop('('))
+      throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                               'Position ' + stream.position() +
+                               ': Expected ( ) after function name.');
+    var params = [];
+    var first = true;
+    while (null == stream.trypop(')')) {
+      if (!first && null == stream.trypop(','))
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Expected , between arguments of the function.');
+      first = false;
+      var param = orExpr(stream, a);
+      if (param == null)
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Expected expression as argument of function.');
+      params.push(param);
+    }
+    return a.node('FunctionCall', name, params);
+  }
+
+  /** [18] UnionExpr::= PathExpr | UnionExpr '|' PathExpr
+   */
+  function unionExpr(stream, a) { return binaryL(pathExpr, stream, a, '|'); }
+  /** [19] PathExpr ::= LocationPath
+   *                  | FilterExpr
+   *                  | FilterExpr '/' RelativeLocationPath
+   *                  | FilterExpr '//' RelativeLocationPath
+   * Unlike most other nodes, this one always generates a node because
+   * at this point all reverse nodesets must turn into a forward nodeset
+   */
+  function pathExpr(stream, a) {
+    // We have to do FilterExpr before LocationPath because otherwise
+    // LocationPath will eat up the name from a function call.
+    var filter = filterExpr(stream, a);
+    if (null == filter) {
+      var loc = locationPath(stream, a);
+      if (null == loc) {
+        throw new Error
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': The expression shouldn\'t be empty...');
+      }
+      return a.node('PathExpr', loc);
+    }
+    var rel = relativeLocationPath(filter, stream, a, false);
+    if (filter === rel) return rel;
+    else return a.node('PathExpr', rel);
+  }
+  /** [20] FilterExpr::= PrimaryExpr | FilterExpr Predicate
+   * aka. FilterExpr ::= PrimaryExpr Predicate*
+   */
+  function filterExpr(stream, a) {
+    var primary = primaryExpr(stream, a);
+    if (primary == null) return null;
+    var pred, lhs = primary;
+    while (null != (pred = predicate(lhs, stream, a))) {
+      lhs = pred;
+    }
+    return lhs;
+  }
+
+  /** [21] OrExpr::= AndExpr | OrExpr 'or' AndExpr
+   */
+  function orExpr(stream, a) {
+    var orig = (stream.peeked || '') + stream.str
+    var r = binaryL(andExpr, stream, a, 'or');
+    var now = (stream.peeked || '') + stream.str;
+    return r;
+  }
+  /** [22] AndExpr::= EqualityExpr | AndExpr 'and' EqualityExpr
+   */
+  function andExpr(stream, a) { return binaryL(equalityExpr, stream, a, 'and'); }
+  /** [23] EqualityExpr::= RelationalExpr | EqualityExpr '=' RelationalExpr
+   *                     | EqualityExpr '!=' RelationalExpr
+   */
+  function equalityExpr(stream, a) { return binaryL(relationalExpr, stream, a, ['=','!=']); }
+  /** [24] RelationalExpr::= AdditiveExpr | RelationalExpr '<' AdditiveExpr
+   *                       | RelationalExpr '>' AdditiveExpr
+   *                       | RelationalExpr '<=' AdditiveExpr
+   *                       | RelationalExpr '>=' AdditiveExpr
+   */
+  function relationalExpr(stream, a) { return binaryL(additiveExpr, stream, a, ['<','>','<=','>=']); }
+  /** [25] AdditiveExpr::= MultiplicativeExpr
+   *                     | AdditiveExpr '+' MultiplicativeExpr
+   *                     | AdditiveExpr '-' MultiplicativeExpr
+   */
+  function additiveExpr(stream, a) { return binaryL(multiplicativeExpr, stream, a, ['+','-']); }
+  /** [26] MultiplicativeExpr::= UnaryExpr
+   *                           | MultiplicativeExpr MultiplyOperator UnaryExpr
+   *                           | MultiplicativeExpr 'div' UnaryExpr
+   *                           | MultiplicativeExpr 'mod' UnaryExpr
+   */
+  function multiplicativeExpr(stream, a) { return binaryL(unaryExpr, stream, a, ['*','div','mod']); }
+  /** [27] UnaryExpr::= UnionExpr | '-' UnaryExpr
+   */
+  function unaryExpr(stream, a) {
+    if (stream.trypop('-')) {
+      var e = unaryExpr(stream, a);
+      if (null == e)
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Expected unary expression after -');
+      return a.node('UnaryMinus', e);
+    }
+    else return unionExpr(stream, a);
+  }
+  var astFactory = {
+    node: function() {return Array.prototype.slice.call(arguments);}
+  };
+
+
+  /***************************************************************************
+   *                            Optimizations (TODO)                         *
+   ***************************************************************************/
+  /**
+   * Some things I've been considering:
+   * 1) a//b becomes a/descendant::b if there's no predicate that uses
+   *    position() or last()
+   * 2) axis[pred]: when pred doesn't use position, evaluate it just once per
+   *    node in the node-set rather than once per (node, position, last).
+   * For more optimizations, look up Gecko's optimizer:
+   * http://mxr.mozilla.org/mozilla-central/source/content/xslt/src/xpath/txXPathOptimizer.cpp
+   */
+  // TODO
+  function optimize(ast) {
+  }
+
+  /***************************************************************************
+   *                           Evaluation: axes                              *
+   ***************************************************************************/
+
+  /**
+   * Data types: For string, number, boolean, we just use Javascript types.
+   * Node-sets have the form
+   *    {nodes: [node, ...]}
+   * or {nodes: [node, ...], pos: [[1], [2], ...], lasts: [[1], [2], ...]}
+   *
+   * Most of the time, only the node is used and the position information is
+   * discarded. But if you use a predicate, we need to try every value of
+   * position and last in case the predicate calls position() or last().
+   */
+
+  /**
+   * The NodeMultiSet is a helper class to help generate
+   * {nodes:[], pos:[], lasts:[]} structures. It is useful for the
+   * descendant, descendant-or-self, following-sibling, and
+   * preceding-sibling axes for which we can use a stack to organize things.
+   */
+  function NodeMultiSet(isReverseAxis) {
+    this.nodes = [];
+    this.pos = [];
+    this.lasts = [];
+    this.nextPos = [];
+    this.seriesIndexes = [];  // index within nodes that each series begins.
+    this.isReverseAxis = isReverseAxis;
+    this._pushToNodes = isReverseAxis ? Array.prototype.unshift : Array.prototype.push;
+  }
+  NodeMultiSet.prototype = {
+    pushSeries: function pushSeries() {
+      this.nextPos.push(1);
+      this.seriesIndexes.push(this.nodes.length);
+    },
+    popSeries: function popSeries() {
+      console.assert(0 < this.nextPos.length, this.nextPos);
+      var last = this.nextPos.pop() - 1,
+          indexInPos = this.nextPos.length,
+          seriesBeginIndex = this.seriesIndexes.pop(),
+          seriesEndIndex = this.nodes.length;
+      for (var i = seriesBeginIndex; i < seriesEndIndex; ++i) {
+        console.assert(indexInPos < this.lasts[i].length);
+        console.assert(undefined === this.lasts[i][indexInPos]);
+        this.lasts[i][indexInPos] = last;
+      }
+    },
+    finalize: function() {
+      if (null == this.nextPos) return this;
+      console.assert(0 === this.nextPos.length);
+      var lastsJSON = JSON.stringify(this.lasts);
+      for (var i = 0; i < this.lasts.length; ++i) {
+        for (var j = 0; j < this.lasts[i].length; ++j) {
+          console.assert(null != this.lasts[i][j], i + ',' + j + ':' + lastsJSON);
+        }
+      }
+      this.pushSeries = this.popSeries = this.addNode = function() {
+        throw new Error('Already finalized.');
+      };
+      return this;
+    },
+    addNode: function addNode(node) {
+      console.assert(node);
+      this._pushToNodes.call(this.nodes, node)
+      this._pushToNodes.call(this.pos, this.nextPos.slice());
+      this._pushToNodes.call(this.lasts, new Array(this.nextPos.length));
+      for (var i = 0; i < this.nextPos.length; ++i) this.nextPos[i]++;
+    },
+    simplify: function() {
+      this.finalize();
+      return {nodes:this.nodes, pos:this.pos, lasts:this.lasts};
+    }
+  };
+  function eachContext(nodeMultiSet) {
+    var r = [];
+    for (var i = 0; i < nodeMultiSet.nodes.length; i++) {
+      var node = nodeMultiSet.nodes[i];
+      if (!nodeMultiSet.pos) {
+        r.push({nodes:[node], pos: [[i + 1]], lasts: [[nodeMultiSet.nodes.length]]});
+      } else {
+        for (var j = 0; j < nodeMultiSet.pos[i].length; ++j) {
+          r.push({nodes:[node], pos: [[nodeMultiSet.pos[i][j]]], lasts: [[nodeMultiSet.lasts[i][j]]]});
+        }
+      }
+    }
+    return r;
+  }
+  /** Matcher used in the axes.
+   */
+  function NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase) {
+    this.nodeTypeNum = nodeTypeNum;
+    this.nodeName = nodeName;
+    this.shouldLowerCase = shouldLowerCase;
+    this.nodeNameTest =
+      null == nodeName ? this._alwaysTrue :
+      shouldLowerCase ? this._nodeNameLowerCaseEquals :
+      this._nodeNameEquals;
+  }
+  NodeMatcher.prototype = {
+    matches: function matches(node) {
+      if (0 === this.nodeTypeNum || this._nodeTypeMatches(node)) {
+        return this.nodeNameTest(getNodeName(node));
+      }
+
+      return false;
+    },
+    _nodeTypeMatches(nodeOrAttr) {
+      if (nodeOrAttr.constructor.name === 'Attr' && this.nodeTypeNum === 2) {
+        return true;
+      }
+      return nodeOrAttr.nodeType === this.nodeTypeNum;
+    },
+    _alwaysTrue: function(name) {return true;},
+    _nodeNameEquals: function _nodeNameEquals(name) {
+      return this.nodeName === name;
+    },
+    _nodeNameLowerCaseEquals: function _nodeNameLowerCaseEquals(name) {
+      return this.nodeName === name.toLowerCase();
+    }
+  };
+
+  function followingSiblingHelper(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase, shift, peek, followingNode, andSelf, isReverseAxis) {
+    var matcher = new NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase);
+    var nodeMultiSet = new NodeMultiSet(isReverseAxis);
+    while (0 < nodeList.length) {  // can be if for following, preceding
+      var node = shift.call(nodeList);
+      console.assert(node != null);
+      node = followingNode(node);
+      nodeMultiSet.pushSeries();
+      var numPushed = 1;
+      while (null != node) {
+        if (! andSelf && matcher.matches(node))
+          nodeMultiSet.addNode(node);
+        if (node === peek.call(nodeList)) {
+          shift.call(nodeList);
+          nodeMultiSet.pushSeries();
+          numPushed++;
+        }
+        if (andSelf && matcher.matches(node))
+          nodeMultiSet.addNode(node);
+        node = followingNode(node);
+      }
+      while (0 < numPushed--)
+        nodeMultiSet.popSeries();
+    }
+    return nodeMultiSet;
+  }
+
+  /** Returns the next non-descendant node in document order.
+   * This is the first node in following::node(), if node is the context.
+   */
+  function followingNonDescendantNode(node) {
+    if (node.ownerElement) {
+      if (node.ownerElement.firstChild)
+        return node.ownerElement.firstChild;
+      node = node.ownerElement;
+    }
+    do {
+      if (node.nextSibling) return node.nextSibling;
+    } while (node = node.parentNode);
+    return null;
+  }
+
+  /** Returns the next node in a document-order depth-first search.
+   * See the definition of document order[1]:
+   *   1) element
+   *   2) namespace nodes
+   *   3) attributes
+   *   4) children
+   *   [1]: http://www.w3.org/TR/xpath/#dt-document-order
+   */
+  function followingNode(node) {
+    if (node.ownerElement)  // attributes: following node of element.
+      node = node.ownerElement;
+    if (null != node.firstChild)
+      return node.firstChild;
+    do {
+      if (null != node.nextSibling) {
+        return node.nextSibling;
+      }
+      node = node.parentNode;
+    } while (node);
+    return null;
+  }
+  /** Returns the previous node in document order (excluding attributes
+   * and namespace nodes).
+   */
+  function precedingNode(node) {
+    if (node.ownerElement)
+      return node.ownerElement;
+    if (null != node.previousSibling) {
+      node = node.previousSibling;
+      while (null != node.lastChild) {
+        node = node.lastChild;
+      }
+      return node;
+    }
+    if (null != node.parentNode) {
+      return node.parentNode;
+    }
+    return null;
+  }
+  /** This axis is inefficient if there are many nodes in the nodeList.
+   * But I think it's a pretty useless axis so it's ok. */
+  function followingHelper(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+    var matcher = new NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase);
+    var nodeMultiSet = new NodeMultiSet(false);
+    var cursor = nodeList[0];
+    var unorderedFollowingStarts = [];
+    for (var i = 0; i < nodeList.length; i++) {
+      var node = nodeList[i];
+      var start = followingNonDescendantNode(node);
+      if (start)
+        unorderedFollowingStarts.push(start);
+    }
+    if (0 === unorderedFollowingStarts.length)
+      return {nodes:[]};
+    var pos = [], nextPos = [];
+    var started = 0;
+    while (cursor = followingNode(cursor)) {
+      for (var i = unorderedFollowingStarts.length - 1; i >= 0; i--){
+        if (cursor === unorderedFollowingStarts[i]) {
+          nodeMultiSet.pushSeries();
+          unorderedFollowingStarts.splice(i,i+1);
+          started++;
+        }
+      }
+      if (started && matcher.matches(cursor)) {
+        nodeMultiSet.addNode(cursor);
+      }
+    }
+    console.assert(0 === unorderedFollowingStarts.length);
+    for (var i = 0; i < started; i++)
+      nodeMultiSet.popSeries();
+    return nodeMultiSet.finalize();
+  }
+  function precedingHelper(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+    var matcher = new NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase);
+    var cursor = nodeList.pop();
+    if (null == cursor) return {nodes:{}};
+    var r = {nodes:[], pos:[], lasts:[]};
+    var nextParents = [cursor.parentNode || cursor.ownerElement], nextPos = [1];
+    while (cursor = precedingNode(cursor)) {
+      if (cursor === nodeList[nodeList.length - 1]) {
+        nextParents.push(nodeList.pop());
+        nextPos.push(1);
+      }
+      var matches = matcher.matches(cursor);
+      var pos, someoneUsed = false;
+      if (matches)
+        pos = nextPos.slice();
+
+      for (var i = 0; i < nextParents.length; ++i) {
+        if (cursor === nextParents[i]) {
+          nextParents[i] = cursor.parentNode || cursor.ownerElement;
+          if (matches) {
+            pos[i] = null;
+          }
+        } else {
+          if (matches) {
+            pos[i] = nextPos[i]++;
+            someoneUsed = true;
+          }
+        }
+      }
+      if (someoneUsed) {
+        r.nodes.unshift(cursor);
+        r.pos.unshift(pos);
+      }
+    }
+    for (var i = 0; i < r.pos.length; ++i) {
+      var lasts = [];
+      r.lasts.push(lasts);
+      for (var j = r.pos[i].length - 1; j >= 0; j--) {
+        if (null == r.pos[i][j]) {
+          r.pos[i].splice(j, j+1);
+        } else {
+          lasts.unshift(nextPos[j] - 1);
+        }
+      }
+    }
+    return r;
+  }
+
+  /** node-set, axis -> node-set */
+  function descendantDfs(nodeMultiSet, node, remaining, matcher, andSelf, attrIndices, attrNodes) {
+    while (0 < remaining.length && null != remaining[0].ownerElement) {
+      var attr = remaining.shift();
+      if (andSelf && matcher.matches(attr)) {
+        attrNodes.push(attr);
+        attrIndices.push(nodeMultiSet.nodes.length);
+      }
+    }
+    if (null != node && !andSelf) {
+      if (matcher.matches(node))
+        nodeMultiSet.addNode(node);
+    }
+    var pushed = false;
+    if (null == node) {
+      if (0 === remaining.length) return;
+      node = remaining.shift();
+      nodeMultiSet.pushSeries();
+      pushed = true;
+    } else if (0 < remaining.length && node === remaining[0]) {
+      nodeMultiSet.pushSeries();
+      pushed = true;
+      remaining.shift();
+    }
+    if (andSelf) {
+      if (matcher.matches(node))
+        nodeMultiSet.addNode(node);
+    }
+    // TODO: use optimization. Also try element.getElementsByTagName
+    // var nodeList = 1 === nodeTypeNum && null != node.children ? node.children : node.childNodes;
+    var nodeList = node.childNodes;
+    for (var j = 0; j < nodeList.length; ++j) {
+      var child = nodeList[j];
+      descendantDfs(nodeMultiSet, child, remaining, matcher, andSelf, attrIndices, attrNodes);
+    }
+    if (pushed) {
+      nodeMultiSet.popSeries();
+    }
+  }
+  function descenantHelper(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase, andSelf) {
+    var matcher = new NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase);
+    var nodeMultiSet = new NodeMultiSet(false);
+    var attrIndices = [], attrNodes = [];
+    while (0 < nodeList.length) {
+      // var node = nodeList.shift();
+      descendantDfs(nodeMultiSet, null, nodeList, matcher, andSelf, attrIndices, attrNodes);
+    }
+    nodeMultiSet.finalize();
+    for (var i = attrNodes.length-1; i >= 0; --i) {
+      nodeMultiSet.nodes.splice(attrIndices[i], attrIndices[i], attrNodes[i]);
+      nodeMultiSet.pos.splice(attrIndices[i], attrIndices[i], [1]);
+      nodeMultiSet.lasts.splice(attrIndices[i], attrIndices[i], [1]);
+    }
+    return nodeMultiSet;
+  }
+  /**
+   */
+  function ancestorHelper(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase, andSelf) {
+    var matcher = new NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase);
+    var ancestors = []; // array of non-empty arrays of matching ancestors
+    for (var i = 0; i < nodeList.length; ++i) {
+      var node = nodeList[i];
+      var isFirst = true;
+      var a = [];
+      while (null != node) {
+        if (!isFirst || andSelf) {
+          if (matcher.matches(node))
+            a.push(node);
+        }
+        isFirst = false;
+        node = node.parentNode || node.ownerElement;
+      }
+      if (0 < a.length)
+        ancestors.push(a);
+    }
+    var lasts = [];
+    for (var i = 0; i < ancestors.length; ++i) lasts.push(ancestors[i].length);
+    var nodeMultiSet = new NodeMultiSet(true);
+    var newCtx = {nodes:[], pos:[], lasts:[]};
+    while (0 < ancestors.length) {
+      var pos = [ancestors[0].length];
+      var last = [lasts[0]];
+      var node = ancestors[0].pop();
+      for (var i = ancestors.length - 1; i > 0; --i) {
+        if (node === ancestors[i][ancestors[i].length - 1]) {
+          pos.push(ancestors[i].length);
+          last.push(lasts[i]);
+          ancestors[i].pop();
+          if (0 === ancestors[i].length) {
+            ancestors.splice(i, i+1);
+            lasts.splice(i, i+1);
+          }
+        }
+      }
+      if (0 === ancestors[0].length) {
+        ancestors.shift();
+        lasts.shift();
+      }
+      newCtx.nodes.push(node);
+      newCtx.pos.push(pos);
+      newCtx.lasts.push(last);
+    }
+    return newCtx;
+  }
+  /** Helper function for sortDocumentOrder. Returns a list of indices, from the
+   * node to the root, of positions within parent.
+   * For convenience, the node is the first element of the array.
+   */
+  function addressVector(node) {
+    var r = [node];
+    if (null != node.ownerElement) {
+      node = node.ownerElement;
+      r.push(-1);
+    }
+    while (null != node) {
+      var i = 0;
+      while (null != node.previousSibling) {
+        node = node.previousSibling;
+        i++;
+      }
+      r.push(i);
+      node = node.parentNode
+    }
+    return r;
+  }
+  function addressComparator(a, b) {
+    var minlen = Math.min(a.length - 1, b.length - 1),  // not including [0]=node
+        alen = a.length,
+        blen = b.length;
+    if (a[0] === b[0]) return 0;
+    var c;
+    for (var i = 0; i < minlen; ++i) {
+      c = a[alen - i - 1] - b[blen - i - 1];
+      if (0 !== c)
+        break;
+    }
+    if (null == c || 0 === c) {
+      // All equal until one of the nodes. The longer one is the descendant.
+      c = alen - blen;
+    }
+    if (0 === c)
+      c = getNodeName(a) - getNodeName(b);
+    if (0 === c)
+      c = 1;
+    return c;
+  }
+  var sortUniqDocumentOrder = xpath.sortUniqDocumentOrder = function(nodes) {
+    var a = [];
+    for (var i = 0; i < nodes.length; i++) {
+      var node = nodes[i];
+      var v = addressVector(node);
+      a.push(v);
+    }
+    a.sort(addressComparator);
+    var b = [];
+    for (var i = 0; i < a.length; i++) {
+      if (0 < i && a[i][0] === a[i - 1][0])
+        continue;
+      b.push(a[i][0]);
+    }
+    return b;
+  }
+  /** Sort node multiset. Does not do any de-duping. */
+  function sortNodeMultiSet(nodeMultiSet) {
+    var a = [];
+    for (var i = 0; i < nodeMultiSet.nodes.length; i++) {
+      var v = addressVector(nodeMultiSet.nodes[i]);
+      a.push({v:v, n:nodeMultiSet.nodes[i],
+              p:nodeMultiSet.pos[i], l:nodeMultiSet.lasts[i]});
+    }
+    a.sort(compare);
+    var r = {nodes:[], pos:[], lasts:[]};
+    for (var i = 0; i < a.length; ++i) {
+      r.nodes.push(a[i].n);
+      r.pos.push(a[i].p);
+      r.lasts.push(a[i].l);
+    }
+    function compare(x, y) {
+      return addressComparator(x.v, y.v);
+    }
+    return r;
+  }
+  /** Returns an array containing all the ancestors down to a node.
+   * The array starts with document.
+   */
+  function nodeAndAncestors(node) {
+    var ancestors = [node];
+    var p = node;
+    while (p = p.parentNode || p.ownerElement) {
+      ancestors.unshift(p);
+    }
+    return ancestors;
+  }
+  function compareSiblings(a, b) {
+    if (a === b) return 0;
+    var c = a;
+    while (c = c.previousSibling) {
+      if (c === b)
+        return 1;  // b < a
+    }
+    c = b;
+    while (c = c.previousSibling) {
+      if (c === a)
+        return -1;  // a < b
+    }
+    throw new Error('a and b are not siblings: ' + xpath.stringifyObject(a) + ' vs ' + xpath.stringifyObject(b));
+  }
+  /** The merge in merge-sort.*/
+  function mergeNodeLists(x, y) {
+    var a, b, aanc, banc, r = [];
+    if ('object' !== typeof x)
+      throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                               'Invalid LHS for | operator ' +
+                               '(expected node-set): ' + x);
+    if ('object' !== typeof y)
+      throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                               'Invalid LHS for | operator ' +
+                               '(expected node-set): ' + y);
+    while (true) {
+      if (null == a) {
+        a = x.shift();
+        if (null != a)
+          aanc = addressVector(a);
+      }
+      if (null == b) {
+        b = y.shift();
+        if (null != b)
+          banc = addressVector(b);
+      }
+      if (null == a || null == b) break;
+      var c = addressComparator(aanc, banc);
+      if (c < 0) {
+        r.push(a);
+        a = null;
+        aanc = null;
+      } else if (c > 0) {
+        r.push(b);
+        b = null;
+        banc = null;
+      } else if (getNodeName(a) < getNodeName(b)) {  // attributes
+        r.push(a);
+        a = null;
+        aanc = null;
+      } else if (getNodeName(a) > getNodeName(b)) {  // attributes
+        r.push(b);
+        b = null;
+        banc = null;
+      } else if (a !== b) {
+        // choose b arbitrarily
+        r.push(b);
+        b = null;
+        banc = null;
+      } else {
+        console.assert(a === b, c);
+        // just skip b without pushing it.
+        b = null;
+        banc = null;
+      }
+    }
+    while (a) {
+      r.push(a);
+      a = x.shift();
+    }
+    while (b) {
+      r.push(b);
+      b = y.shift();
+    }
+    return r;
+  }
+  function comparisonHelper(test, x, y, isNumericComparison) {
+    var coersion;
+    if (isNumericComparison)
+      coersion = fn.number;
+    else coersion =
+      'boolean' === typeof x || 'boolean' === typeof y ? fn['boolean'] :
+      'number' === typeof x || 'number' === typeof y ? fn.number :
+      fn.string;
+    if ('object' === typeof x && 'object' === typeof y) {
+      var aMap = {};
+      for (var i = 0; i < x.nodes.length; ++i) {
+        var xi = coersion({nodes:[x.nodes[i]]});
+        for (var j = 0; j < y.nodes.length; ++j) {
+          var yj = coersion({nodes:[y.nodes[j]]});
+          if (test(xi, yj)) return true;
+        }
+      }
+      return false;
+    } else if ('object' === typeof x && x.nodes && x.nodes.length) {
+      for (var i = 0; i < x.nodes.length; ++i) {
+        var xi = coersion({nodes:[x.nodes[i]]}), yc = coersion(y);
+        if (test(xi, yc))
+          return true;
+      }
+      return false;
+    } else if ('object' === typeof y && x.nodes && x.nodes.length) {
+      for (var i = 0; i < x.nodes.length; ++i) {
+        var yi = coersion({nodes:[y.nodes[i]]}), xc = coersion(x);
+        if (test(xc, yi))
+          return true;
+      }
+      return false;
+    } else {
+      var xc = coersion(x), yc = coersion(y);
+      return test(xc, yc);
+    }
+  }
+  var axes = xpath.axes = {
+    'ancestor':
+      function ancestor(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        return ancestorHelper(
+          nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase, false);
+      },
+    'ancestor-or-self':
+      function ancestorOrSelf(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        return ancestorHelper(
+          nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase, true);
+      },
+    'attribute':
+      function attribute(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        // TODO: figure out whether positions should be undefined here.
+        var matcher = new NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase);
+        var nodeMultiSet = new NodeMultiSet(false);
+        if (null != nodeName) {
+          // TODO: with namespace
+          for (var i = 0; i < nodeList.length; ++i) {
+            var node = nodeList[i];
+            if (null == node.getAttributeNode)
+              continue;  // only Element has .getAttributeNode
+            var attr = node.getAttributeNode(nodeName);
+            if (null != attr && matcher.matches(attr)) {
+              nodeMultiSet.pushSeries();
+              nodeMultiSet.addNode(attr);
+              nodeMultiSet.popSeries();
+            }
+          }
+        } else {
+          for (var i = 0; i < nodeList.length; ++i) {
+            var node = nodeList[i];
+            if (null != node.attributes) {
+              nodeMultiSet.pushSeries();
+              for (var j = 0; j < node.attributes.length; j++) {  // all nodes have .attributes
+                var attr = node.attributes[j];
+                if (matcher.matches(attr))  // TODO: I think this check is unnecessary
+                  nodeMultiSet.addNode(attr);
+              }
+              nodeMultiSet.popSeries();
+            }
+          }
+        }
+        return nodeMultiSet.finalize();
+      },
+    'child':
+      function child(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        var matcher = new NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase);
+        var nodeMultiSet = new NodeMultiSet(false);
+        for (var i = 0; i < nodeList.length; ++i) {
+          var n = nodeList[i];
+          if (n.ownerElement)  // skip attribute nodes' text child.
+            continue;
+          if (n.childNodes) {
+            nodeMultiSet.pushSeries();
+            var childList = 1 === nodeTypeNum && null != n.children ?
+                n.children : n.childNodes;
+            for (var j = 0; j < childList.length; ++j) {
+              var child = childList[j];
+              if (matcher.matches(child)) {
+                nodeMultiSet.addNode(child);
+              }
+              // don't have to do de-duping because children have parent,
+              // which are current context.
+            }
+            nodeMultiSet.popSeries();
+          }
+        }
+        nodeMultiSet.finalize();
+        return sortNodeMultiSet(nodeMultiSet);
+      },
+    'descendant':
+      function descenant(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        return descenantHelper(
+          nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase, false);
+      },
+    'descendant-or-self':
+      function descenantOrSelf(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        return descenantHelper(
+          nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase, true);
+      },
+    'following':
+      function following(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        return followingHelper(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase);
+      },
+    'following-sibling':
+      function followingSibling(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        return followingSiblingHelper(
+          nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase,
+          Array.prototype.shift, function() {return this[0];},
+          function(node) {return node.nextSibling;});
+      },
+    'namespace':
+      function namespace(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        // TODO
+      },
+    'parent':
+      function parent(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        var matcher = new NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase);
+        var nodes = [], pos = [];
+        for (var i = 0; i < nodeList.length; ++i) {
+          var parent = nodeList[i].parentNode || nodeList[i].ownerElement;
+          if (null == parent)
+            continue;
+          if (!matcher.matches(parent))
+            continue;
+          if (nodes.length > 0 && parent === nodes[nodes.length-1])
+            continue;
+          nodes.push(parent);
+          pos.push([1]);
+        }
+        return {nodes:nodes, pos:pos, lasts:pos};
+      },
+    'preceding':
+      function preceding(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        return precedingHelper(
+          nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase);
+      },
+    'preceding-sibling':
+      function precedingSibling(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        return followingSiblingHelper(
+          nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase,
+          Array.prototype.pop, function() {return this[this.length-1];},
+          function(node) {return node.previousSibling},
+          false, true);
+      },
+    'self':
+      function self(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        var nodes = [], pos = [];
+        var matcher = new NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase);
+        for (var i = 0; i < nodeList.length; ++i) {
+          if (matcher.matches(nodeList[i])) {
+            nodes.push(nodeList[i]);
+            pos.push([1]);
+          }
+        }
+        return {nodes: nodes, pos: pos, lasts: pos}
+      }
+  };
+
+  /***************************************************************************
+   *                         Evaluation: functions                           *
+   ***************************************************************************/
+  var fn = {
+    'number': function number(optObject) {
+      if ('number' === typeof optObject)
+        return optObject;
+      if ('string' === typeof optObject)
+        return parseFloat(optObject);  // note: parseFloat(' ') -> NaN, unlike +' ' -> 0.
+      if ('boolean' === typeof optObject)
+        return +optObject;
+      return fn.number(fn.string.call(this, optObject));  // for node-sets
+    },
+    'string': function string(optObject) {
+      if (null == optObject)
+        return fn.string(this);
+      if ('string' === typeof optObject || 'boolean' === typeof optObject ||
+          'number' === typeof optObject)
+        return '' + optObject;
+      if (0 == optObject.nodes.length) return '';
+      if (null != optObject.nodes[0].textContent)
+        return optObject.nodes[0].textContent;
+      return optObject.nodes[0].nodeValue;
+    },
+    'boolean': function booleanVal(x) {
+      return 'object' === typeof x ? x.nodes.length > 0 : !!x;
+    },
+    'last': function last() {
+      console.assert(Array.isArray(this.pos));
+      console.assert(Array.isArray(this.lasts));
+      console.assert(1 === this.pos.length);
+      console.assert(1 === this.lasts.length);
+      console.assert(1 === this.lasts[0].length);
+      return this.lasts[0][0];
+    },
+    'position': function position() {
+      console.assert(Array.isArray(this.pos));
+      console.assert(Array.isArray(this.lasts));
+      console.assert(1 === this.pos.length);
+      console.assert(1 === this.lasts.length);
+      console.assert(1 === this.pos[0].length);
+      return this.pos[0][0];
+    },
+    'count': function count(nodeSet) {
+      if ('object' !== typeof nodeSet)
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Function count(node-set) ' +
+                                 'got wrong argument type: ' + nodeSet);
+      return nodeSet.nodes.length;
+    },
+    'id': function id(object) {
+      var r = {nodes: []};
+      var doc = this.nodes[0].ownerDocument || this.nodes[0];
+      console.assert(doc);
+      var ids;
+      if ('object' === typeof object) {
+        // for node-sets, map id over each node value.
+        ids = [];
+        for (var i = 0; i < object.nodes.length; ++i) {
+          var idNode = object.nodes[i];
+          var idsString = fn.string({nodes:[idNode]});
+          var a = idsString.split(/[ \t\r\n]+/g);
+          Array.prototype.push.apply(ids, a);
+        }
+      } else {
+        var idsString = fn.string(object);
+        var a = idsString.split(/[ \t\r\n]+/g);
+        ids = a;
+      }
+      for (var i = 0; i < ids.length; ++i) {
+        var id = ids[i];
+        if (0 === id.length)
+          continue;
+        var node = doc.getElementById(id);
+        if (null != node)
+          r.nodes.push(node);
+      }
+      r.nodes = sortUniqDocumentOrder(r.nodes);
+      return r;
+    },
+    'local-name': function(nodeSet) {
+      if (null == nodeSet)
+        return fn.name(this);
+      if (null == nodeSet.nodes) {
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'argument to name() must be a node-set. got ' + nodeSet);
+      }
+      // TODO: namespaced version
+      return nodeSet.nodes[0].localName;
+    },
+    'namespace-uri': function(nodeSet) {
+      // TODO
+      throw new Error('not implemented yet');
+    },
+    'name': function(nodeSet) {
+      if (null == nodeSet)
+        return fn.name(this);
+      if (null == nodeSet.nodes) {
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'argument to name() must be a node-set. got ' + nodeSet);
+      }
+      return nodeSet.nodes[0].name;
+    },
+    'concat': function concat(x) {
+      var l = [];
+      for (var i = 0; i < arguments.length; ++i) {
+        l.push(fn.string(arguments[i]));
+      }
+      return l.join('');
+    },
+    'starts-with': function startsWith(a, b) {
+      var as = fn.string(a), bs = fn.string(b);
+      return as.substr(0, bs.length) === bs;
+    },
+    'contains': function contains(a, b) {
+      var as = fn.string(a), bs = fn.string(b);
+      var i = as.indexOf(bs);
+      if (-1 === i) return false;
+      return true;
+    },
+    'substring-before': function substringBefore(a, b) {
+      var as = fn.string(a), bs = fn.string(b);
+      var i = as.indexOf(bs);
+      if (-1 === i) return '';
+      return as.substr(0, i);
+    },
+    'substring-after': function substringBefore(a, b) {
+      var as = fn.string(a), bs = fn.string(b);
+      var i = as.indexOf(bs);
+      if (-1 === i) return '';
+      return as.substr(i + bs.length);
+    },
+    'substring': function substring(string, start, optEnd) {
+      if (null == string || null == start) {
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Must be at least 2 arguments to string()');
+      }
+      var sString = fn.string(string),
+          iStart = fn.round(start),
+          iEnd = optEnd == null ? null : fn.round(optEnd);
+      // Note that xpath string positions user 1-based index
+      if (iEnd == null)
+        return sString.substr(iStart - 1);
+      else
+        return sString.substr(iStart - 1, iEnd);
+    },
+    'string-length': function stringLength(optString) {
+      return fn.string.call(this, optString).length;
+    },
+    'normalize-space': function normalizeSpace(optString) {
+      var s = fn.string.call(this, optString);
+      return s.replace(/[ \t\r\n]+/g, ' ').replace(/^ | $/g, '');
+    },
+    'translate': function translate(string, from, to) {
+      var sString = fn.string.call(this, string),
+          sFrom = fn.string(from),
+          sTo = fn.string(to);
+      var eachCharRe = [];
+      var map = {};
+      for (var i = 0; i < sFrom.length; ++i) {
+        var c = sFrom.charAt(i);
+        map[c] = sTo.charAt(i);  // returns '' if beyond length of sTo.
+        // copied from goog.string.regExpEscape in the Closure library.
+        eachCharRe.push(
+          c.replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, '\\$1').
+            replace(/\x08/g, '\\x08'));
+      }
+      var re = new RegExp(eachCharRe.join('|'), 'g');
+      return sString.replace(re, function(c) {return map[c];});
+    },
+    /// Boolean functions
+    'not': function not(x) {
+      var bx = fn['boolean'](x);
+      return !bx;
+    },
+    'true': function trueVal() { return true; },
+    'false': function falseVal() { return false; },
+    // TODO
+    'lang': function lang(string) { throw new Error('Not implemented');},
+    'sum': function sum(optNodeSet) {
+      if (null == optNodeSet) return fn.sum(this);
+      // for node-sets, map id over each node value.
+      var sum = 0;
+      for (var i = 0; i < optNodeSet.nodes.length; ++i) {
+        var node = optNodeSet.nodes[i];
+        var x = fn.number({nodes:[node]});
+        sum += x;
+      }
+      return sum;
+    },
+    'floor': function floor(number) {
+      return Math.floor(fn.number(number));
+    },
+    'ceiling': function ceiling(number) {
+      return Math.ceil(fn.number(number));
+    },
+    'round': function round(number) {
+      return Math.round(fn.number(number));
+    }
+  };
+  /***************************************************************************
+   *                         Evaluation: operators                           *
+   ***************************************************************************/
+  var more = {
+    UnaryMinus: function(x) { return -fn.number(x); },
+    '+': function(x, y) { return fn.number(x) + fn.number(y); },
+    '-': function(x, y) { return fn.number(x) - fn.number(y); },
+    '*': function(x, y) { return fn.number(x) * fn.number(y); },
+    'div': function(x, y) { return fn.number(x) / fn.number(y); },
+    'mod': function(x, y) { return fn.number(x) % fn.number(y); },
+    '<': function(x, y) {
+      return comparisonHelper(function(x, y) { return fn.number(x) < fn.number(y);}, x, y, true);
+    },
+    '<=': function(x, y) {
+      return comparisonHelper(function(x, y) { return fn.number(x) <= fn.number(y);}, x, y, true);
+    },
+    '>':  function(x, y) {
+      return comparisonHelper(function(x, y) { return fn.number(x) > fn.number(y);}, x, y, true);
+    },
+    '>=': function(x, y) {
+      return comparisonHelper(function(x, y) { return fn.number(x) >= fn.number(y);}, x, y, true);
+    },
+    'and': function(x, y) { return fn['boolean'](x) && fn['boolean'](y); },
+    'or': function(x, y) { return fn['boolean'](x) || fn['boolean'](y); },
+    '|': function(x, y) { return {nodes: mergeNodeLists(x.nodes, y.nodes)}; },
+    '=': function(x, y) {
+      // optimization for two node-sets case: avoid n^2 comparisons.
+      if ('object' === typeof x && 'object' === typeof y) {
+        var aMap = {};
+        for (var i = 0; i < x.nodes.length; ++i) {
+          var s = fn.string({nodes:[x.nodes[i]]});
+          aMap[s] = true;
+        }
+        for (var i = 0; i < y.nodes.length; ++i) {
+          var s = fn.string({nodes:[y.nodes[i]]});
+          if (aMap[s]) return true;
+        }
+        return false;
+      } else {
+        return comparisonHelper(function(x, y) {return x === y;}, x, y);
+      }
+    },
+    '!=': function(x, y) {
+      // optimization for two node-sets case: avoid n^2 comparisons.
+      if ('object' === typeof x && 'object' === typeof y) {
+        if (0 === x.nodes.length || 0 === y.nodes.length) return false;
+        var aMap = {};
+        for (var i = 0; i < x.nodes.length; ++i) {
+          var s = fn.string({nodes:[x.nodes[i]]});
+          aMap[s] = true;
+        }
+        for (var i = 0; i < y.nodes.length; ++i) {
+          var s = fn.string({nodes:[y.nodes[i]]});
+          if (!aMap[s]) return true;
+        }
+        return false;
+      } else {
+        return comparisonHelper(function(x, y) {return x !== y;}, x, y);
+      }
+    }
+  };
+  var nodeTypes = xpath.nodeTypes = {
+    'node': 0,
+    'attribute': 2,
+    'comment': 8, // this.doc.COMMENT_NODE,
+    'text': 3, // this.doc.TEXT_NODE,
+    'processing-instruction': 7, // this.doc.PROCESSING_INSTRUCTION_NODE,
+    'element': 1  //this.doc.ELEMENT_NODE
+  };
+  /** For debugging and unit tests: returnjs a stringified version of the
+   * argument. */
+  var stringifyObject = xpath.stringifyObject = function stringifyObject(ctx) {
+    var seenKey = 'seen' + Math.floor(Math.random()*1000000000);
+    return JSON.stringify(helper(ctx));
+
+    function helper(ctx) {
+      if (Array.isArray(ctx)) {
+        return ctx.map(function(x) {return helper(x);});
+      }
+      if ('object' !== typeof ctx) return ctx;
+      if (null == ctx) return ctx;
+    //  if (ctx.toString) return ctx.toString();
+      if (null != ctx.outerHTML) return ctx.outerHTML;
+      if (null != ctx.nodeValue) return ctx.nodeName + '=' + ctx.nodeValue;
+      if (ctx[seenKey]) return '[circular]';
+      ctx[seenKey] = true;
+      var nicer = {};
+      for (var key in ctx) {
+        if (seenKey === key)
+          continue;
+        try {
+          nicer[key] = helper(ctx[key]);
+        } catch (e) {
+          nicer[key] = '[exception: ' + e.message + ']';
+        }
+      }
+      delete ctx[seenKey];
+      return nicer;
+    }
+  }
+  var Evaluator = xpath.Evaluator = function Evaluator(doc) {
+    this.doc = doc;
+  }
+  Evaluator.prototype = {
+    val: function val(ast, ctx) {
+      console.assert(ctx.nodes);
+
+      if ('number' === typeof ast || 'string' === typeof ast) return ast;
+      if (more[ast[0]]) {
+        var evaluatedParams = [];
+        for (var i = 1; i < ast.length; ++i) {
+          evaluatedParams.push(this.val(ast[i], ctx));
+        }
+        var r = more[ast[0]].apply(ctx, evaluatedParams);
+        return r;
+      }
+      switch (ast[0]) {
+        case 'Root': return {nodes: [this.doc]};
+        case 'FunctionCall':
+          var functionName = ast[1], functionParams = ast[2];
+          if (null == fn[functionName])
+            throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                     'Unknown function: ' + functionName);
+          var evaluatedParams = [];
+          for (var i = 0; i < functionParams.length; ++i) {
+            evaluatedParams.push(this.val(functionParams[i], ctx));
+          }
+          var r = fn[functionName].apply(ctx, evaluatedParams);
+          return r;
+        case 'Predicate':
+          var lhs = this.val(ast[1], ctx);
+          var ret = {nodes: []};
+          var contexts = eachContext(lhs);
+          for (var i = 0; i < contexts.length; ++i) {
+            var singleNodeSet = contexts[i];
+            var rhs = this.val(ast[2], singleNodeSet);
+            var success;
+            if ('number' === typeof rhs) {
+              success = rhs === singleNodeSet.pos[0][0];
+            } else {
+              success = fn['boolean'](rhs);
+            }
+            if (success) {
+              var node = singleNodeSet.nodes[0];
+              ret.nodes.push(node);
+              // skip over all the rest of the same node.
+              while (i+1 < contexts.length && node === contexts[i+1].nodes[0]) {
+                i++;
+              }
+            }
+          }
+          return ret;
+        case 'PathExpr':
+          // turn the path into an expressoin; i.e., remove the position
+          // information of the last axis.
+          var x = this.val(ast[1], ctx);
+          // Make the nodeset a forward-direction-only one.
+          if (x.finalize) {  // it is a NodeMultiSet
+            return {nodes: x.nodes};
+          } else {
+            return x;
+          }
+        case '/':
+          // TODO: don't generate '/' nodes, just Axis nodes.
+          var lhs = this.val(ast[1], ctx);
+          console.assert(null != lhs);
+          var r = this.val(ast[2], lhs);
+          console.assert(null != r);
+          return r;
+        case 'Axis':
+          // All the axis tests from Step. We only get AxisSpecifier NodeTest,
+          // not the predicate (which is applied later)
+          var axis = ast[1],
+              nodeType = ast[2],
+              nodeTypeNum = nodeTypes[nodeType],
+              shouldLowerCase = true,  // TODO: give option
+              nodeName = ast[3] && shouldLowerCase ? ast[3].toLowerCase() : ast[3];
+          nodeName = nodeName === '*' ? null : nodeName;
+          if ('object' !== typeof ctx) return {nodes:[], pos:[]};
+          var nodeList = ctx.nodes.slice();  // TODO: is copy needed?
+          var r = axes[axis](nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase);
+          return r;
+      }
+    }
+  };
+  var evaluate = xpath.evaluate = function evaluate(expr, doc, context) {
+    //var astFactory = new AstEvaluatorFactory(doc, context);
+    var stream = new Stream(expr);
+    var ast = parse(stream, astFactory);
+    var val = new Evaluator(doc).val(ast, {nodes: [context]});
+    return val;
+  }
+
+  /***************************************************************************
+   *                           DOM interface                                 *
+   ***************************************************************************/
+  var XPathException = xpath.XPathException = function XPathException(code, message) {
+    var e = new Error(message);
+    e.name = 'XPathException';
+    e.code = code;
+    return e;
+  }
+  XPathException.INVALID_EXPRESSION_ERR = 51;
+  XPathException.TYPE_ERR = 52;
+
+
+  var XPathEvaluator = xpath.XPathEvaluator = function XPathEvaluator() {}
+  XPathEvaluator.prototype = {
+    createExpression: function(expression, resolver) {
+      return new XPathExpression(expression, resolver);
+    },
+    createNSResolver: function(nodeResolver) {
+      // TODO
+    },
+    evaluate: function evaluate(expression, contextNode, resolver, type, result) {
+      var expr = new XPathExpression(expression, resolver);
+      return expr.evaluate(contextNode, type, result);
+    }
+  };
+
+
+  var XPathExpression = xpath.XPathExpression = function XPathExpression(expression, resolver, optDoc) {
+    var stream = new Stream(expression);
+    this._ast = parse(stream, astFactory);
+    this._doc = optDoc;
+  }
+  XPathExpression.prototype = {
+    evaluate: function evaluate(contextNode, type, result) {
+      if (null == contextNode.nodeType)
+        throw new Error('bad argument (expected context node): ' + contextNode);
+      var doc = contextNode.ownerDocument || contextNode;
+      if (null != this._doc && this._doc !== doc) {
+        throw new core.DOMException(
+            core.DOMException.WRONG_DOCUMENT_ERR,
+            'The document must be the same as the context node\'s document.');
+      }
+      var evaluator = new Evaluator(doc);
+      var value = evaluator.val(this._ast, {nodes: [contextNode]});
+      if (XPathResult.NUMBER_TYPE === type)
+        value = fn.number(value);
+      else if (XPathResult.STRING_TYPE === type)
+        value = fn.string(value);
+      else if (XPathResult.BOOLEAN_TYPE === type)
+        value = fn['boolean'](value);
+      else if (XPathResult.ANY_TYPE !== type &&
+               XPathResult.UNORDERED_NODE_ITERATOR_TYPE !== type &&
+               XPathResult.ORDERED_NODE_ITERATOR_TYPE !== type &&
+               XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE !== type &&
+               XPathResult.ORDERED_NODE_SNAPSHOT_TYPE !== type &&
+               XPathResult.ANY_UNORDERED_NODE_TYPE !== type &&
+               XPathResult.FIRST_ORDERED_NODE_TYPE !== type)
+        throw new core.DOMException(
+            core.DOMException.NOT_SUPPORTED_ERR,
+            'You must provide an XPath result type (0=any).');
+      else if (XPathResult.ANY_TYPE !== type &&
+               'object' !== typeof value)
+        throw new XPathException(
+            XPathException.TYPE_ERR,
+            'Value should be a node-set: ' + value);
+      return new XPathResult(doc, value, type);
+    }
+  }
+
+  var XPathResult = xpath.XPathResult = function XPathResult(doc, value, resultType) {
+    this._value = value;
+    this._resultType = resultType;
+    this._i = 0;
+
+    // TODO: we removed mutation events but didn't take care of this. No tests fail, so that's nice, but eventually we
+    // should fix this, preferably by entirely replacing our XPath implementation.
+    // this._invalidated = false;
+    // if (this.resultType === XPathResult.UNORDERED_NODE_ITERATOR_TYPE ||
+    //     this.resultType === XPathResult.ORDERED_NODE_ITERATOR_TYPE) {
+    //   doc.addEventListener('DOMSubtreeModified', invalidate, true);
+    //   var self = this;
+    //   function invalidate() {
+    //     self._invalidated = true;
+    //     doc.removeEventListener('DOMSubtreeModified', invalidate, true);
+    //   }
+    // }
+  }
+  XPathResult.ANY_TYPE = 0;
+  XPathResult.NUMBER_TYPE = 1;
+  XPathResult.STRING_TYPE = 2;
+  XPathResult.BOOLEAN_TYPE = 3;
+  XPathResult.UNORDERED_NODE_ITERATOR_TYPE = 4;
+  XPathResult.ORDERED_NODE_ITERATOR_TYPE = 5;
+  XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE = 6;
+  XPathResult.ORDERED_NODE_SNAPSHOT_TYPE = 7;
+  XPathResult.ANY_UNORDERED_NODE_TYPE = 8;
+  XPathResult.FIRST_ORDERED_NODE_TYPE = 9;
+  var proto = {
+    // XPathResultType
+    get resultType() {
+      if (this._resultType) return this._resultType;
+      switch (typeof this._value) {
+        case 'number': return XPathResult.NUMBER_TYPE;
+        case 'string': return XPathResult.STRING_TYPE;
+        case 'boolean': return XPathResult.BOOLEAN_TYPE;
+        default: return XPathResult.UNORDERED_NODE_ITERATOR_TYPE;
+      }
+    },
+    get numberValue() {
+      if (XPathResult.NUMBER_TYPE !== this.resultType)
+        throw new XPathException(XPathException.TYPE_ERR,
+                                 'You should have asked for a NUMBER_TYPE.');
+      return this._value;
+    },
+    get stringValue() {
+      if (XPathResult.STRING_TYPE !== this.resultType)
+        throw new XPathException(XPathException.TYPE_ERR,
+                                 'You should have asked for a STRING_TYPE.');
+      return this._value;
+    },
+    get booleanValue() {
+      if (XPathResult.BOOLEAN_TYPE !== this.resultType)
+        throw new XPathException(XPathException.TYPE_ERR,
+                                 'You should have asked for a BOOLEAN_TYPE.');
+      return this._value;
+    },
+    get singleNodeValue() {
+      if (XPathResult.ANY_UNORDERED_NODE_TYPE !== this.resultType &&
+          XPathResult.FIRST_ORDERED_NODE_TYPE !== this.resultType)
+        throw new XPathException(
+            XPathException.TYPE_ERR,
+            'You should have asked for a FIRST_ORDERED_NODE_TYPE.');
+      return this._value.nodes[0] || null;
+    },
+    get invalidIteratorState() {
+      if (XPathResult.UNORDERED_NODE_ITERATOR_TYPE !== this.resultType &&
+          XPathResult.ORDERED_NODE_ITERATOR_TYPE !== this.resultType)
+        return false;
+      return !!this._invalidated;
+    },
+    get snapshotLength() {
+      if (XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE !== this.resultType &&
+          XPathResult.ORDERED_NODE_SNAPSHOT_TYPE !== this.resultType)
+        throw new XPathException(
+            XPathException.TYPE_ERR,
+            'You should have asked for a ORDERED_NODE_SNAPSHOT_TYPE.');
+      return this._value.nodes.length;
+    },
+    iterateNext: function iterateNext() {
+      if (XPathResult.UNORDERED_NODE_ITERATOR_TYPE !== this.resultType &&
+          XPathResult.ORDERED_NODE_ITERATOR_TYPE !== this.resultType)
+        throw new XPathException(
+            XPathException.TYPE_ERR,
+            'You should have asked for a ORDERED_NODE_ITERATOR_TYPE.');
+      if (this.invalidIteratorState)
+        throw new core.DOMException(
+            core.DOMException.INVALID_STATE_ERR,
+            'The document has been mutated since the result was returned');
+      return this._value.nodes[this._i++] || null;
+    },
+    snapshotItem: function snapshotItem(index) {
+      if (XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE !== this.resultType &&
+          XPathResult.ORDERED_NODE_SNAPSHOT_TYPE !== this.resultType)
+        throw new XPathException(
+            XPathException.TYPE_ERR,
+            'You should have asked for a ORDERED_NODE_SNAPSHOT_TYPE.');
+      return this._value.nodes[index] || null;
+    }
+  };
+  // so you can access ANY_TYPE etc. from the instances:
+  XPathResult.prototype = Object.create(XPathResult,
+      Object.keys(proto).reduce(function (descriptors, name) {
+        descriptors[name] = Object.getOwnPropertyDescriptor(proto, name);
+        return descriptors;
+      }, {
+        constructor: {
+          value: XPathResult,
+          writable: true,
+          configurable: true
+        }
+      }));
+
+  core.XPathException = XPathException;
+  core.XPathExpression = XPathExpression;
+  core.XPathResult = XPathResult;
+  core.XPathEvaluator = XPathEvaluator;
+
+  core.Document.prototype.createExpression =
+    XPathEvaluator.prototype.createExpression;
+
+  core.Document.prototype.createNSResolver =
+      XPathEvaluator.prototype.createNSResolver;
+
+  core.Document.prototype.evaluate = XPathEvaluator.prototype.evaluate;
+
+  return xpath; // for tests
+};