jsel.js

/**
 * jselement.js - 1.1.6
 *
 * DOM 3 XPath implementation for JavaScript object data.
 *
 * Ali Chamas <musicartscience (at) gmail.com>
 *
 * Revision 1: July 31, 2013
 *   Added mocha tests for browser - single test script shared
 *
 * Based on an adaptation of:
 *
 * xpath.js
 *
 * An XPath 1.0 library for JavaScript.
 *
 * Cameron McCormack <cam (at) mcc.id.au>
 *
 * This work is licensed under the Creative Commons Attribution-ShareAlike
 * License. To view a copy of this license, visit
 *
 *   http://creativecommons.org/licenses/by-sa/2.0/
 *
 * or send a letter to Creative Commons, 559 Nathan Abbott Way, Stanford,
 * California 94305, USA.
 *
 * Revision 20: April 26, 2011
 *   Fixed a typo resulting in FIRST_ORDERED_NODE_TYPE results being wrong,
 *   thanks to <shi_a009 (at) hotmail.com>.
 *
 * Revision 19: November 29, 2005
 *   Nodesets now store their nodes in a height balanced tree, increasing
 *   performance for the common case of selecting nodes in document order,
 *   thanks to S閎astien Cramatte <contact (at) zeninteractif.com>.
 *   AVL tree code adapted from Raimund Neumann <rnova (at) gmx.net>.
 *
 * Revision 18: October 27, 2005
 *   DOM 3 XPath support.  Caveats:
 *     - namespace prefixes aren't resolved in XPathEvaluator.createExpression,
 *       but in XPathExpression.evaluate.
 *     - XPathResult.invalidIteratorState is not implemented.
 *
 * Revision 17: October 25, 2005
 *   Some core XPath function fixes and a patch to avoid crashing certain
 *   versions of MSXML in PathExpr.prototype.getOwnerElement, thanks to
 *   S閎astien Cramatte <contact (at) zeninteractif.com>.
 *
 * Revision 16: September 22, 2005
 *   Workarounds for some IE 5.5 deficiencies.
 *   Fixed problem with prefix node tests on attribute nodes.
 *
 * Revision 15: May 21, 2005
 *   Fixed problem with QName node tests on elements with an xmlns="...".
 *
 * Revision 14: May 19, 2005
 *   Fixed QName node tests on attribute node regression.
 *
 * Revision 13: May 3, 2005
 *   Node tests are case insensitive now if working in an HTML DOM.
 *
 * Revision 12: April 26, 2005
 *   Updated licence.  Slight code changes to enable use of Dean
 *   Edwards' script compression, http://dean.edwards.name/packer/ .
 *
 * Revision 11: April 23, 2005
 *   Fixed bug with 'and' and 'or' operators, fix thanks to
 *   Sandy McArthur <sandy (at) mcarthur.org>.
 *
 * Revision 10: April 15, 2005
 *   Added support for a virtual root node, supposedly helpful for
 *   implementing XForms.  Fixed problem with QName node tests and
 *   the parent axis.
 *
 * Revision 9: March 17, 2005
 *   Namespace resolver tweaked so using the document node as the context
 *   for namespace lookups is equivalent to using the document element.
 *
 * Revision 8: February 13, 2005
 *   Handle implicit declaration of 'xmlns' namespace prefix.
 *   Fixed bug when comparing nodesets.
 *   Instance data can now be associated with a FunctionResolver, and
 *     workaround for MSXML not supporting 'localName()' and 'getElementById',
 *     thanks to Grant Gongaware.
 *   Fix a few problems when the context node is the root node.
 *
 * Revision 7: February 11, 2005
 *   Default namespace resolver fix from Grant Gongaware
 *   <grant (at) gongaware.com>.
 *
 * Revision 6: February 10, 2005
 *   Fixed bug in 'number' function.
 *
 * Revision 5: February 9, 2005
 *   Fixed bug where text nodes not getting converted to string values.
 *
 * Revision 4: January 21, 2005
 *   Bug in 'name' function, fix thanks to Bill Edney.
 *   Fixed incorrect processing of namespace nodes.
 *   Fixed NamespaceResolver to resolve 'xml' namespace.
 *   Implemented union '|' operator.
 *
 * Revision 3: January 14, 2005
 *   Fixed bug with nodeset comparisons, bug lexing < and >.
 *
 * Revision 2: October 26, 2004
 *   QName node test namespace handling fixed.  Few other bug fixes.
 *
 * Revision 1: August 13, 2004
 *   Bug fixes from William J. Edney <bedney (at) technicalpursuit.com>.
 *   Added minimal licence.
 *
 * Initial version: June 14, 2004
 */

// export to module and global
var jsel = (function () {
  /**
   * xpath.js
   */
// XPathParser ///////////////////////////////////////////////////////////////

  XPathParser.prototype = new Object();
  XPathParser.prototype.constructor = XPathParser;
  XPathParser.superclass = Object.prototype;

  function XPathParser() {
    this.init();
  }

  XPathParser.prototype.init = function () {
    this.reduceActions = [];

    this.reduceActions[3] = function (rhs) {
      return new OrOperation(rhs[0], rhs[2]);
    };
    this.reduceActions[5] = function (rhs) {
      return new AndOperation(rhs[0], rhs[2]);
    };
    this.reduceActions[7] = function (rhs) {
      return new EqualsOperation(rhs[0], rhs[2]);
    };
    this.reduceActions[8] = function (rhs) {
      return new NotEqualOperation(rhs[0], rhs[2]);
    };
    this.reduceActions[10] = function (rhs) {
      return new LessThanOperation(rhs[0], rhs[2]);
    };
    this.reduceActions[11] = function (rhs) {
      return new GreaterThanOperation(rhs[0], rhs[2]);
    };
    this.reduceActions[12] = function (rhs) {
      return new LessThanOrEqualOperation(rhs[0], rhs[2]);
    };
    this.reduceActions[13] = function (rhs) {
      return new GreaterThanOrEqualOperation(rhs[0], rhs[2]);
    };
    this.reduceActions[15] = function (rhs) {
      return new PlusOperation(rhs[0], rhs[2]);
    };
    this.reduceActions[16] = function (rhs) {
      return new MinusOperation(rhs[0], rhs[2]);
    };
    this.reduceActions[18] = function (rhs) {
      return new MultiplyOperation(rhs[0], rhs[2]);
    };
    this.reduceActions[19] = function (rhs) {
      return new DivOperation(rhs[0], rhs[2]);
    };
    this.reduceActions[20] = function (rhs) {
      return new ModOperation(rhs[0], rhs[2]);
    };
    this.reduceActions[22] = function (rhs) {
      return new UnaryMinusOperation(rhs[1]);
    };
    this.reduceActions[24] = function (rhs) {
      return new BarOperation(rhs[0], rhs[2]);
    };
    this.reduceActions[25] = function (rhs) {
      return new PathExpr(undefined, undefined, rhs[0]);
    };
    this.reduceActions[27] = function (rhs) {
      rhs[0].locationPath = rhs[2];
      return rhs[0];
    };
    this.reduceActions[28] = function (rhs) {
      rhs[0].locationPath = rhs[2];
      rhs[0].locationPath.steps.unshift(new Step(Step.DESCENDANTORSELF, new NodeTest(NodeTest.NODE, undefined), []));
      return rhs[0];
    };
    this.reduceActions[29] = function (rhs) {
      return new PathExpr(rhs[0], [], undefined);
    };
    this.reduceActions[30] = function (rhs) {
      if (Utilities.instance_of(rhs[0], PathExpr)) {
        if (rhs[0].filterPredicates == undefined) {
          rhs[0].filterPredicates = [];
        }
        rhs[0].filterPredicates.push(rhs[1]);
        return rhs[0];
      } else {
        return new PathExpr(rhs[0], [rhs[1]], undefined);
      }
    };
    this.reduceActions[32] = function (rhs) {
      return rhs[1];
    };
    this.reduceActions[33] = function (rhs) {
      return new XString(rhs[0]);
    };
    this.reduceActions[34] = function (rhs) {
      return new XNumber(rhs[0]);
    };
    this.reduceActions[36] = function (rhs) {
      return new FunctionCall(rhs[0], []);
    };
    this.reduceActions[37] = function (rhs) {
      return new FunctionCall(rhs[0], rhs[2]);
    };
    this.reduceActions[38] = function (rhs) {
      return [rhs[0]];
    };
    this.reduceActions[39] = function (rhs) {
      rhs[2].unshift(rhs[0]);
      return rhs[2];
    };
    this.reduceActions[43] = function (rhs) {
      return new LocationPath(true, []);
    };
    this.reduceActions[44] = function (rhs) {
      rhs[1].absolute = true;
      return rhs[1];
    };
    this.reduceActions[46] = function (rhs) {
      return new LocationPath(false, [rhs[0]]);
    };
    this.reduceActions[47] = function (rhs) {
      rhs[0].steps.push(rhs[2]);
      return rhs[0];
    };
    this.reduceActions[49] = function (rhs) {
      return new Step(rhs[0], rhs[1], []);
    };
    this.reduceActions[50] = function (rhs) {
      return new Step(Step.CHILD, rhs[0], []);
    };
    this.reduceActions[51] = function (rhs) {
      return new Step(rhs[0], rhs[1], rhs[2]);
    };
    this.reduceActions[52] = function (rhs) {
      return new Step(Step.CHILD, rhs[0], rhs[1]);
    };
    this.reduceActions[54] = function (rhs) {
      return [rhs[0]];
    };
    this.reduceActions[55] = function (rhs) {
      rhs[1].unshift(rhs[0]);
      return rhs[1];
    };
    this.reduceActions[56] = function (rhs) {
      if (rhs[0] == "ancestor") {
        return Step.ANCESTOR;
      } else if (rhs[0] == "ancestor-or-self") {
        return Step.ANCESTORORSELF;
      } else if (rhs[0] == "attribute") {
        return Step.ATTRIBUTE;
      } else if (rhs[0] == "child") {
        return Step.CHILD;
      } else if (rhs[0] == "descendant") {
        return Step.DESCENDANT;
      } else if (rhs[0] == "descendant-or-self") {
        return Step.DESCENDANTORSELF;
      } else if (rhs[0] == "following") {
        return Step.FOLLOWING;
      } else if (rhs[0] == "following-sibling") {
        return Step.FOLLOWINGSIBLING;
      } else if (rhs[0] == "namespace") {
        return Step.NAMESPACE;
      } else if (rhs[0] == "parent") {
        return Step.PARENT;
      } else if (rhs[0] == "preceding") {
        return Step.PRECEDING;
      } else if (rhs[0] == "preceding-sibling") {
        return Step.PRECEDINGSIBLING;
      } else if (rhs[0] == "self") {
        return Step.SELF;
      }
      return -1;
    };
    this.reduceActions[57] = function (rhs) {
      return Step.ATTRIBUTE;
    };
    this.reduceActions[59] = function (rhs) {
      if (rhs[0] == "comment") {
        return new NodeTest(NodeTest.COMMENT, undefined);
      } else if (rhs[0] == "text") {
        return new NodeTest(NodeTest.TEXT, undefined);
      } else if (rhs[0] == "processing-instruction") {
        return new NodeTest(NodeTest.PI, undefined);
      } else if (rhs[0] == "node") {
        return new NodeTest(NodeTest.NODE, undefined);
      }
      return new NodeTest(-1, undefined);
    };
    this.reduceActions[60] = function (rhs) {
      return new NodeTest(NodeTest.PI, rhs[2]);
    };
    this.reduceActions[61] = function (rhs) {
      return rhs[1];
    };
    this.reduceActions[63] = function (rhs) {
      rhs[1].absolute = true;
      rhs[1].steps.unshift(new Step(Step.DESCENDANTORSELF, new NodeTest(NodeTest.NODE, undefined), []));
      return rhs[1];
    };
    this.reduceActions[64] = function (rhs) {
      rhs[0].steps.push(new Step(Step.DESCENDANTORSELF, new NodeTest(NodeTest.NODE, undefined), []));
      rhs[0].steps.push(rhs[2]);
      return rhs[0];
    };
    this.reduceActions[65] = function (rhs) {
      return new Step(Step.SELF, new NodeTest(NodeTest.NODE, undefined), []);
    };
    this.reduceActions[66] = function (rhs) {
      return new Step(Step.PARENT, new NodeTest(NodeTest.NODE, undefined), []);
    };
    this.reduceActions[67] = function (rhs) {
      return new VariableReference(rhs[1]);
    };
    this.reduceActions[68] = function (rhs) {
      return new NodeTest(NodeTest.NAMETESTANY, undefined);
    };
    this.reduceActions[69] = function (rhs) {
      var prefix = rhs[0].substring(0, rhs[0].indexOf(":"));
      return new NodeTest(NodeTest.NAMETESTPREFIXANY, prefix);
    };
    this.reduceActions[70] = function (rhs) {
      return new NodeTest(NodeTest.NAMETESTQNAME, rhs[0]);
    };
  };

  XPathParser.actionTable = [
    " s s        sssssssss    s ss  s  ss",
    "                 s                  ",
    "r  rrrrrrrrr         rrrrrrr rr  r  ",
    "                rrrrr               ",
    " s s        sssssssss    s ss  s  ss",
    "rs  rrrrrrrr s  sssssrrrrrr  rrs rs ",
    " s s        sssssssss    s ss  s  ss",
    "                            s       ",
    "                            s       ",
    "r  rrrrrrrrr         rrrrrrr rr rr  ",
    "r  rrrrrrrrr         rrrrrrr rr rr  ",
    "r  rrrrrrrrr         rrrrrrr rr rr  ",
    "r  rrrrrrrrr         rrrrrrr rr rr  ",
    "r  rrrrrrrrr         rrrrrrr rr rr  ",
    "  s                                 ",
    "                            s       ",
    " s           s  sssss          s  s ",
    "r  rrrrrrrrr         rrrrrrr rr  r  ",
    "a                                   ",
    "r       s                    rr  r  ",
    "r      sr                    rr  r  ",
    "r   s  rr            s       rr  r  ",
    "r   rssrr            rss     rr  r  ",
    "r   rrrrr            rrrss   rr  r  ",
    "r   rrrrrsss         rrrrr   rr  r  ",
    "r   rrrrrrrr         rrrrr   rr  r  ",
    "r   rrrrrrrr         rrrrrs  rr  r  ",
    "r   rrrrrrrr         rrrrrr  rr  r  ",
    "r   rrrrrrrr         rrrrrr  rr  r  ",
    "r  srrrrrrrr         rrrrrrs rr sr  ",
    "r  srrrrrrrr         rrrrrrs rr  r  ",
    "r  rrrrrrrrr         rrrrrrr rr rr  ",
    "r  rrrrrrrrr         rrrrrrr rr rr  ",
    "r  rrrrrrrrr         rrrrrrr rr rr  ",
    "r   rrrrrrrr         rrrrrr  rr  r  ",
    "r   rrrrrrrr         rrrrrr  rr  r  ",
    "r  rrrrrrrrr         rrrrrrr rr  r  ",
    "r  rrrrrrrrr         rrrrrrr rr  r  ",
    "                sssss               ",
    "r  rrrrrrrrr         rrrrrrr rr sr  ",
    "r  rrrrrrrrr         rrrrrrr rr  r  ",
    "r  rrrrrrrrr         rrrrrrr rr rr  ",
    "r  rrrrrrrrr         rrrrrrr rr rr  ",
    "                             s      ",
    "r  srrrrrrrr         rrrrrrs rr  r  ",
    "r   rrrrrrrr         rrrrr   rr  r  ",
    "              s                     ",
    "                             s      ",
    "                rrrrr               ",
    " s s        sssssssss    s sss s  ss",
    "r  srrrrrrrr         rrrrrrs rr  r  ",
    " s s        sssssssss    s ss  s  ss",
    " s s        sssssssss    s ss  s  ss",
    " s s        sssssssss    s ss  s  ss",
    " s s        sssssssss    s ss  s  ss",
    " s s        sssssssss    s ss  s  ss",
    " s s        sssssssss    s ss  s  ss",
    " s s        sssssssss    s ss  s  ss",
    " s s        sssssssss    s ss  s  ss",
    " s s        sssssssss    s ss  s  ss",
    " s s        sssssssss    s ss  s  ss",
    " s s        sssssssss    s ss  s  ss",
    " s s        sssssssss    s ss  s  ss",
    " s s        sssssssss    s ss  s  ss",
    " s s        sssssssss      ss  s  ss",
    " s s        sssssssss    s ss  s  ss",
    " s           s  sssss          s  s ",
    " s           s  sssss          s  s ",
    "r  rrrrrrrrr         rrrrrrr rr rr  ",
    " s           s  sssss          s  s ",
    " s           s  sssss          s  s ",
    "r  rrrrrrrrr         rrrrrrr rr sr  ",
    "r  rrrrrrrrr         rrrrrrr rr sr  ",
    "r  rrrrrrrrr         rrrrrrr rr  r  ",
    "r  rrrrrrrrr         rrrrrrr rr rr  ",
    "                             s      ",
    "r  rrrrrrrrr         rrrrrrr rr rr  ",
    "r  rrrrrrrrr         rrrrrrr rr rr  ",
    "                             rr     ",
    "                             s      ",
    "                             rs     ",
    "r      sr                    rr  r  ",
    "r   s  rr            s       rr  r  ",
    "r   rssrr            rss     rr  r  ",
    "r   rssrr            rss     rr  r  ",
    "r   rrrrr            rrrss   rr  r  ",
    "r   rrrrr            rrrss   rr  r  ",
    "r   rrrrr            rrrss   rr  r  ",
    "r   rrrrr            rrrss   rr  r  ",
    "r   rrrrrsss         rrrrr   rr  r  ",
    "r   rrrrrsss         rrrrr   rr  r  ",
    "r   rrrrrrrr         rrrrr   rr  r  ",
    "r   rrrrrrrr         rrrrr   rr  r  ",
    "r   rrrrrrrr         rrrrr   rr  r  ",
    "r   rrrrrrrr         rrrrrr  rr  r  ",
    "                                 r  ",
    "                                 s  ",
    "r  srrrrrrrr         rrrrrrs rr  r  ",
    "r  srrrrrrrr         rrrrrrs rr  r  ",
    "r  rrrrrrrrr         rrrrrrr rr  r  ",
    "r  rrrrrrrrr         rrrrrrr rr  r  ",
    "r  rrrrrrrrr         rrrrrrr rr  r  ",
    "r  rrrrrrrrr         rrrrrrr rr  r  ",
    "r  rrrrrrrrr         rrrrrrr rr rr  ",
    "r  rrrrrrrrr         rrrrrrr rr rr  ",
    " s s        sssssssss    s ss  s  ss",
    "r  rrrrrrrrr         rrrrrrr rr rr  ",
    "                             r      "
  ];

  XPathParser.actionTableNumber = [
    " 1 0        /.-,+*)('    & %$  #  \"!",
    "                 J                  ",
    "a  aaaaaaaaa         aaaaaaa aa  a  ",
    "                YYYYY               ",
    " 1 0        /.-,+*)('    & %$  #  \"!",
    "K1  KKKKKKKK .  +*)('KKKKKK  KK# K\" ",
    " 1 0        /.-,+*)('    & %$  #  \"!",
    "                            N       ",
    "                            O       ",
    "e  eeeeeeeee         eeeeeee ee ee  ",
    "f  fffffffff         fffffff ff ff  ",
    "d  ddddddddd         ddddddd dd dd  ",
    "B  BBBBBBBBB         BBBBBBB BB BB  ",
    "A  AAAAAAAAA         AAAAAAA AA AA  ",
    "  P                                 ",
    "                            Q       ",
    " 1           .  +*)('          #  \" ",
    "b  bbbbbbbbb         bbbbbbb bb  b  ",
    "                                    ",
    "!       S                    !!  !  ",
    "\"      T\"                    \"\"  \"  ",
    "$   V  $$            U       $$  $  ",
    "&   &ZY&&            &XW     &&  &  ",
    ")   )))))            )))\\[   ))  )  ",
    ".   ....._^]         .....   ..  .  ",
    "1   11111111         11111   11  1  ",
    "5   55555555         55555`  55  5  ",
    "7   77777777         777777  77  7  ",
    "9   99999999         999999  99  9  ",
    ":  c::::::::         ::::::b :: a:  ",
    "I  fIIIIIIII         IIIIIIe II  I  ",
    "=  =========         ======= == ==  ",
    "?  ?????????         ??????? ?? ??  ",
    "C  CCCCCCCCC         CCCCCCC CC CC  ",
    "J   JJJJJJJJ         JJJJJJ  JJ  J  ",
    "M   MMMMMMMM         MMMMMM  MM  M  ",
    "N  NNNNNNNNN         NNNNNNN NN  N  ",
    "P  PPPPPPPPP         PPPPPPP PP  P  ",
    "                +*)('               ",
    "R  RRRRRRRRR         RRRRRRR RR aR  ",
    "U  UUUUUUUUU         UUUUUUU UU  U  ",
    "Z  ZZZZZZZZZ         ZZZZZZZ ZZ ZZ  ",
    "c  ccccccccc         ccccccc cc cc  ",
    "                             j      ",
    "L  fLLLLLLLL         LLLLLLe LL  L  ",
    "6   66666666         66666   66  6  ",
    "              k                     ",
    "                             l      ",
    "                XXXXX               ",
    " 1 0        /.-,+*)('    & %$m #  \"!",
    "_  f________         ______e __  _  ",
    " 1 0        /.-,+*)('    & %$  #  \"!",
    " 1 0        /.-,+*)('    & %$  #  \"!",
    " 1 0        /.-,+*)('    & %$  #  \"!",
    " 1 0        /.-,+*)('    & %$  #  \"!",
    " 1 0        /.-,+*)('    & %$  #  \"!",
    " 1 0        /.-,+*)('    & %$  #  \"!",
    " 1 0        /.-,+*)('    & %$  #  \"!",
    " 1 0        /.-,+*)('    & %$  #  \"!",
    " 1 0        /.-,+*)('    & %$  #  \"!",
    " 1 0        /.-,+*)('    & %$  #  \"!",
    " 1 0        /.-,+*)('    & %$  #  \"!",
    " 1 0        /.-,+*)('    & %$  #  \"!",
    " 1 0        /.-,+*)('    & %$  #  \"!",
    " 1 0        /.-,+*)('      %$  #  \"!",
    " 1 0        /.-,+*)('    & %$  #  \"!",
    " 1           .  +*)('          #  \" ",
    " 1           .  +*)('          #  \" ",
    ">  >>>>>>>>>         >>>>>>> >> >>  ",
    " 1           .  +*)('          #  \" ",
    " 1           .  +*)('          #  \" ",
    "Q  QQQQQQQQQ         QQQQQQQ QQ aQ  ",
    "V  VVVVVVVVV         VVVVVVV VV aV  ",
    "T  TTTTTTTTT         TTTTTTT TT  T  ",
    "@  @@@@@@@@@         @@@@@@@ @@ @@  ",
    "                             \x87      ",
    "[  [[[[[[[[[         [[[[[[[ [[ [[  ",
    "D  DDDDDDDDD         DDDDDDD DD DD  ",
    "                             HH     ",
    "                             \x88      ",
    "                             F\x89     ",
    "#      T#                    ##  #  ",
    "%   V  %%            U       %%  %  ",
    "'   'ZY''            'XW     ''  '  ",
    "(   (ZY((            (XW     ((  (  ",
    "+   +++++            +++\\[   ++  +  ",
    "*   *****            ***\\[   **  *  ",
    "-   -----            ---\\[   --  -  ",
    ",   ,,,,,            ,,,\\[   ,,  ,  ",
    "0   00000_^]         00000   00  0  ",
    "/   /////_^]         /////   //  /  ",
    "2   22222222         22222   22  2  ",
    "3   33333333         33333   33  3  ",
    "4   44444444         44444   44  4  ",
    "8   88888888         888888  88  8  ",
    "                                 ^  ",
    "                                 \x8a  ",
    ";  f;;;;;;;;         ;;;;;;e ;;  ;  ",
    "<  f<<<<<<<<         <<<<<<e <<  <  ",
    "O  OOOOOOOOO         OOOOOOO OO  O  ",
    "`  `````````         ``````` ``  `  ",
    "S  SSSSSSSSS         SSSSSSS SS  S  ",
    "W  WWWWWWWWW         WWWWWWW WW  W  ",
    "\\  \\\\\\\\\\\\\\\\\\         \\\\\\\\\\\\\\ \\\\ \\\\  ",
    "E  EEEEEEEEE         EEEEEEE EE EE  ",
    " 1 0        /.-,+*)('    & %$  #  \"!",
    "]  ]]]]]]]]]         ]]]]]]] ]] ]]  ",
    "                             G      "
  ];

  XPathParser.gotoTable = [
    "3456789:;<=>?@ AB  CDEFGH IJ ",
    "                             ",
    "                             ",
    "                             ",
    "L456789:;<=>?@ AB  CDEFGH IJ ",
    "            M        EFGH IJ ",
    "       N;<=>?@ AB  CDEFGH IJ ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "            S        EFGH IJ ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "              e              ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                        h  J ",
    "              i          j   ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "o456789:;<=>?@ ABpqCDEFGH IJ ",
    "                             ",
    "  r6789:;<=>?@ AB  CDEFGH IJ ",
    "   s789:;<=>?@ AB  CDEFGH IJ ",
    "    t89:;<=>?@ AB  CDEFGH IJ ",
    "    u89:;<=>?@ AB  CDEFGH IJ ",
    "     v9:;<=>?@ AB  CDEFGH IJ ",
    "     w9:;<=>?@ AB  CDEFGH IJ ",
    "     x9:;<=>?@ AB  CDEFGH IJ ",
    "     y9:;<=>?@ AB  CDEFGH IJ ",
    "      z:;<=>?@ AB  CDEFGH IJ ",
    "      {:;<=>?@ AB  CDEFGH IJ ",
    "       |;<=>?@ AB  CDEFGH IJ ",
    "       };<=>?@ AB  CDEFGH IJ ",
    "       ~;<=>?@ AB  CDEFGH IJ ",
    "         \x7f=>?@ AB  CDEFGH IJ ",
    "\x80456789:;<=>?@ AB  CDEFGH IJ\x81",
    "            \x82        EFGH IJ ",
    "            \x83        EFGH IJ ",
    "                             ",
    "                     \x84 GH IJ ",
    "                     \x85 GH IJ ",
    "              i          \x86   ",
    "              i          \x87   ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "                             ",
    "o456789:;<=>?@ AB\x8cqCDEFGH IJ ",
    "                             ",
    "                             "
  ];

  XPathParser.productions = [
    [1, 1, 2],
    [2, 1, 3],
    [3, 1, 4],
    [3, 3, 3, -9, 4],
    [4, 1, 5],
    [4, 3, 4, -8, 5],
    [5, 1, 6],
    [5, 3, 5, -22, 6],
    [5, 3, 5, -5, 6],
    [6, 1, 7],
    [6, 3, 6, -23, 7],
    [6, 3, 6, -24, 7],
    [6, 3, 6, -6, 7],
    [6, 3, 6, -7, 7],
    [7, 1, 8],
    [7, 3, 7, -25, 8],
    [7, 3, 7, -26, 8],
    [8, 1, 9],
    [8, 3, 8, -12, 9],
    [8, 3, 8, -11, 9],
    [8, 3, 8, -10, 9],
    [9, 1, 10],
    [9, 2, -26, 9],
    [10, 1, 11],
    [10, 3, 10, -27, 11],
    [11, 1, 12],
    [11, 1, 13],
    [11, 3, 13, -28, 14],
    [11, 3, 13, -4, 14],
    [13, 1, 15],
    [13, 2, 13, 16],
    [15, 1, 17],
    [15, 3, -29, 2, -30],
    [15, 1, -15],
    [15, 1, -16],
    [15, 1, 18],
    [18, 3, -13, -29, -30],
    [18, 4, -13, -29, 19, -30],
    [19, 1, 20],
    [19, 3, 20, -31, 19],
    [20, 1, 2],
    [12, 1, 14],
    [12, 1, 21],
    [21, 1, -28],
    [21, 2, -28, 14],
    [21, 1, 22],
    [14, 1, 23],
    [14, 3, 14, -28, 23],
    [14, 1, 24],
    [23, 2, 25, 26],
    [23, 1, 26],
    [23, 3, 25, 26, 27],
    [23, 2, 26, 27],
    [23, 1, 28],
    [27, 1, 16],
    [27, 2, 16, 27],
    [25, 2, -14, -3],
    [25, 1, -32],
    [26, 1, 29],
    [26, 3, -20, -29, -30],
    [26, 4, -21, -29, -15, -30],
    [16, 3, -33, 30, -34],
    [30, 1, 2],
    [22, 2, -4, 14],
    [24, 3, 14, -4, 23],
    [28, 1, -35],
    [28, 1, -2],
    [17, 2, -36, -18],
    [29, 1, -17],
    [29, 1, -19],
    [29, 1, -18]
  ];

  XPathParser.DOUBLEDOT = 2;
  XPathParser.DOUBLECOLON = 3;
  XPathParser.DOUBLESLASH = 4;
  XPathParser.NOTEQUAL = 5;
  XPathParser.LESSTHANOREQUAL = 6;
  XPathParser.GREATERTHANOREQUAL = 7;
  XPathParser.AND = 8;
  XPathParser.OR = 9;
  XPathParser.MOD = 10;
  XPathParser.DIV = 11;
  XPathParser.MULTIPLYOPERATOR = 12;
  XPathParser.FUNCTIONNAME = 13;
  XPathParser.AXISNAME = 14;
  XPathParser.LITERAL = 15;
  XPathParser.NUMBER = 16;
  XPathParser.ASTERISKNAMETEST = 17;
  XPathParser.QNAME = 18;
  XPathParser.NCNAMECOLONASTERISK = 19;
  XPathParser.NODETYPE = 20;
  XPathParser.PROCESSINGINSTRUCTIONWITHLITERAL = 21;
  XPathParser.EQUALS = 22;
  XPathParser.LESSTHAN = 23;
  XPathParser.GREATERTHAN = 24;
  XPathParser.PLUS = 25;
  XPathParser.MINUS = 26;
  XPathParser.BAR = 27;
  XPathParser.SLASH = 28;
  XPathParser.LEFTPARENTHESIS = 29;
  XPathParser.RIGHTPARENTHESIS = 30;
  XPathParser.COMMA = 31;
  XPathParser.AT = 32;
  XPathParser.LEFTBRACKET = 33;
  XPathParser.RIGHTBRACKET = 34;
  XPathParser.DOT = 35;
  XPathParser.DOLLAR = 36;

  XPathParser.prototype.tokenize = function (s1) {
    var types = [];
    var values = [];
    var s = s1 + '\0';

    var pos = 0;
    var c = s.charAt(pos++);
    while (1) {
      while (c == ' ' || c == '\t' || c == '\r' || c == '\n') {
        c = s.charAt(pos++);
      }
      if (c == '\0' || pos >= s.length) {
        break;
      }

      if (c == '(') {
        types.push(XPathParser.LEFTPARENTHESIS);
        values.push(c);
        c = s.charAt(pos++);
        continue;
      }
      if (c == ')') {
        types.push(XPathParser.RIGHTPARENTHESIS);
        values.push(c);
        c = s.charAt(pos++);
        continue;
      }
      if (c == '[') {
        types.push(XPathParser.LEFTBRACKET);
        values.push(c);
        c = s.charAt(pos++);
        continue;
      }
      if (c == ']') {
        types.push(XPathParser.RIGHTBRACKET);
        values.push(c);
        c = s.charAt(pos++);
        continue;
      }
      if (c == '@') {
        types.push(XPathParser.AT);
        values.push(c);
        c = s.charAt(pos++);
        continue;
      }
      if (c == ',') {
        types.push(XPathParser.COMMA);
        values.push(c);
        c = s.charAt(pos++);
        continue;
      }
      if (c == '|') {
        types.push(XPathParser.BAR);
        values.push(c);
        c = s.charAt(pos++);
        continue;
      }
      if (c == '+') {
        types.push(XPathParser.PLUS);
        values.push(c);
        c = s.charAt(pos++);
        continue;
      }
      if (c == '-') {
        types.push(XPathParser.MINUS);
        values.push(c);
        c = s.charAt(pos++);
        continue;
      }
      if (c == '=') {
        types.push(XPathParser.EQUALS);
        values.push(c);
        c = s.charAt(pos++);
        continue;
      }
      if (c == '$') {
        types.push(XPathParser.DOLLAR);
        values.push(c);
        c = s.charAt(pos++);
        continue;
      }

      if (c == '.') {
        c = s.charAt(pos++);
        if (c == '.') {
          types.push(XPathParser.DOUBLEDOT);
          values.push("..");
          c = s.charAt(pos++);
          continue;
        }
        if (c >= '0' && c <= '9') {
          var number = "." + c;
          c = s.charAt(pos++);
          while (c >= '0' && c <= '9') {
            number += c;
            c = s.charAt(pos++);
          }
          types.push(XPathParser.NUMBER);
          values.push(number);
          continue;
        }
        types.push(XPathParser.DOT);
        values.push('.');
        continue;
      }

      if (c == '\'' || c == '"') {
        var delimiter = c;
        var literal = "";
        while ((c = s.charAt(pos++)) != delimiter) {
          literal += c;
        }
        types.push(XPathParser.LITERAL);
        values.push(literal);
        c = s.charAt(pos++);
        continue;
      }

      if (c >= '0' && c <= '9') {
        var number = c;
        c = s.charAt(pos++);
        while (c >= '0' && c <= '9') {
          number += c;
          c = s.charAt(pos++);
        }
        if (c == '.') {
          if (s.charAt(pos) >= '0' && s.charAt(pos) <= '9') {
            number += c;
            number += s.charAt(pos++);
            c = s.charAt(pos++);
            while (c >= '0' && c <= '9') {
              number += c;
              c = s.charAt(pos++);
            }
          }
        }
        types.push(XPathParser.NUMBER);
        values.push(number);
        continue;
      }

      if (c == '*') {
        if (types.length > 0) {
          var last = types[types.length - 1];
          if (last != XPathParser.AT
            && last != XPathParser.DOUBLECOLON
            && last != XPathParser.LEFTPARENTHESIS
            && last != XPathParser.LEFTBRACKET
            && last != XPathParser.AND
            && last != XPathParser.OR
            && last != XPathParser.MOD
            && last != XPathParser.DIV
            && last != XPathParser.MULTIPLYOPERATOR
            && last != XPathParser.SLASH
            && last != XPathParser.DOUBLESLASH
            && last != XPathParser.BAR
            && last != XPathParser.PLUS
            && last != XPathParser.MINUS
            && last != XPathParser.EQUALS
            && last != XPathParser.NOTEQUAL
            && last != XPathParser.LESSTHAN
            && last != XPathParser.LESSTHANOREQUAL
            && last != XPathParser.GREATERTHAN
            && last != XPathParser.GREATERTHANOREQUAL) {
            types.push(XPathParser.MULTIPLYOPERATOR);
            values.push(c);
            c = s.charAt(pos++);
            continue;
          }
        }
        types.push(XPathParser.ASTERISKNAMETEST);
        values.push(c);
        c = s.charAt(pos++);
        continue;
      }

      if (c == ':') {
        if (s.charAt(pos) == ':') {
          types.push(XPathParser.DOUBLECOLON);
          values.push("::");
          pos++;
          c = s.charAt(pos++);
          continue;
        }
      }

      if (c == '/') {
        c = s.charAt(pos++);
        if (c == '/') {
          types.push(XPathParser.DOUBLESLASH);
          values.push("//");
          c = s.charAt(pos++);
          continue;
        }
        types.push(XPathParser.SLASH);
        values.push('/');
        continue;
      }

      if (c == '!') {
        if (s.charAt(pos) == '=') {
          types.push(XPathParser.NOTEQUAL);
          values.push("!=");
          pos++;
          c = s.charAt(pos++);
          continue;
        }
      }

      if (c == '<') {
        if (s.charAt(pos) == '=') {
          types.push(XPathParser.LESSTHANOREQUAL);
          values.push("<=");
          pos++;
          c = s.charAt(pos++);
          continue;
        }
        types.push(XPathParser.LESSTHAN);
        values.push('<');
        c = s.charAt(pos++);
        continue;
      }

      if (c == '>') {
        if (s.charAt(pos) == '=') {
          types.push(XPathParser.GREATERTHANOREQUAL);
          values.push(">=");
          pos++;
          c = s.charAt(pos++);
          continue;
        }
        types.push(XPathParser.GREATERTHAN);
        values.push('>');
        c = s.charAt(pos++);
        continue;
      }

      if (c == '_' || Utilities.isLetter(c.charCodeAt(0))) {
        var name = c;
        c = s.charAt(pos++);
        while (Utilities.isNCNameChar(c.charCodeAt(0))) {
          name += c;
          c = s.charAt(pos++);
        }
        if (types.length > 0) {
          var last = types[types.length - 1];
          if (last != XPathParser.AT
            && last != XPathParser.DOUBLECOLON
            && last != XPathParser.LEFTPARENTHESIS
            && last != XPathParser.LEFTBRACKET
            && last != XPathParser.AND
            && last != XPathParser.OR
            && last != XPathParser.MOD
            && last != XPathParser.DIV
            && last != XPathParser.MULTIPLYOPERATOR
            && last != XPathParser.SLASH
            && last != XPathParser.DOUBLESLASH
            && last != XPathParser.BAR
            && last != XPathParser.PLUS
            && last != XPathParser.MINUS
            && last != XPathParser.EQUALS
            && last != XPathParser.NOTEQUAL
            && last != XPathParser.LESSTHAN
            && last != XPathParser.LESSTHANOREQUAL
            && last != XPathParser.GREATERTHAN
            && last != XPathParser.GREATERTHANOREQUAL) {
            if (name == "and") {
              types.push(XPathParser.AND);
              values.push(name);
              continue;
            }
            if (name == "or") {
              types.push(XPathParser.OR);
              values.push(name);
              continue;
            }
            if (name == "mod") {
              types.push(XPathParser.MOD);
              values.push(name);
              continue;
            }
            if (name == "div") {
              types.push(XPathParser.DIV);
              values.push(name);
              continue;
            }
          }
        }
        if (c == ':') {
          if (s.charAt(pos) == '*') {
            types.push(XPathParser.NCNAMECOLONASTERISK);
            values.push(name + ":*");
            pos++;
            c = s.charAt(pos++);
            continue;
          }
          if (s.charAt(pos) == '_' || Utilities.isLetter(s.charCodeAt(pos))) {
            name += ':';
            c = s.charAt(pos++);
            while (Utilities.isNCNameChar(c.charCodeAt(0))) {
              name += c;
              c = s.charAt(pos++);
            }
            if (c == '(') {
              types.push(XPathParser.FUNCTIONNAME);
              values.push(name);
              continue;
            }
            types.push(XPathParser.QNAME);
            values.push(name);
            continue;
          }
          if (s.charAt(pos) == ':') {
            types.push(XPathParser.AXISNAME);
            values.push(name);
            continue;
          }
        }
        if (c == '(') {
          if (name == "comment" || name == "text" || name == "node") {
            types.push(XPathParser.NODETYPE);
            values.push(name);
            continue;
          }
          if (name == "processing-instruction") {
            if (s.charAt(pos) == ')') {
              types.push(XPathParser.NODETYPE);
            } else {
              types.push(XPathParser.PROCESSINGINSTRUCTIONWITHLITERAL);
            }
            values.push(name);
            continue;
          }
          types.push(XPathParser.FUNCTIONNAME);
          values.push(name);
          continue;
        }
        types.push(XPathParser.QNAME);
        values.push(name);
        continue;
      }

      throw new Error("Unexpected character " + c);
    }
    types.push(1);
    values.push("[EOF]");
    return [types, values];
  };

  XPathParser.SHIFT = 's';
  XPathParser.REDUCE = 'r';
  XPathParser.ACCEPT = 'a';

  XPathParser.prototype.parse = function (s) {
    var types;
    var values;
    var res = this.tokenize(s);
    if (res == undefined) {
      return undefined;
    }
    types = res[0];
    values = res[1];
    var tokenPos = 0;
    var state = [];
    var tokenType = [];
    var tokenValue = [];
    var s;
    var a;
    var t;

    state.push(0);
    tokenType.push(1);
    tokenValue.push("_S");

    a = types[tokenPos];
    t = values[tokenPos++];
    while (1) {
      s = state[state.length - 1];
      switch (XPathParser.actionTable[s].charAt(a - 1)) {
        case XPathParser.SHIFT:
          tokenType.push(-a);
          tokenValue.push(t);
          state.push(XPathParser.actionTableNumber[s].charCodeAt(a - 1) - 32);
          a = types[tokenPos];
          t = values[tokenPos++];
          break;
        case XPathParser.REDUCE:
          var num = XPathParser.productions[XPathParser.actionTableNumber[s].charCodeAt(a - 1) - 32][1];
          var rhs = [];
          for (var i = 0; i < num; i++) {
            tokenType.pop();
            rhs.unshift(tokenValue.pop());
            state.pop();
          }
          var s_ = state[state.length - 1];
          tokenType.push(XPathParser.productions[XPathParser.actionTableNumber[s].charCodeAt(a - 1) - 32][0]);
          if (this.reduceActions[XPathParser.actionTableNumber[s].charCodeAt(a - 1) - 32] == undefined) {
            tokenValue.push(rhs[0]);
          } else {
            tokenValue.push(this.reduceActions[XPathParser.actionTableNumber[s].charCodeAt(a - 1) - 32](rhs));
          }
          state.push(XPathParser.gotoTable[s_].charCodeAt(XPathParser.productions[XPathParser.actionTableNumber[s].charCodeAt(a - 1) - 32][0] - 2) - 33);
          break;
        case XPathParser.ACCEPT:
          return new XPath(tokenValue.pop());
        default:
          throw new Error("XPath parse error");
      }
    }
  };

// XPath /////////////////////////////////////////////////////////////////////

  XPath.prototype = new Object();
  XPath.prototype.constructor = XPath;
  XPath.superclass = Object.prototype;

  function XPath(e) {
    this.expression = e;
  }

  XPath.prototype.toString = function () {
    return this.expression.toString();
  };

  XPath.prototype.evaluate = function (context) {
    context.contextNode = context.expressionContextNode;
    context.contextSize = 1;
    context.contextPosition = 1;
    context.caseInsensitive = true;
    return this.expression.evaluate(context);
  };

  XPath.XML_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace";
  XPath.XMLNS_NAMESPACE_URI = "http://www.w3.org/2000/xmlns/";

// Expression ////////////////////////////////////////////////////////////////

  Expression.prototype = new Object();
  Expression.prototype.constructor = Expression;
  Expression.superclass = Object.prototype;

  function Expression() {
  }

  Expression.prototype.init = function () {
  };

  Expression.prototype.toString = function () {
    return "<Expression>";
  };

  Expression.prototype.evaluate = function (c) {
    throw new Error("Could not evaluate expression.");
  };

// UnaryOperation ////////////////////////////////////////////////////////////

  UnaryOperation.prototype = new Expression();
  UnaryOperation.prototype.constructor = UnaryOperation;
  UnaryOperation.superclass = Expression.prototype;

  function UnaryOperation(rhs) {
    if (arguments.length > 0) {
      this.init(rhs);
    }
  }

  UnaryOperation.prototype.init = function (rhs) {
    this.rhs = rhs;
  };

// UnaryMinusOperation ///////////////////////////////////////////////////////

  UnaryMinusOperation.prototype = new UnaryOperation();
  UnaryMinusOperation.prototype.constructor = UnaryMinusOperation;
  UnaryMinusOperation.superclass = UnaryOperation.prototype;

  function UnaryMinusOperation(rhs) {
    if (arguments.length > 0) {
      this.init(rhs);
    }
  }

  UnaryMinusOperation.prototype.init = function (rhs) {
    UnaryMinusOperation.superclass.init.call(this, rhs);
  };

  UnaryMinusOperation.prototype.evaluate = function (c) {
    return this.rhs.evaluate(c).number().negate();
  };

  UnaryMinusOperation.prototype.toString = function () {
    return "-" + this.rhs.toString();
  };

// BinaryOperation ///////////////////////////////////////////////////////////

  BinaryOperation.prototype = new Expression();
  BinaryOperation.prototype.constructor = BinaryOperation;
  BinaryOperation.superclass = Expression.prototype;

  function BinaryOperation(lhs, rhs) {
    if (arguments.length > 0) {
      this.init(lhs, rhs);
    }
  }

  BinaryOperation.prototype.init = function (lhs, rhs) {
    this.lhs = lhs;
    this.rhs = rhs;
  };

// OrOperation ///////////////////////////////////////////////////////////////

  OrOperation.prototype = new BinaryOperation();
  OrOperation.prototype.constructor = OrOperation;
  OrOperation.superclass = BinaryOperation.prototype;

  function OrOperation(lhs, rhs) {
    if (arguments.length > 0) {
      this.init(lhs, rhs);
    }
  }

  OrOperation.prototype.init = function (lhs, rhs) {
    OrOperation.superclass.init.call(this, lhs, rhs);
  };

  OrOperation.prototype.toString = function () {
    return "(" + this.lhs.toString() + " or " + this.rhs.toString() + ")";
  };

  OrOperation.prototype.evaluate = function (c) {
    var b = this.lhs.evaluate(c).bool();
    if (b.booleanValue()) {
      return b;
    }
    return this.rhs.evaluate(c).bool();
  };

// AndOperation //////////////////////////////////////////////////////////////

  AndOperation.prototype = new BinaryOperation();
  AndOperation.prototype.constructor = AndOperation;
  AndOperation.superclass = BinaryOperation.prototype;

  function AndOperation(lhs, rhs) {
    if (arguments.length > 0) {
      this.init(lhs, rhs);
    }
  }

  AndOperation.prototype.init = function (lhs, rhs) {
    AndOperation.superclass.init.call(this, lhs, rhs);
  };

  AndOperation.prototype.toString = function () {
    return "(" + this.lhs.toString() + " and " + this.rhs.toString() + ")";
  };

  AndOperation.prototype.evaluate = function (c) {
    var b = this.lhs.evaluate(c).bool();
    if (!b.booleanValue()) {
      return b;
    }
    return this.rhs.evaluate(c).bool();
  };

// EqualsOperation ///////////////////////////////////////////////////////////

  EqualsOperation.prototype = new BinaryOperation();
  EqualsOperation.prototype.constructor = EqualsOperation;
  EqualsOperation.superclass = BinaryOperation.prototype;

  function EqualsOperation(lhs, rhs) {
    if (arguments.length > 0) {
      this.init(lhs, rhs);
    }
  }

  EqualsOperation.prototype.init = function (lhs, rhs) {
    EqualsOperation.superclass.init.call(this, lhs, rhs);
  };

  EqualsOperation.prototype.toString = function () {
    return "(" + this.lhs.toString() + " = " + this.rhs.toString() + ")";
  };

  EqualsOperation.prototype.evaluate = function (c) {
    return this.lhs.evaluate(c).equals(this.rhs.evaluate(c));
  };

// NotEqualOperation /////////////////////////////////////////////////////////

  NotEqualOperation.prototype = new BinaryOperation();
  NotEqualOperation.prototype.constructor = NotEqualOperation;
  NotEqualOperation.superclass = BinaryOperation.prototype;

  function NotEqualOperation(lhs, rhs) {
    if (arguments.length > 0) {
      this.init(lhs, rhs);
    }
  }

  NotEqualOperation.prototype.init = function (lhs, rhs) {
    NotEqualOperation.superclass.init.call(this, lhs, rhs);
  };

  NotEqualOperation.prototype.toString = function () {
    return "(" + this.lhs.toString() + " != " + this.rhs.toString() + ")";
  };

  NotEqualOperation.prototype.evaluate = function (c) {
    return this.lhs.evaluate(c).notequal(this.rhs.evaluate(c));
  };

// LessThanOperation /////////////////////////////////////////////////////////

  LessThanOperation.prototype = new BinaryOperation();
  LessThanOperation.prototype.constructor = LessThanOperation;
  LessThanOperation.superclass = BinaryOperation.prototype;

  function LessThanOperation(lhs, rhs) {
    if (arguments.length > 0) {
      this.init(lhs, rhs);
    }
  }

  LessThanOperation.prototype.init = function (lhs, rhs) {
    LessThanOperation.superclass.init.call(this, lhs, rhs);
  };

  LessThanOperation.prototype.evaluate = function (c) {
    return this.lhs.evaluate(c).lessthan(this.rhs.evaluate(c));
  };

  LessThanOperation.prototype.toString = function () {
    return "(" + this.lhs.toString() + " < " + this.rhs.toString() + ")";
  };

// GreaterThanOperation //////////////////////////////////////////////////////

  GreaterThanOperation.prototype = new BinaryOperation();
  GreaterThanOperation.prototype.constructor = GreaterThanOperation;
  GreaterThanOperation.superclass = BinaryOperation.prototype;

  function GreaterThanOperation(lhs, rhs) {
    if (arguments.length > 0) {
      this.init(lhs, rhs);
    }
  }

  GreaterThanOperation.prototype.init = function (lhs, rhs) {
    GreaterThanOperation.superclass.init.call(this, lhs, rhs);
  };

  GreaterThanOperation.prototype.evaluate = function (c) {
    return this.lhs.evaluate(c).greaterthan(this.rhs.evaluate(c));
  };

  GreaterThanOperation.prototype.toString = function () {
    return "(" + this.lhs.toString() + " > " + this.rhs.toString() + ")";
  };

// LessThanOrEqualOperation //////////////////////////////////////////////////

  LessThanOrEqualOperation.prototype = new BinaryOperation();
  LessThanOrEqualOperation.prototype.constructor = LessThanOrEqualOperation;
  LessThanOrEqualOperation.superclass = BinaryOperation.prototype;

  function LessThanOrEqualOperation(lhs, rhs) {
    if (arguments.length > 0) {
      this.init(lhs, rhs);
    }
  }

  LessThanOrEqualOperation.prototype.init = function (lhs, rhs) {
    LessThanOrEqualOperation.superclass.init.call(this, lhs, rhs);
  };

  LessThanOrEqualOperation.prototype.evaluate = function (c) {
    return this.lhs.evaluate(c).lessthanorequal(this.rhs.evaluate(c));
  };

  LessThanOrEqualOperation.prototype.toString = function () {
    return "(" + this.lhs.toString() + " <= " + this.rhs.toString() + ")";
  };

// GreaterThanOrEqualOperation ///////////////////////////////////////////////

  GreaterThanOrEqualOperation.prototype = new BinaryOperation();
  GreaterThanOrEqualOperation.prototype.constructor = GreaterThanOrEqualOperation;
  GreaterThanOrEqualOperation.superclass = BinaryOperation.prototype;

  function GreaterThanOrEqualOperation(lhs, rhs) {
    if (arguments.length > 0) {
      this.init(lhs, rhs);
    }
  }

  GreaterThanOrEqualOperation.prototype.init = function (lhs, rhs) {
    GreaterThanOrEqualOperation.superclass.init.call(this, lhs, rhs);
  };

  GreaterThanOrEqualOperation.prototype.evaluate = function (c) {
    return this.lhs.evaluate(c).greaterthanorequal(this.rhs.evaluate(c));
  };

  GreaterThanOrEqualOperation.prototype.toString = function () {
    return "(" + this.lhs.toString() + " >= " + this.rhs.toString() + ")";
  };

// PlusOperation /////////////////////////////////////////////////////////////

  PlusOperation.prototype = new BinaryOperation();
  PlusOperation.prototype.constructor = PlusOperation;
  PlusOperation.superclass = BinaryOperation.prototype;

  function PlusOperation(lhs, rhs) {
    if (arguments.length > 0) {
      this.init(lhs, rhs);
    }
  }

  PlusOperation.prototype.init = function (lhs, rhs) {
    PlusOperation.superclass.init.call(this, lhs, rhs);
  };

  PlusOperation.prototype.evaluate = function (c) {
    return this.lhs.evaluate(c).number().plus(this.rhs.evaluate(c).number());
  };

  PlusOperation.prototype.toString = function () {
    return "(" + this.lhs.toString() + " + " + this.rhs.toString() + ")";
  };

// MinusOperation ////////////////////////////////////////////////////////////

  MinusOperation.prototype = new BinaryOperation();
  MinusOperation.prototype.constructor = MinusOperation;
  MinusOperation.superclass = BinaryOperation.prototype;

  function MinusOperation(lhs, rhs) {
    if (arguments.length > 0) {
      this.init(lhs, rhs);
    }
  }

  MinusOperation.prototype.init = function (lhs, rhs) {
    MinusOperation.superclass.init.call(this, lhs, rhs);
  };

  MinusOperation.prototype.evaluate = function (c) {
    return this.lhs.evaluate(c).number().minus(this.rhs.evaluate(c).number());
  };

  MinusOperation.prototype.toString = function () {
    return "(" + this.lhs.toString() + " - " + this.rhs.toString() + ")";
  };

// MultiplyOperation /////////////////////////////////////////////////////////

  MultiplyOperation.prototype = new BinaryOperation();
  MultiplyOperation.prototype.constructor = MultiplyOperation;
  MultiplyOperation.superclass = BinaryOperation.prototype;

  function MultiplyOperation(lhs, rhs) {
    if (arguments.length > 0) {
      this.init(lhs, rhs);
    }
  }

  MultiplyOperation.prototype.init = function (lhs, rhs) {
    MultiplyOperation.superclass.init.call(this, lhs, rhs);
  };

  MultiplyOperation.prototype.evaluate = function (c) {
    return this.lhs.evaluate(c).number().multiply(this.rhs.evaluate(c).number());
  };

  MultiplyOperation.prototype.toString = function () {
    return "(" + this.lhs.toString() + " * " + this.rhs.toString() + ")";
  };

// DivOperation //////////////////////////////////////////////////////////////

  DivOperation.prototype = new BinaryOperation();
  DivOperation.prototype.constructor = DivOperation;
  DivOperation.superclass = BinaryOperation.prototype;

  function DivOperation(lhs, rhs) {
    if (arguments.length > 0) {
      this.init(lhs, rhs);
    }
  }

  DivOperation.prototype.init = function (lhs, rhs) {
    DivOperation.superclass.init.call(this, lhs, rhs);
  };

  DivOperation.prototype.evaluate = function (c) {
    return this.lhs.evaluate(c).number().div(this.rhs.evaluate(c).number());
  };

  DivOperation.prototype.toString = function () {
    return "(" + this.lhs.toString() + " div " + this.rhs.toString() + ")";
  };

// ModOperation //////////////////////////////////////////////////////////////

  ModOperation.prototype = new BinaryOperation();
  ModOperation.prototype.constructor = ModOperation;
  ModOperation.superclass = BinaryOperation.prototype;

  function ModOperation(lhs, rhs) {
    if (arguments.length > 0) {
      this.init(lhs, rhs);
    }
  }

  ModOperation.prototype.init = function (lhs, rhs) {
    ModOperation.superclass.init.call(this, lhs, rhs);
  };

  ModOperation.prototype.evaluate = function (c) {
    return this.lhs.evaluate(c).number().mod(this.rhs.evaluate(c).number());
  };

  ModOperation.prototype.toString = function () {
    return "(" + this.lhs.toString() + " mod " + this.rhs.toString() + ")";
  };

// BarOperation //////////////////////////////////////////////////////////////

  BarOperation.prototype = new BinaryOperation();
  BarOperation.prototype.constructor = BarOperation;
  BarOperation.superclass = BinaryOperation.prototype;

  function BarOperation(lhs, rhs) {
    if (arguments.length > 0) {
      this.init(lhs, rhs);
    }
  }

  BarOperation.prototype.init = function (lhs, rhs) {
    BarOperation.superclass.init.call(this, lhs, rhs);
  };

  BarOperation.prototype.evaluate = function (c) {
    return this.lhs.evaluate(c).nodeset().union(this.rhs.evaluate(c).nodeset());
  };

  BarOperation.prototype.toString = function () {
    return this.lhs.toString() + " | " + this.rhs.toString();
  };

// PathExpr //////////////////////////////////////////////////////////////////

  PathExpr.prototype = new Expression();
  PathExpr.prototype.constructor = PathExpr;
  PathExpr.superclass = Expression.prototype;

  function PathExpr(filter, filterPreds, locpath) {
    if (arguments.length > 0) {
      this.init(filter, filterPreds, locpath);
    }
  }

  PathExpr.prototype.init = function (filter, filterPreds, locpath) {
    PathExpr.superclass.init.call(this);
    this.filter = filter;
    this.filterPredicates = filterPreds;
    this.locationPath = locpath;
  };

  PathExpr.prototype.evaluate = function (c) {
    var nodes;
    var xpc = new XPathContext();
    xpc.variableResolver = c.variableResolver;
    xpc.functionResolver = c.functionResolver;
    xpc.namespaceResolver = c.namespaceResolver;
    xpc.expressionContextNode = c.expressionContextNode;
    xpc.virtualRoot = c.virtualRoot;
    xpc.caseInsensitive = c.caseInsensitive;
    if (this.filter == null) {
      nodes = [c.contextNode];
    } else {
      var ns = this.filter.evaluate(c);
      if (!Utilities.instance_of(ns, XNodeSet)) {
        if (this.filterPredicates != null && this.filterPredicates.length > 0 || this.locationPath != null) {
          throw new Error("Path expression filter must evaluate to a nodeset if predicates or location path are used");
        }
        return ns;
      }
      nodes = ns.toArray();
      if (this.filterPredicates != null) {
        // apply each of the predicates in turn
        for (var j = 0; j < this.filterPredicates.length; j++) {
          var pred = this.filterPredicates[j];
          var newNodes = [];
          xpc.contextSize = nodes.length;
          for (xpc.contextPosition = 1; xpc.contextPosition <= xpc.contextSize; xpc.contextPosition++) {
            xpc.contextNode = nodes[xpc.contextPosition - 1];
            if (this.predicateMatches(pred, xpc)) {
              newNodes.push(xpc.contextNode);
            }
          }
          nodes = newNodes;
        }
      }
    }
    if (this.locationPath != null) {
      if (this.locationPath.absolute) {
        if (nodes[0].nodeType() != 9 /*Node.DOCUMENT_NODE*/) {
          if (xpc.virtualRoot != null) {
            nodes = [xpc.virtualRoot];
          } else {
            if (nodes[0].ownerDocument() == null) {
              // IE 5.5 doesn't have ownerDocument?
              var n = nodes[0];
              while (n.parentNode() != null) {
                n = n.parentNode();
              }
              nodes = [n];
            } else {
              nodes = [nodes[0].ownerDocument()];
            }
          }
        } else {
          nodes = [nodes[0]];
        }
      }
      for (var i = 0; i < this.locationPath.steps.length; i++) {
        var step = this.locationPath.steps[i];
        var newNodes = [];
        for (var j = 0; j < nodes.length; j++) {
          xpc.contextNode = nodes[j];
          switch (step.axis) {
            case Step.ANCESTOR:
              //log("ANCESTOR");
              // look at all the ancestor nodes
              if (xpc.contextNode === xpc.virtualRoot) {
                break;
              }
              var m;
              if (xpc.contextNode.nodeType() == 2 /*Node.ATTRIBUTE_NODE*/) {
                m = this.getOwnerElement(xpc.contextNode);
              } else {
                m = xpc.contextNode.parentNode();
              }
              while (m != null) {
                if (step.nodeTest.matches(m, xpc)) {
                  newNodes.push(m);
                }
                if (m === xpc.virtualRoot) {
                  break;
                }
                m = m.parentNode();
              }
              break;

            case Step.ANCESTORORSELF:
              //log("ANCESTORORSELF");
              // look at all the ancestor nodes and the current node
              for (var m = xpc.contextNode; m != null; m = m.nodeType() == 2 /*Node.ATTRIBUTE_NODE*/ ? this.getOwnerElement(m) : m.parentNode()) {
                if (step.nodeTest.matches(m, xpc)) {
                  newNodes.push(m);
                }
                if (m === xpc.virtualRoot) {
                  break;
                }
              }
              break;

            case Step.ATTRIBUTE:
              //log("ATTRIBUTE");
              // look at the attributes
              var nnm = xpc.contextNode.attributes();
              if (nnm != null) {
                for (var k = 0; k < nnm.length; k++) {
                  var m = nnm.item(k);
                  if (step.nodeTest.matches(m, xpc)) {
                    newNodes.push(m);
                  }
                }
              }
              break;

            case Step.CHILD:
              //log("CHILD");
              // look at all child elements
              for (var m = xpc.contextNode.firstChild(); m != null; m = m.nextSibling()) {
                //log(xpc.contextNode.nodeName(), m.nodeName());
                if (step.nodeTest.matches(m, xpc)) {
                  newNodes.push(m);
                }
              }
              break;

            case Step.DESCENDANT:
              //log("DESCENDANT");
              // look at all descendant nodes
              var st = [xpc.contextNode.firstChild()];
              while (st.length > 0) {
                for (var m = st.pop(); m != null;) {
                  if (step.nodeTest.matches(m, xpc)) {
                    newNodes.push(m);
                  }
                  if (m.firstChild() != null) {
                    st.push(m.nextSibling());
                    m = m.firstChild();
                  } else {
                    m = m.nextSibling();
                  }
                }
              }
              break;

            case Step.DESCENDANTORSELF:
              //log("DESCENDANTORSELF");
              // look at self
              if (step.nodeTest.matches(xpc.contextNode, xpc)) {
                newNodes.push(xpc.contextNode);
              }
              // look at all descendant nodes
              var st = [xpc.contextNode.firstChild()];
              while (st.length > 0) {
                for (var m = st.pop(); m != null;) {
                  if (step.nodeTest.matches(m, xpc)) {
                    newNodes.push(m);
                  }
                  if (m.firstChild() != null) {
                    st.push(m.nextSibling());
                    m = m.firstChild();
                  } else {
                    m = m.nextSibling();
                  }
                }
              }
              break;

            case Step.FOLLOWING:
              log("FOLLOWING");
              if (xpc.contextNode === xpc.virtualRoot) {
                break;
              }
              var st = [];
              if (xpc.contextNode.firstChild() != null) {
                st.unshift(xpc.contextNode.firstChild());
              } else {
                st.unshift(xpc.contextNode.nextSibling());
              }
              for (var m = xpc.contextNode.parentNode(); m != null && m.nodeType() != 9 /*Node.DOCUMENT_NODE*/ && m !== xpc.virtualRoot; m = m.parentNode()) {
                st.unshift(m.nextSibling());
              }
              do {
                for (var m = st.pop(); m != null;) {
                  if (step.nodeTest.matches(m, xpc)) {
                    newNodes.push(m);
                  }
                  if (m.firstChild() != null) {
                    st.push(m.nextSibling());
                    m = m.firstChild();
                  } else {
                    m = m.nextSibling();
                  }
                }
              } while (st.length > 0);
              break;

            case Step.FOLLOWINGSIBLING:
              //log("FOLLOWINGSIBLING");
              if (xpc.contextNode === xpc.virtualRoot) {
                break;
              }
              for (var m = xpc.contextNode.nextSibling(); m != null; m = m.nextSibling()) {
                if (step.nodeTest.matches(m, xpc)) {
                  newNodes.push(m);
                }
              }
              break;

            case Step.NAMESPACE:
              //log("NAMESPACE");
              var n = {};
              if (xpc.contextNode.nodeType() == 1 /*Node.ELEMENT_NODE*/) {
                n["xml"] = XPath.XML_NAMESPACE_URI;
                n["xmlns"] = XPath.XMLNS_NAMESPACE_URI;
                for (var m = xpc.contextNode; m != null && m.nodeType() == 1 /*Node.ELEMENT_NODE*/; m = m.parentNode()) {
                  for (var k = 0; k < m.attributes().length; k++) {
                    var attr = m.attributes().item(k);
                    var nm = String(attr.name);
                    if (nm == "xmlns") {
                      if (n[""] == undefined) {
                        n[""] = attr.value;
                      }
                    } else if (nm.length > 6 && nm.substring(0, 6) == "xmlns:") {
                      var pre = nm.substring(6, nm.length);
                      if (n[pre] == undefined) {
                        n[pre] = attr.value;
                      }
                    }
                  }
                }
                for (var pre in n) {
                  var nsn = new NamespaceNode(pre, n[pre], xpc.contextNode);
                  if (step.nodeTest.matches(nsn, xpc)) {
                    newNodes.push(nsn);
                  }
                }
              }
              break;

            case Step.PARENT:
              //log("PARENT");
              m = null;
              if (xpc.contextNode !== xpc.virtualRoot) {
                if (xpc.contextNode.nodeType() == 2 /*Node.ATTRIBUTE_NODE*/) {
                  m = this.getOwnerElement(xpc.contextNode);
                } else {
                  m = xpc.contextNode.parentNode();
                }
              }
              if (m != null && step.nodeTest.matches(m, xpc)) {
                newNodes.push(m);
              }
              break;

            case Step.PRECEDING:
              //log("PRECEDING");
              var st;
              if (xpc.virtualRoot != null) {
                st = [xpc.virtualRoot];
              } else {
                st = xpc.contextNode.nodeType() == 9 /*Node.DOCUMENT_NODE*/
                  ? [xpc.contextNode]
                  : [xpc.contextNode.ownerDocument()];
              }
              outer: while (st.length > 0) {
                for (var m = st.pop(); m != null;) {
                  if (m == xpc.contextNode) {
                    break outer;
                  }
                  if (step.nodeTest.matches(m, xpc)) {
                    newNodes.unshift(m);
                  }
                  if (m.firstChild() != null) {
                    st.push(m.nextSibling());
                    m = m.firstChild();
                  } else {
                    m = m.nextSibling();
                  }
                }
              }
              break;

            case Step.PRECEDINGSIBLING:
              //log("PRECEDINGSIBLING");
              if (xpc.contextNode === xpc.virtualRoot) {
                break;
              }
              for (var m = xpc.contextNode.previousSibling(); m != null; m = m.previousSibling()) {
                if (step.nodeTest.matches(m, xpc)) {
                  newNodes.push(m);
                }
              }
              break;

            case Step.SELF:
              //log("SELF");
              if (step.nodeTest.matches(xpc.contextNode, xpc)) {
                newNodes.push(xpc.contextNode);
              }
              break;

            default:
          }
        }
        nodes = newNodes;
        // apply each of the predicates in turn
        for (var j = 0; j < step.predicates.length; j++) {
          var pred = step.predicates[j];
          var newNodes = [];
          xpc.contextSize = nodes.length;
          for (xpc.contextPosition = 1; xpc.contextPosition <= xpc.contextSize; xpc.contextPosition++) {
            xpc.contextNode = nodes[xpc.contextPosition - 1];
            if (this.predicateMatches(pred, xpc)) {
              newNodes.push(xpc.contextNode);
            } else {
            }
          }
          nodes = newNodes;
        }
      }
    }
    var ns = new XNodeSet();
    ns.addArray(nodes);
    return ns;
  };

  PathExpr.prototype.predicateMatches = function (pred, c) {
    var res = pred.evaluate(c);
    if (Utilities.instance_of(res, XNumber)) {
      return c.contextPosition == res.numberValue();
    }
    return res.booleanValue();
  };

  PathExpr.prototype.toString = function () {
    if (this.filter != undefined) {
      var s = this.filter.toString();
      if (Utilities.instance_of(this.filter, XString)) {
        s = "'" + s + "'";
      }
      if (this.filterPredicates != undefined) {
        for (var i = 0; i < this.filterPredicates.length; i++) {
          s = s + "[" + this.filterPredicates[i].toString() + "]";
        }
      }
      if (this.locationPath != undefined) {
        if (!this.locationPath.absolute) {
          s += "/";
        }
        s += this.locationPath.toString();
      }
      return s;
    }
    return this.locationPath.toString();
  };

  PathExpr.prototype.getOwnerElement = function (n) {
    // DOM 2 has ownerElement
    if (n.ownerElement) {
      return n.ownerElement;
    }
    // DOM 1 Internet Explorer can use selectSingleNode (ironically)
    try {
      if (n.selectSingleNode) {
        return n.selectSingleNode("..");
      }
    } catch (e) {
    }
    // Other DOM 1 implementations must use this egregious search
    var doc = n.nodeType() == 9 /*Node.DOCUMENT_NODE*/
      ? n
      : n.ownerDocument();
    var elts = doc.getElementsByTagName("*");
    for (var i = 0; i < elts.length; i++) {
      var elt = elts.item(i);
      var nnm = elt.attributes();
      for (var j = 0; j < nnm.length; j++) {
        var an = nnm.item(j);
        if (an === n) {
          return elt;
        }
      }
    }
    return null;
  };

// LocationPath //////////////////////////////////////////////////////////////

  LocationPath.prototype = new Object();
  LocationPath.prototype.constructor = LocationPath;
  LocationPath.superclass = Object.prototype;

  function LocationPath(abs, steps) {
    if (arguments.length > 0) {
      this.init(abs, steps);
    }
  }

  LocationPath.prototype.init = function (abs, steps) {
    this.absolute = abs;
    this.steps = steps;
  };

  LocationPath.prototype.toString = function () {
    var s;
    if (this.absolute) {
      s = "/";
    } else {
      s = "";
    }
    for (var i = 0; i < this.steps.length; i++) {
      if (i != 0) {
        s += "/";
      }
      s += this.steps[i].toString();
    }
    return s;
  };

// Step //////////////////////////////////////////////////////////////////////

  Step.prototype = new Object();
  Step.prototype.constructor = Step;
  Step.superclass = Object.prototype;

  function Step(axis, nodetest, preds) {
    if (arguments.length > 0) {
      this.init(axis, nodetest, preds);
    }
  }

  Step.prototype.init = function (axis, nodetest, preds) {
    this.axis = axis;
    this.nodeTest = nodetest;
    this.predicates = preds;
  };

  Step.prototype.toString = function () {
    var s;
    switch (this.axis) {
      case Step.ANCESTOR:
        s = "ancestor";
        break;
      case Step.ANCESTORORSELF:
        s = "ancestor-or-self";
        break;
      case Step.ATTRIBUTE:
        s = "attribute";
        break;
      case Step.CHILD:
        s = "child";
        break;
      case Step.DESCENDANT:
        s = "descendant";
        break;
      case Step.DESCENDANTORSELF:
        s = "descendant-or-self";
        break;
      case Step.FOLLOWING:
        s = "following";
        break;
      case Step.FOLLOWINGSIBLING:
        s = "following-sibling";
        break;
      case Step.NAMESPACE:
        s = "namespace";
        break;
      case Step.PARENT:
        s = "parent";
        break;
      case Step.PRECEDING:
        s = "preceding";
        break;
      case Step.PRECEDINGSIBLING:
        s = "preceding-sibling";
        break;
      case Step.SELF:
        s = "self";
        break;
    }
    s += "::";
    s += this.nodeTest.toString();
    for (var i = 0; i < this.predicates.length; i++) {
      s += "[" + this.predicates[i].toString() + "]";
    }
    return s;
  };

  Step.ANCESTOR = 0;
  Step.ANCESTORORSELF = 1;
  Step.ATTRIBUTE = 2;
  Step.CHILD = 3;
  Step.DESCENDANT = 4;
  Step.DESCENDANTORSELF = 5;
  Step.FOLLOWING = 6;
  Step.FOLLOWINGSIBLING = 7;
  Step.NAMESPACE = 8;
  Step.PARENT = 9;
  Step.PRECEDING = 10;
  Step.PRECEDINGSIBLING = 11;
  Step.SELF = 12;

// NodeTest //////////////////////////////////////////////////////////////////

  NodeTest.prototype = new Object();
  NodeTest.prototype.constructor = NodeTest;
  NodeTest.superclass = Object.prototype;

  function NodeTest(type, value) {
    if (arguments.length > 0) {
      this.init(type, value);
    }
  }

  NodeTest.prototype.init = function (type, value) {
    this.type = type;
    this.value = value;
  };

  NodeTest.prototype._matches = function (testName, nodeName) {
    if (!(testName || nodeName)) return false;
    if (XPathExpression.mappings) {
      for (var key in XPathExpression.mappings) {
        if (XPathExpression.mappings.hasOwnProperty(key)) {
          var testRegex = new RegExp('^' + key + '$', 'ig');
          var nodeRegex = new RegExp('^' + XPathExpression.mappings[key] + '$', 'ig');
          if (testRegex.test(testName) && nodeRegex.test(nodeName)) {
            return true;
          }
        }
      }
    }
    return testName.toLowerCase() == nodeName.toLowerCase()
  };

  NodeTest.prototype.matches = function (n, xpc) {
    switch (this.type) {
      case NodeTest.NAMETESTANY:
        if (n.nodeType() == 2 /*Node.ATTRIBUTE_NODE*/
          || n.nodeType() == 1) { /*Node.ELEMENT_NODE*/
          return true;
        }
        return false;
      case NodeTest.NAMETESTPREFIXANY:
        if ((n.nodeType() == 2 /*Node.ATTRIBUTE_NODE*/ || n.nodeType() == 1 /*Node.ELEMENT_NODE*/)) {
          var ns = xpc.namespaceResolver.getNamespace(this.value, xpc.expressionContextNode);
          if (ns == null) {
            throw new Error("Cannot resolve QName " + this.value);
          }
          return true;
        }
        return false;
      case NodeTest.NAMETESTQNAME:
        if (n.nodeType() == 2 /*Node.ATTRIBUTE_NODE*/
          || n.nodeType() == 1) { /*Node.ELEMENT_NODE*/
          // automatically fail if trying to use namespace
          if (this.value.indexOf(":") > -1) {
            return false;
          }
          // element name in expression being tested
          var test = Utilities.resolveQName(this.value, xpc.namespaceResolver, xpc.expressionContextNode, false);
          if (test[0] == null) {
            throw new Error("Cannot resolve QName " + this.value);
          }
          // namespace
          test[0] = String(test[0]);
          // local name
          test[1] = String(test[1]);
          if (test[0] == "") {
            test[0] = null;
          }
          // element to test against from dom
          var node = Utilities.resolveQName(n.nodeName(), xpc.namespaceResolver, n, n.nodeType() == 1 /*Node.ELEMENT_NODE*/);
          // namespace
          node[0] = String(node[0]);
          // local name
          node[1] = String(node[1]);
          if (node[0] == "") {
            node[0] = null;
          }
          return this._matches(String(test[1]), String(node[1]));
        }
        return false;
      case NodeTest.COMMENT:
        return n.nodeType() == 8 /*Node.COMMENT_NODE*/;
      case NodeTest.TEXT:
        return n.nodeType() == 3 /*Node.TEXT_NODE*/ || n.nodeType() == 4 /*Node.CDATA_SECTION_NODE*/;
      case NodeTest.PI:
        return n.nodeType() == 7 /*Node.PROCESSING_INSTRUCTION_NODE*/
          && (this.value == null || n.nodeName(this.value));
      case NodeTest.NODE:
        return n.nodeType() == 9 /*Node.DOCUMENT_NODE*/
          || n.nodeType() == 1 /*Node.ELEMENT_NODE*/
          || n.nodeType() == 2 /*Node.ATTRIBUTE_NODE*/
          || n.nodeType() == 3 /*Node.TEXT_NODE*/
          || n.nodeType() == 4 /*Node.CDATA_SECTION_NODE*/
          || n.nodeType() == 8 /*Node.COMMENT_NODE*/
          || n.nodeType() == 7 /*Node.PROCESSING_INSTRUCTION_NODE*/;
    }
    return false;
  };

  NodeTest.prototype.toString = function () {
    switch (this.type) {
      case NodeTest.NAMETESTANY:
        return "*";
      case NodeTest.NAMETESTPREFIXANY:
        return this.value + ":*";
      case NodeTest.NAMETESTRESOLVEDANY:
        return "{" + this.value + "}*";
      case NodeTest.NAMETESTQNAME:
        return this.value;
      case NodeTest.NAMETESTRESOLVEDNAME:
        return "{" + this.namespaceURI + "}" + this.value;
      case NodeTest.COMMENT:
        return "comment()";
      case NodeTest.TEXT:
        return "text()";
      case NodeTest.PI:
        if (this.value != undefined) {
          return "processing-instruction(\"" + this.value + "\")";
        }
        return "processing-instruction()";
      case NodeTest.NODE:
        return "node()";
    }
    return "<unknown nodetest type>";
  };

  NodeTest.NAMETESTANY = 0;
  NodeTest.NAMETESTPREFIXANY = 1;
  NodeTest.NAMETESTQNAME = 2;
  NodeTest.COMMENT = 3;
  NodeTest.TEXT = 4;
  NodeTest.PI = 5;
  NodeTest.NODE = 6;

// VariableReference /////////////////////////////////////////////////////////

  VariableReference.prototype = new Expression();
  VariableReference.prototype.constructor = VariableReference;
  VariableReference.superclass = Expression.prototype;

  function VariableReference(v) {
    if (arguments.length > 0) {
      this.init(v);
    }
  }

  VariableReference.prototype.init = function (v) {
    this.variable = v;
  };

  VariableReference.prototype.toString = function () {
    return "$" + this.variable;
  };

  VariableReference.prototype.evaluate = function (c) {
    return c.variableResolver.getVariable(this.variable, c);
  };

// FunctionCall //////////////////////////////////////////////////////////////

  FunctionCall.prototype = new Expression();
  FunctionCall.prototype.constructor = FunctionCall;
  FunctionCall.superclass = Expression.prototype;

  function FunctionCall(fn, args) {
    if (arguments.length > 0) {
      this.init(fn, args);
    }
  }

  FunctionCall.prototype.init = function (fn, args) {
    this.functionName = fn;
    this.arguments = args;
  };

  FunctionCall.prototype.toString = function () {
    var s = this.functionName + "(";
    for (var i = 0; i < this.arguments.length; i++) {
      if (i > 0) {
        s += ", ";
      }
      s += this.arguments[i].toString();
    }
    return s + ")";
  };

  FunctionCall.prototype.evaluate = function (c) {
    var f = c.functionResolver.getFunction(this.functionName, c);
    if (f == undefined) {
      throw new Error("Unknown function " + this.functionName);
    }
    var a = [c].concat(this.arguments);
    return f.apply(c.functionResolver.thisArg, a);
  };

// XString ///////////////////////////////////////////////////////////////////

  XString.prototype = new Expression();
  XString.prototype.constructor = XString;
  XString.superclass = Expression.prototype;

  function XString(s) {
    if (arguments.length > 0) {
      this.init(s);
    }
  }

  XString.prototype.init = function (s) {
    this.str = s;
  };

  XString.prototype.toString = function () {
    return this.str;
  };

  XString.prototype.evaluate = function (c) {
    return this;
  };

  XString.prototype.string = function () {
    return this;
  };

  XString.prototype.number = function () {
    return new XNumber(this.str);
  };

  XString.prototype.bool = function () {
    return new XBoolean(this.str);
  };

  XString.prototype.nodeset = function () {
    throw new Error("Cannot convert string to nodeset");
  };

  XString.prototype.stringValue = function () {
    return this.str;
  };

  XString.prototype.numberValue = function () {
    return this.number().numberValue();
  };

  XString.prototype.booleanValue = function () {
    return this.bool().booleanValue();
  };

  XString.prototype.equals = function (r) {
    if (Utilities.instance_of(r, XBoolean)) {
      return this.bool().equals(r);
    }
    if (Utilities.instance_of(r, XNumber)) {
      return this.number().equals(r);
    }
    if (Utilities.instance_of(r, XNodeSet)) {
      return r.compareWithString(this, Operators.equals);
    }
    return new XBoolean(this.str == r.str);
  };

  XString.prototype.notequal = function (r) {
    if (Utilities.instance_of(r, XBoolean)) {
      return this.bool().notequal(r);
    }
    if (Utilities.instance_of(r, XNumber)) {
      return this.number().notequal(r);
    }
    if (Utilities.instance_of(r, XNodeSet)) {
      return r.compareWithString(this, Operators.notequal);
    }
    return new XBoolean(this.str != r.str);
  };

  XString.prototype.lessthan = function (r) {
    if (Utilities.instance_of(r, XNodeSet)) {
      return r.compareWithNumber(this.number(), Operators.greaterthanorequal);
    }
    return this.number().lessthan(r.number());
  };

  XString.prototype.greaterthan = function (r) {
    if (Utilities.instance_of(r, XNodeSet)) {
      return r.compareWithNumber(this.number(), Operators.lessthanorequal);
    }
    return this.number().greaterthan(r.number());
  };

  XString.prototype.lessthanorequal = function (r) {
    if (Utilities.instance_of(r, XNodeSet)) {
      return r.compareWithNumber(this.number(), Operators.greaterthan);
    }
    return this.number().lessthanorequal(r.number());
  };

  XString.prototype.greaterthanorequal = function (r) {
    if (Utilities.instance_of(r, XNodeSet)) {
      return r.compareWithNumber(this.number(), Operators.lessthan);
    }
    return this.number().greaterthanorequal(r.number());
  };

// XNumber ///////////////////////////////////////////////////////////////////

  XNumber.prototype = new Expression();
  XNumber.prototype.constructor = XNumber;
  XNumber.superclass = Expression.prototype;

  function XNumber(n) {
    if (arguments.length > 0) {
      this.init(n);
    }
  }

  XNumber.prototype.init = function (n) {
    this.num = Number(n);
  };

  XNumber.prototype.toString = function () {
    return this.num;
  };

  XNumber.prototype.evaluate = function (c) {
    return this;
  };

  XNumber.prototype.string = function () {
    return new XString(this.num);
  };

  XNumber.prototype.number = function () {
    return this;
  };

  XNumber.prototype.bool = function () {
    return new XBoolean(this.num);
  };

  XNumber.prototype.nodeset = function () {
    throw new Error("Cannot convert number to nodeset");
  };

  XNumber.prototype.stringValue = function () {
    return this.string().stringValue();
  };

  XNumber.prototype.numberValue = function () {
    return this.num;
  };

  XNumber.prototype.booleanValue = function () {
    return this.bool().booleanValue();
  };

  XNumber.prototype.negate = function () {
    return new XNumber(-this.num);
  };

  XNumber.prototype.equals = function (r) {
    if (Utilities.instance_of(r, XBoolean)) {
      return this.bool().equals(r);
    }
    if (Utilities.instance_of(r, XString)) {
      return this.equals(r.number());
    }
    if (Utilities.instance_of(r, XNodeSet)) {
      return r.compareWithNumber(this, Operators.equals);
    }
    return new XBoolean(this.num == r.num);
  };

  XNumber.prototype.notequal = function (r) {
    if (Utilities.instance_of(r, XBoolean)) {
      return this.bool().notequal(r);
    }
    if (Utilities.instance_of(r, XString)) {
      return this.notequal(r.number());
    }
    if (Utilities.instance_of(r, XNodeSet)) {
      return r.compareWithNumber(this, Operators.notequal);
    }
    return new XBoolean(this.num != r.num);
  };

  XNumber.prototype.lessthan = function (r) {
    if (Utilities.instance_of(r, XNodeSet)) {
      return r.compareWithNumber(this, Operators.greaterthanorequal);
    }
    if (Utilities.instance_of(r, XBoolean) || Utilities.instance_of(r, XString)) {
      return this.lessthan(r.number());
    }
    return new XBoolean(this.num < r.num);
  };

  XNumber.prototype.greaterthan = function (r) {
    if (Utilities.instance_of(r, XNodeSet)) {
      return r.compareWithNumber(this, Operators.lessthanorequal);
    }
    if (Utilities.instance_of(r, XBoolean) || Utilities.instance_of(r, XString)) {
      return this.greaterthan(r.number());
    }
    return new XBoolean(this.num > r.num);
  };

  XNumber.prototype.lessthanorequal = function (r) {
    if (Utilities.instance_of(r, XNodeSet)) {
      return r.compareWithNumber(this, Operators.greaterthan);
    }
    if (Utilities.instance_of(r, XBoolean) || Utilities.instance_of(r, XString)) {
      return this.lessthanorequal(r.number());
    }
    return new XBoolean(this.num <= r.num);
  };

  XNumber.prototype.greaterthanorequal = function (r) {
    if (Utilities.instance_of(r, XNodeSet)) {
      return r.compareWithNumber(this, Operators.lessthan);
    }
    if (Utilities.instance_of(r, XBoolean) || Utilities.instance_of(r, XString)) {
      return this.greaterthanorequal(r.number());
    }
    return new XBoolean(this.num >= r.num);
  };

  XNumber.prototype.plus = function (r) {
    return new XNumber(this.num + r.num);
  };

  XNumber.prototype.minus = function (r) {
    return new XNumber(this.num - r.num);
  };

  XNumber.prototype.multiply = function (r) {
    return new XNumber(this.num * r.num);
  };

  XNumber.prototype.div = function (r) {
    return new XNumber(this.num / r.num);
  };

  XNumber.prototype.mod = function (r) {
    return new XNumber(this.num % r.num);
  };

// XBoolean //////////////////////////////////////////////////////////////////

  XBoolean.prototype = new Expression();
  XBoolean.prototype.constructor = XBoolean;
  XBoolean.superclass = Expression.prototype;

  function XBoolean(b) {
    if (arguments.length > 0) {
      this.init(b);
    }
  }

  XBoolean.prototype.init = function (b) {
    this.b = Boolean(b);
  };

  XBoolean.prototype.toString = function () {
    return this.b.toString();
  };

  XBoolean.prototype.evaluate = function (c) {
    return this;
  };

  XBoolean.prototype.string = function () {
    return new XString(this.b);
  };

  XBoolean.prototype.number = function () {
    return new XNumber(this.b);
  };

  XBoolean.prototype.bool = function () {
    return this;
  };

  XBoolean.prototype.nodeset = function () {
    throw new Error("Cannot convert boolean to nodeset");
  };

  XBoolean.prototype.stringValue = function () {
    return this.string().stringValue();
  };

  XBoolean.prototype.numberValue = function () {
    return this.num().numberValue();
  };

  XBoolean.prototype.booleanValue = function () {
    return this.b;
  };

  XBoolean.prototype.not = function () {
    return new XBoolean(!this.b);
  };

  XBoolean.prototype.equals = function (r) {
    if (Utilities.instance_of(r, XString) || Utilities.instance_of(r, XNumber)) {
      return this.equals(r.bool());
    }
    if (Utilities.instance_of(r, XNodeSet)) {
      return r.compareWithBoolean(this, Operators.equals);
    }
    return new XBoolean(this.b == r.b);
  };

  XBoolean.prototype.notequal = function (r) {
    if (Utilities.instance_of(r, XString) || Utilities.instance_of(r, XNumber)) {
      return this.notequal(r.bool());
    }
    if (Utilities.instance_of(r, XNodeSet)) {
      return r.compareWithBoolean(this, Operators.notequal);
    }
    return new XBoolean(this.b != r.b);
  };

  XBoolean.prototype.lessthan = function (r) {
    if (Utilities.instance_of(r, XNodeSet)) {
      return r.compareWithNumber(this.number(), Operators.greaterthanorequal);
    }
    return this.number().lessthan(r.number());
  };

  XBoolean.prototype.greaterthan = function (r) {
    if (Utilities.instance_of(r, XNodeSet)) {
      return r.compareWithNumber(this.number(), Operators.lessthanorequal);
    }
    return this.number().greaterthan(r.number());
  };

  XBoolean.prototype.lessthanorequal = function (r) {
    if (Utilities.instance_of(r, XNodeSet)) {
      return r.compareWithNumber(this.number(), Operators.greaterthan);
    }
    return this.number().lessthanorequal(r.number());
  };

  XBoolean.prototype.greaterthanorequal = function (r) {
    if (Utilities.instance_of(r, XNodeSet)) {
      return r.compareWithNumber(this.number(), Operators.lessthan);
    }
    return this.number().greaterthanorequal(r.number());
  };

// AVLTree ///////////////////////////////////////////////////////////////////

  AVLTree.prototype = new Object();
  AVLTree.prototype.constructor = AVLTree;
  AVLTree.superclass = Object.prototype;

  function AVLTree(n) {
    this.init(n);
  }

  AVLTree.prototype.init = function (n) {
    this.left = null;
    this.right = null;
    this.node = n;
    this.depth = 1;
  };

  AVLTree.prototype.balance = function () {
    var ldepth = this.left == null ? 0 : this.left.depth;
    var rdepth = this.right == null ? 0 : this.right.depth;

    if (ldepth > rdepth + 1) {
      // LR or LL rotation
      var lldepth = this.left.left == null ? 0 : this.left.left.depth;
      var lrdepth = this.left.right == null ? 0 : this.left.right.depth;

      if (lldepth < lrdepth) {
        // LR rotation consists of a RR rotation of the left child
        this.left.rotateRR();
        // plus a LL rotation of this node, which happens anyway
      }
      this.rotateLL();
    } else if (ldepth + 1 < rdepth) {
      // RR or RL rorarion
      var rrdepth = this.right.right == null ? 0 : this.right.right.depth;
      var rldepth = this.right.left == null ? 0 : this.right.left.depth;

      if (rldepth > rrdepth) {
        // RR rotation consists of a LL rotation of the right child
        this.right.rotateLL();
        // plus a RR rotation of this node, which happens anyway
      }
      this.rotateRR();
    }
  };

  AVLTree.prototype.rotateLL = function () {
    // the left side is too long => rotate from the left (_not_ leftwards)
    var nodeBefore = this.node;
    var rightBefore = this.right;
    this.node = this.left.node;
    this.right = this.left;
    this.left = this.left.left;
    this.right.left = this.right.right;
    this.right.right = rightBefore;
    this.right.node = nodeBefore;
    this.right.updateInNewLocation();
    this.updateInNewLocation();
  };

  AVLTree.prototype.rotateRR = function () {
    // the right side is too long => rotate from the right (_not_ rightwards)
    var nodeBefore = this.node;
    var leftBefore = this.left;
    this.node = this.right.node;
    this.left = this.right;
    this.right = this.right.right;
    this.left.right = this.left.left;
    this.left.left = leftBefore;
    this.left.node = nodeBefore;
    this.left.updateInNewLocation();
    this.updateInNewLocation();
  };

  AVLTree.prototype.updateInNewLocation = function () {
    this.getDepthFromChildren();
  };

  AVLTree.prototype.getDepthFromChildren = function () {
    this.depth = this.node == null ? 0 : 1;
    if (this.left != null) {
      this.depth = this.left.depth + 1;
    }
    if (this.right != null && this.depth <= this.right.depth) {
      this.depth = this.right.depth + 1;
    }
  };

  AVLTree.prototype.order = function (n1, n2) {
    if (n1 === n2) {
      return 0;
    }
    var d1 = 0;
    var d2 = 0;
    for (var m1 = n1; m1 != null; m1 = m1.parentNode()) {
      d1++;
    }
    for (var m2 = n2; m2 != null; m2 = m2.parentNode()) {
      d2++;
    }
    if (d1 > d2) {
      while (d1 > d2) {
        n1 = n1.parentNode();
        d1--;
      }
      if (n1 == n2) {
        return 1;
      }
    } else if (d2 > d1) {
      while (d2 > d1) {
        n2 = n2.parentNode();
        d2--;
      }
      if (n1 == n2) {
        return -1;
      }
    }
    while (n1.parentNode() != n2.parentNode()) {
      n1 = n1.parentNode();
      n2 = n2.parentNode();
    }
    while (n1.previousSibling() != null && n2.previousSibling() != null) {
      n1 = n1.previousSibling();
      n2 = n2.previousSibling();
    }
    if (n1.previousSibling() == null) {
      return -1;
    }
    return 1;
  };

  AVLTree.prototype.add = function (n) {
    if (n === this.node) {
      return false;
    }

    var o = this.order(n, this.node);

    var ret = false;
    if (o == -1) {
      if (this.left == null) {
        this.left = new AVLTree(n);
        ret = true;
      } else {
        ret = this.left.add(n);
        if (ret) {
          this.balance();
        }
      }
    } else if (o == 1) {
      if (this.right == null) {
        this.right = new AVLTree(n);
        ret = true;
      } else {
        ret = this.right.add(n);
        if (ret) {
          this.balance();
        }
      }
    }

    if (ret) {
      this.getDepthFromChildren();
    }
    return ret;
  };

// XNodeSet //////////////////////////////////////////////////////////////////

  XNodeSet.prototype = new Expression();
  XNodeSet.prototype.constructor = XNodeSet;
  XNodeSet.superclass = Expression.prototype;

  function XNodeSet() {
    this.init();
  }

  XNodeSet.prototype.init = function () {
    this.tree = null;
    this.size = 0;
  };

  XNodeSet.prototype.toString = function () {
    var p = this.first();
    if (p == null) {
      return "";
    }
    return this.stringForNode(p);
  };

  XNodeSet.prototype.evaluate = function (c) {
    return this;
  };

  XNodeSet.prototype.string = function () {
    return new XString(this.toString());
  };

  XNodeSet.prototype.stringValue = function () {
    return this.toString();
  };

  XNodeSet.prototype.number = function () {
    return new XNumber(this.string());
  };

  XNodeSet.prototype.numberValue = function () {
    return Number(this.string());
  };

  XNodeSet.prototype.bool = function () {
    return new XBoolean(this.tree != null);
  };

  XNodeSet.prototype.booleanValue = function () {
    return this.tree != null;
  };

  XNodeSet.prototype.nodeset = function () {
    return this;
  };

  XNodeSet.prototype.stringForNode = function (n) {
    if (n.nodeType() == 9 /*Node.DOCUMENT_NODE*/) {
      n = n.documentElement();
    }
    if (n.nodeType() == 1 /*Node.ELEMENT_NODE*/) {
      return this.stringForNodeRec(n);
    }
    if (n.isNamespaceNode) {
      return n.namespace;
    }
    return n.nodeValue();
  };

  XNodeSet.prototype.stringForNodeRec = function (n) {
    var s = "";
    for (var n2 = n.firstChild(); n2 != null; n2 = n2.nextSibling()) {
      if (n2.nodeType() == 3 /*Node.TEXT_NODE*/) {
        s += n2.nodeValue();
      } else if (n2.nodeType() == 1 /*Node.ELEMENT_NODE*/) {
        s += this.stringForNodeRec(n2);
      }
    }
    return s;
  };

  XNodeSet.prototype.first = function () {
    var p = this.tree;
    if (p == null) {
      return null;
    }
    while (p.left != null) {
      p = p.left;
    }
    return p.node;
  };

  XNodeSet.prototype.add = function (n) {
    var added;
    if (this.tree == null) {
      this.tree = new AVLTree(n);
      added = true;
    } else {
      added = this.tree.add(n);
    }
    if (added) {
      this.size++;
    }
  };

  XNodeSet.prototype.addArray = function (ns) {
    for (var i = 0; i < ns.length; i++) {
      this.add(ns[i]);
    }
  };

  XNodeSet.prototype.toArray = function () {
    var a = [];
    this.toArrayRec(this.tree, a);
    return a;
  };

  XNodeSet.prototype.toArrayRec = function (t, a) {
    if (t != null) {
      this.toArrayRec(t.left, a);
      a.push(t.node);
      this.toArrayRec(t.right, a);
    }
  };

  XNodeSet.prototype.compareWithString = function (r, o) {
    var a = this.toArray();
    for (var i = 0; i < a.length; i++) {
      var n = a[i];
      var l = new XString(this.stringForNode(n));
      var res = o(l, r);
      if (res.booleanValue()) {
        return res;
      }
    }
    return new XBoolean(false);
  };

  XNodeSet.prototype.compareWithNumber = function (r, o) {
    var a = this.toArray();
    for (var i = 0; i < a.length; i++) {
      var n = a[i];
      var l = new XNumber(this.stringForNode(n));
      var res = o(l, r);
      if (res.booleanValue()) {
        return res;
      }
    }
    return new XBoolean(false);
  };

  XNodeSet.prototype.compareWithBoolean = function (r, o) {
    return o(this.bool(), r);
  };

  XNodeSet.prototype.compareWithNodeSet = function (r, o) {
    var a = this.toArray();
    for (var i = 0; i < a.length; i++) {
      var n = a[i];
      var l = new XString(this.stringForNode(n));
      var b = r.toArray();
      for (var j = 0; j < b.length; j++) {
        var n2 = b[j];
        var r = new XString(this.stringForNode(n2));
        var res = o(l, r);
        if (res.booleanValue()) {
          return res;
        }
      }
    }
    return new XBoolean(false);
  };

  XNodeSet.prototype.equals = function (r) {
    if (Utilities.instance_of(r, XString)) {
      return this.compareWithString(r, Operators.equals);
    }
    if (Utilities.instance_of(r, XNumber)) {
      return this.compareWithNumber(r, Operators.equals);
    }
    if (Utilities.instance_of(r, XBoolean)) {
      return this.compareWithBoolean(r, Operators.equals);
    }
    return this.compareWithNodeSet(r, Operators.equals);
  };

  XNodeSet.prototype.notequal = function (r) {
    if (Utilities.instance_of(r, XString)) {
      return this.compareWithString(r, Operators.notequal);
    }
    if (Utilities.instance_of(r, XNumber)) {
      return this.compareWithNumber(r, Operators.notequal);
    }
    if (Utilities.instance_of(r, XBoolean)) {
      return this.compareWithBoolean(r, Operators.notequal);
    }
    return this.compareWithNodeSet(r, Operators.notequal);
  };

  XNodeSet.prototype.lessthan = function (r) {
    if (Utilities.instance_of(r, XString)) {
      return this.compareWithNumber(r.number(), Operators.lessthan);
    }
    if (Utilities.instance_of(r, XNumber)) {
      return this.compareWithNumber(r, Operators.lessthan);
    }
    if (Utilities.instance_of(r, XBoolean)) {
      return this.compareWithBoolean(r, Operators.lessthan);
    }
    return this.compareWithNodeSet(r, Operators.lessthan);
  };

  XNodeSet.prototype.greaterthan = function (r) {
    if (Utilities.instance_of(r, XString)) {
      return this.compareWithNumber(r.number(), Operators.greaterthan);
    }
    if (Utilities.instance_of(r, XNumber)) {
      return this.compareWithNumber(r, Operators.greaterthan);
    }
    if (Utilities.instance_of(r, XBoolean)) {
      return this.compareWithBoolean(r, Operators.greaterthan);
    }
    return this.compareWithNodeSet(r, Operators.greaterthan);
  };

  XNodeSet.prototype.lessthanorequal = function (r) {
    if (Utilities.instance_of(r, XString)) {
      return this.compareWithNumber(r.number(), Operators.lessthanorequal);
    }
    if (Utilities.instance_of(r, XNumber)) {
      return this.compareWithNumber(r, Operators.lessthanorequal);
    }
    if (Utilities.instance_of(r, XBoolean)) {
      return this.compareWithBoolean(r, Operators.lessthanorequal);
    }
    return this.compareWithNodeSet(r, Operators.lessthanorequal);
  };

  XNodeSet.prototype.greaterthanorequal = function (r) {
    if (Utilities.instance_of(r, XString)) {
      return this.compareWithNumber(r.number(), Operators.greaterthanorequal);
    }
    if (Utilities.instance_of(r, XNumber)) {
      return this.compareWithNumber(r, Operators.greaterthanorequal);
    }
    if (Utilities.instance_of(r, XBoolean)) {
      return this.compareWithBoolean(r, Operators.greaterthanorequal);
    }
    return this.compareWithNodeSet(r, Operators.greaterthanorequal);
  };

  XNodeSet.prototype.union = function (r) {
    var ns = new XNodeSet();
    ns.tree = this.tree;
    ns.size = this.size;
    ns.addArray(r.toArray());
    return ns;
  };

// Operators /////////////////////////////////////////////////////////////////

  var Operators = new Object();

  Operators.equals = function (l, r) {
    return l.equals(r);
  };

  Operators.notequal = function (l, r) {
    return l.notequal(r);
  };

  Operators.lessthan = function (l, r) {
    return l.lessthan(r);
  };

  Operators.greaterthan = function (l, r) {
    return l.greaterthan(r);
  };

  Operators.lessthanorequal = function (l, r) {
    return l.lessthanorequal(r);
  };

  Operators.greaterthanorequal = function (l, r) {
    return l.greaterthanorequal(r);
  };

// XPathContext //////////////////////////////////////////////////////////////

  XPathContext.prototype = new Object();
  XPathContext.prototype.constructor = XPathContext;
  XPathContext.superclass = Object.prototype;

  function XPathContext(vr, nr, fr) {
    this.variableResolver = vr != null ? vr : new VariableResolver();
    this.namespaceResolver = nr != null ? nr : new NamespaceResolver();
    this.functionResolver = fr != null ? fr : new FunctionResolver();
  }

// VariableResolver //////////////////////////////////////////////////////////

  VariableResolver.prototype = new Object();
  VariableResolver.prototype.constructor = VariableResolver;
  VariableResolver.superclass = Object.prototype;

  function VariableResolver() {
  }

  VariableResolver.prototype.getVariable = function (vn, c) {
    var parts = Utilities.splitQName(vn);
    if (parts[0] != null) {
      parts[0] = c.namespaceResolver.getNamespace(parts[0], c.expressionContextNode);
      if (parts[0] == null) {
        throw new Error("Cannot resolve QName " + fn);
      }
    }
    return this.getVariableWithName(parts[0], parts[1], c.expressionContextNode);
  };

  VariableResolver.prototype.getVariableWithName = function (ns, ln, c) {
    return null;
  };

// NamespaceResolver //////////////////////////////////////////////////////////

  NamespaceResolver.prototype = new Object();
  NamespaceResolver.prototype.constructor = NamespaceResolver;
  NamespaceResolver.superclass = Object.prototype;

  function NamespaceResolver() {
  }

  NamespaceResolver.prototype.getNamespace = function (prefix, n) {
    if (prefix == "xml") {
      return XPath.XML_NAMESPACE_URI;
    } else if (prefix == "xmlns") {
      return XPath.XMLNS_NAMESPACE_URI;
    }
    if (n.nodeType() == 9 /*Node.DOCUMENT_NODE*/) {
      n = n.documentElement();
    } else if (n.nodeType() == 2 /*Node.ATTRIBUTE_NODE*/) {
      n = PathExpr.prototype.getOwnerElement(n);
    } else if (n.nodeType() != 1 /*Node.ELEMENT_NODE*/) {
      n = n.parentNode();
    }
    while (n != null && n.nodeType() == 1 /*Node.ELEMENT_NODE*/) {
      var nnm = n.attributes();
      for (var i = 0; i < nnm.length; i++) {
        var a = nnm.item(i);
        var aname = a.nodeName();
        if (aname == "xmlns" && prefix == ""
          || aname == "xmlns:" + prefix) {
          return String(a.nodeValue());
        }
      }
      n = n.parentNode();
    }
    return null;
  };

// FunctionResolver //////////////////////////////////////////////////////////

  FunctionResolver.prototype = new Object();
  FunctionResolver.prototype.constructor = FunctionResolver;
  FunctionResolver.superclass = Object.prototype;

  function FunctionResolver(thisArg) {
    this.thisArg = thisArg != null ? thisArg : Functions;
    this.functions = new Object();
    this.addStandardFunctions();
  }

  FunctionResolver.prototype.addFunction = function (ns, ln, f) {
    this.functions["{" + ns + "}" + ln] = f;
  };

  FunctionResolver.prototype.getFunction = function (fn, c) {
    var parts = Utilities.resolveQName(fn, c.namespaceResolver, c.contextNode, false);
    if (parts[0] == null) {
      throw new Error("Cannot resolve QName " + fn);
    }
    return this.getFunctionWithName(parts[0], parts[1], c.contextNode);
  };

  FunctionResolver.prototype.getFunctionWithName = function (ns, ln, c) {
    return this.functions["{" + ns + "}" + ln];
  };

    FunctionResolver.customFunctions = {};
    FunctionResolver.addCustomFunction = function (ns, ln, fn) {
        var func = function () { return null; };
        eval('func = ' + fn.toString());
        this.customFunctions["{" + (ns ? ns : '') + "}" + ln] = func;
    };

  FunctionResolver.toString = function (fn) {
    var source = fn.toString().replace(/^\s+|\s+$/g, '');
    var args = source.match(/function[^(]+\(([^)]+)\)\s+\{/);
    args = args ? args[1].match(/[a-zA-Z0-9_]+/g) : [];
  };

  FunctionResolver.prototype.addStandardFunctions = function () {
    this.functions["{}last"] = Functions.last;
    this.functions["{}position"] = Functions.position;
    this.functions["{}count"] = Functions.count;
    this.functions["{}match"] = Functions.match;
    this.functions["{}replace"] = Functions.replace;
    this.functions["{}id"] = Functions.id;
    this.functions["{}name"] = Functions.name;
    this.functions["{}string"] = Functions.string;
    this.functions["{}concat"] = Functions.concat;
    this.functions["{}starts-with"] = Functions.startsWith;
    this.functions["{}contains"] = Functions.contains;
    this.functions["{}substring-before"] = Functions.substringBefore;
    this.functions["{}substring-after"] = Functions.substringAfter;
    this.functions["{}substring"] = Functions.substring;
    this.functions["{}string-length"] = Functions.stringLength;
    this.functions["{}normalize-space"] = Functions.normalizeSpace;
    this.functions["{}translate"] = Functions.translate;
    this.functions["{}boolean"] = Functions.boolean_;
    this.functions["{}not"] = Functions.not;
    this.functions["{}true"] = Functions.true_;
    this.functions["{}false"] = Functions.false_;
    this.functions["{}lang"] = Functions.lang;
    this.functions["{}number"] = Functions.number;
    this.functions["{}sum"] = Functions.sum;
    this.functions["{}floor"] = Functions.floor;
    this.functions["{}ceiling"] = Functions.ceiling;
    this.functions["{}round"] = Functions.round;
    for (var key in FunctionResolver.customFunctions) {
      if (FunctionResolver.customFunctions.hasOwnProperty(key)) {
        this.functions[key] = FunctionResolver.customFunctions[key];
      }
    }
  };

// Functions /////////////////////////////////////////////////////////////////

  Functions = new Object();

  Functions.last = function () {
    var c = arguments[0];
    if (arguments.length != 1) {
      throw new Error("Function last expects ()");
    }
    return new XNumber(c.contextSize);
  };

  Functions.position = function () {
    var c = arguments[0];
    if (arguments.length != 1) {
      throw new Error("Function position expects ()");
    }
    return new XNumber(c.contextPosition);
  };

  Functions.count = function () {
    var c = arguments[0];
    var ns;
    if (arguments.length != 2 || !Utilities.instance_of(ns = arguments[1].evaluate(c), XNodeSet)) {
      throw new Error("Function count expects (node-set)");
    }
    return new XNumber(ns.size);
  };

  Functions.match = function () {
    var c = arguments[0];
    if (arguments.length !== 3 && arguments.length !== 4) {
      throw new Error("Function match expects ({string}source, {string}expression, {string}modifiers)");
    }
    var source = arguments[1].evaluate(c).stringValue().toString();
    var expression = arguments[2].evaluate(c).stringValue();
    var modifiers = arguments.length === 4 ? arguments[3].evaluate(c).stringValue() : '';
    var regex = new RegExp(expression, modifiers);
    return new XBoolean(regex.test(source));
  };

  Functions.replace = function () {
    var c = arguments[0];
    if (arguments.length != 4 && arguments.length != 5) {
      throw new Error("Function replace expects ({string}source, {string}find, {string}replace, {string}modifiers)");
    }
    var source = arguments[1].evaluate(c).stringValue();
    var find = arguments[2].evaluate(c).stringValue();
    var replace = arguments[3].evaluate(c).stringValue();
    var modifiers = arguments.length === 5 ? arguments[4].evaluate(c).stringValue() : '';
    var regex = new RegExp(find, modifiers);
    return new XString(source.replace(regex, replace));
  };

  Functions.id = function () {
    var c = arguments[0];
    var id;
    if (arguments.length != 2) {
      throw new Error("Function id expects (object)");
    }
    id = arguments[1].evaluate(c);
    if (Utilities.instance_of(id, XNodeSet)) {
      id = id.toArray().join(" ");
    } else {
      id = id.stringValue();
    }
    var ids = id.split(/[\x0d\x0a\x09\x20]+/);
    var count = 0;
    var ns = new XNodeSet();
    var doc = c.contextNode.nodeType() == 9 /*Node.DOCUMENT_NODE*/
      ? c.contextNode
      : c.contextNode.ownerDocument();
    for (var i = 0; i < ids.length; i++) {
      var n;
      if (doc.getElementById) {
        n = doc.getElementById(ids[i]);
      } else {
        n = Utilities.getElementById(doc, ids[i]);
      }
      if (n != null) {
        ns.add(n);
        count++;
      }
    }
    return ns;
  };

  Functions.name = function () {
    var c = arguments[0];
    var n;
    if (arguments.length == 1) {
      n = c.contextNode;
    } else if (arguments.length == 2) {
      n = arguments[1].evaluate(c).first();
    } else {
      throw new Error("Function name expects (node-set?)");
    }
    if (n == null) {
      return new XString("");
    }
    if (n.nodeType() == 1 /*Node.ELEMENT_NODE*/ || n.nodeType() == 2 /*Node.ATTRIBUTE_NODE*/) {
      return new XString(n.nodeName());
    } else if (n.localName() == null) {
      return new XString("");
    } else {
      return new XString(n.localName());
    }
  };

  Functions.string = function () {
    var c = arguments[0];
    if (arguments.length == 1) {
      return XNodeSet.prototype.stringForNode(c.contextNode);
    } else if (arguments.length == 2) {
      return arguments[1].evaluate(c).string();
    }
    throw new Error("Function string expects (object?)");
  };

  Functions.concat = function () {
    var c = arguments[0];
    if (arguments.length < 3) {
      throw new Error("Function concat expects (string, string, string*)");
    }
    var s = "";
    for (var i = 1; i < arguments.length; i++) {
      s += arguments[i].evaluate(c).stringValue();
    }
    return new XString(s);
  };

  Functions.startsWith = function () {
    var c = arguments[0];
    if (arguments.length != 3) {
      throw new Error("Function startsWith expects (string, string)");
    }
    var s1 = arguments[1].evaluate(c).stringValue();
    var s2 = arguments[2].evaluate(c).stringValue();
    return new XBoolean(s1.substring(0, s2.length) == s2);
  };

  Functions.contains = function () {
    var c = arguments[0];
    if (arguments.length != 3) {
      throw new Error("Function contains expects (string, string)");
    }
    var s1 = arguments[1].evaluate(c).stringValue();
    var s2 = arguments[2].evaluate(c).stringValue();
    return new XBoolean(s1.indexOf(s2) != -1);
  };

  Functions.substringBefore = function () {
    var c = arguments[0];
    if (arguments.length != 3) {
      throw new Error("Function substring-before expects (string, string)");
    }
    var s1 = arguments[1].evaluate(c).stringValue();
    var s2 = arguments[2].evaluate(c).stringValue();
    return new XString(s1.substring(0, s1.indexOf(s2)));
  };

  Functions.substringAfter = function () {
    var c = arguments[0];
    if (arguments.length != 3) {
      throw new Error("Function substring-after expects (string, string)");
    }
    var s1 = arguments[1].evaluate(c).stringValue();
    var s2 = arguments[2].evaluate(c).stringValue();
    if (s2.length == 0) {
      return new XString(s1);
    }
    var i = s1.indexOf(s2);
    if (i == -1) {
      return new XString("");
    }
    return new XString(s1.substring(s1.indexOf(s2) + 1));
  };

  Functions.substring = function () {
    var c = arguments[0];
    if (!(arguments.length == 3 || arguments.length == 4)) {
      throw new Error("Function substring expects (string, number, number?)");
    }
    var s = arguments[1].evaluate(c).stringValue();
    var n1 = Math.round(arguments[2].evaluate(c).numberValue()) - 1;
    var n2 = arguments.length == 4 ? n1 + Math.round(arguments[3].evaluate(c).numberValue()) : undefined;
    return new XString(s.substring(n1, n2));
  };

  Functions.stringLength = function () {
    var c = arguments[0];
    var s;
    if (arguments.length == 1) {
      s = XNodeSet.prototype.stringForNode(c.contextNode);
    } else if (arguments.length == 2) {
      s = arguments[1].evaluate(c).stringValue();
    } else {
      throw new Error("Function string-length expects (string?)");
    }
    return new XNumber(s.length);
  };

  Functions.normalizeSpace = function () {
    var c = arguments[0];
    var s;
    if (arguments.length == 1) {
      s = XNodeSet.prototype.stringForNode(c.contextNode);
    } else if (arguments.length == 2) {
      s = arguments[1].evaluate(c).stringValue();
    } else {
      throw new Error("Function normalize-space expects (string?)");
    }
    var i = 0;
    var j = s.length - 1;
    while (Utilities.isSpace(s.charCodeAt(j))) {
      j--;
    }
    var t = "";
    while (i <= j && Utilities.isSpace(s.charCodeAt(i))) {
      i++;
    }
    while (i <= j) {
      if (Utilities.isSpace(s.charCodeAt(i))) {
        t += " ";
        while (i <= j && Utilities.isSpace(s.charCodeAt(i))) {
          i++;
        }
      } else {
        t += s.charAt(i);
        i++;
      }
    }
    return new XString(t);
  };

  Functions.translate = function () {
    var c = arguments[0];
    if (arguments.length != 4) {
      throw new Error("Function translate expects (string, string, string)");
    }
    var s1 = arguments[1].evaluate(c).stringValue();
    var s2 = arguments[2].evaluate(c).stringValue();
    var s3 = arguments[3].evaluate(c).stringValue();
    var map = [];
    for (var i = 0; i < s2.length; i++) {
      var j = s2.charCodeAt(i);
      if (map[j] == undefined) {
        var k = i > s3.length ? "" : s3.charAt(i);
        map[j] = k;
      }
    }
    var t = "";
    for (var i = 0; i < s1.length; i++) {
      var c = s1.charCodeAt(i);
      var r = map[c];
      if (r == undefined) {
        t += s1.charAt(i);
      } else {
        t += r;
      }
    }
    return new XString(t);
  };

  Functions.boolean_ = function () {
    var c = arguments[0];
    if (arguments.length != 2) {
      throw new Error("Function boolean expects (object)");
    }
    return arguments[1].evaluate(c).bool();
  };

  Functions.not = function () {
    var c = arguments[0];
    if (arguments.length != 2) {
      throw new Error("Function not expects (object)");
    }
    return arguments[1].evaluate(c).bool().not();
  };

  Functions.true_ = function () {
    if (arguments.length != 1) {
      throw new Error("Function true expects ()");
    }
    return new XBoolean(true);
  };

  Functions.false_ = function () {
    if (arguments.length != 1) {
      throw new Error("Function false expects ()");
    }
    return new XBoolean(false);
  };

  Functions.lang = function () {
    var c = arguments[0];
    if (arguments.length != 2) {
      throw new Error("Function lang expects (string)");
    }
    var lang;
    for (var n = c.contextNode; n != null && n.nodeType() != 9 /*Node.DOCUMENT_NODE*/; n = n.parentNode()) {
      var a = n.getAttributeNS(XPath.XML_NAMESPACE_URI, "lang");
      if (a != null) {
        lang = String(a);
        break;
      }
    }
    if (lang == null) {
      return new XBoolean(false);
    }
    var s = arguments[1].evaluate(c).stringValue();
    return new XBoolean(lang.substring(0, s.length) == s
      && (lang.length == s.length || lang.charAt(s.length) == '-'));
  };

  Functions.number = function () {
    var c = arguments[0];
    if (!(arguments.length == 1 || arguments.length == 2)) {
      throw new Error("Function number expects (object?)");
    }
    if (arguments.length == 1) {
      return new XNumber(XNodeSet.prototype.stringForNode(c.contextNode));
    }
    return arguments[1].evaluate(c).number();
  };

  Functions.sum = function () {
    var c = arguments[0];
    var ns;
    if (arguments.length != 2 || !Utilities.instance_of((ns = arguments[1].evaluate(c)), XNodeSet)) {
      throw new Error("Function sum expects (node-set)");
    }
    ns = ns.toArray();
    var n = 0;
    for (var i = 0; i < ns.length; i++) {
      n += new XNumber(XNodeSet.prototype.stringForNode(ns[i])).numberValue();
    }
    return new XNumber(n);
  };

  Functions.floor = function () {
    var c = arguments[0];
    if (arguments.length != 2) {
      throw new Error("Function floor expects (number)");
    }
    return new XNumber(Math.floor(arguments[1].evaluate(c).numberValue()));
  };

  Functions.ceiling = function () {
    var c = arguments[0];
    if (arguments.length != 2) {
      throw new Error("Function ceiling expects (number)");
    }
    return new XNumber(Math.ceil(arguments[1].evaluate(c).numberValue()));
  };

  Functions.round = function () {
    var c = arguments[0];
    if (arguments.length != 2) {
      throw new Error("Function round expects (number)");
    }
    return new XNumber(Math.round(arguments[1].evaluate(c).numberValue()));
  };

// Utilities /////////////////////////////////////////////////////////////////

  Utilities = new Object();

  Utilities.splitQName = function (qn) {
    if (!qn)
      return ""; //this.toString();
    var i = qn.indexOf(":");
    if (i == -1) {
      return [null, qn];
    }
    return [qn.substring(0, i), qn.substring(i + 1)];
  };

  Utilities.resolveQName = function (qn, nr, n, useDefault) {
    var parts = Utilities.splitQName(qn);
    if (parts[0] != null) {
      var ns = nr.getNamespace(parts[0], n);
      parts[0] = ns ? ns : parts[0];
    } else {
      if (useDefault) {
        parts[0] = nr.getNamespace("", n);
        if (parts[0] == null) {
          parts[0] = "";
        }
      } else {
        parts[0] = "";
      }
    }
    return parts;
  };

  Utilities.isSpace = function (c) {
    return c == 0x9 || c == 0xd || c == 0xa || c == 0x20;
  };

  Utilities.isLetter = function (c) {
    return c >= 0x0041 && c <= 0x005A ||
      c >= 0x0061 && c <= 0x007A ||
      c >= 0x00C0 && c <= 0x00D6 ||
      c >= 0x00D8 && c <= 0x00F6 ||
      c >= 0x00F8 && c <= 0x00FF ||
      c >= 0x0100 && c <= 0x0131 ||
      c >= 0x0134 && c <= 0x013E ||
      c >= 0x0141 && c <= 0x0148 ||
      c >= 0x014A && c <= 0x017E ||
      c >= 0x0180 && c <= 0x01C3 ||
      c >= 0x01CD && c <= 0x01F0 ||
      c >= 0x01F4 && c <= 0x01F5 ||
      c >= 0x01FA && c <= 0x0217 ||
      c >= 0x0250 && c <= 0x02A8 ||
      c >= 0x02BB && c <= 0x02C1 ||
      c == 0x0386 ||
      c >= 0x0388 && c <= 0x038A ||
      c == 0x038C ||
      c >= 0x038E && c <= 0x03A1 ||
      c >= 0x03A3 && c <= 0x03CE ||
      c >= 0x03D0 && c <= 0x03D6 ||
      c == 0x03DA ||
      c == 0x03DC ||
      c == 0x03DE ||
      c == 0x03E0 ||
      c >= 0x03E2 && c <= 0x03F3 ||
      c >= 0x0401 && c <= 0x040C ||
      c >= 0x040E && c <= 0x044F ||
      c >= 0x0451 && c <= 0x045C ||
      c >= 0x045E && c <= 0x0481 ||
      c >= 0x0490 && c <= 0x04C4 ||
      c >= 0x04C7 && c <= 0x04C8 ||
      c >= 0x04CB && c <= 0x04CC ||
      c >= 0x04D0 && c <= 0x04EB ||
      c >= 0x04EE && c <= 0x04F5 ||
      c >= 0x04F8 && c <= 0x04F9 ||
      c >= 0x0531 && c <= 0x0556 ||
      c == 0x0559 ||
      c >= 0x0561 && c <= 0x0586 ||
      c >= 0x05D0 && c <= 0x05EA ||
      c >= 0x05F0 && c <= 0x05F2 ||
      c >= 0x0621 && c <= 0x063A ||
      c >= 0x0641 && c <= 0x064A ||
      c >= 0x0671 && c <= 0x06B7 ||
      c >= 0x06BA && c <= 0x06BE ||
      c >= 0x06C0 && c <= 0x06CE ||
      c >= 0x06D0 && c <= 0x06D3 ||
      c == 0x06D5 ||
      c >= 0x06E5 && c <= 0x06E6 ||
      c >= 0x0905 && c <= 0x0939 ||
      c == 0x093D ||
      c >= 0x0958 && c <= 0x0961 ||
      c >= 0x0985 && c <= 0x098C ||
      c >= 0x098F && c <= 0x0990 ||
      c >= 0x0993 && c <= 0x09A8 ||
      c >= 0x09AA && c <= 0x09B0 ||
      c == 0x09B2 ||
      c >= 0x09B6 && c <= 0x09B9 ||
      c >= 0x09DC && c <= 0x09DD ||
      c >= 0x09DF && c <= 0x09E1 ||
      c >= 0x09F0 && c <= 0x09F1 ||
      c >= 0x0A05 && c <= 0x0A0A ||
      c >= 0x0A0F && c <= 0x0A10 ||
      c >= 0x0A13 && c <= 0x0A28 ||
      c >= 0x0A2A && c <= 0x0A30 ||
      c >= 0x0A32 && c <= 0x0A33 ||
      c >= 0x0A35 && c <= 0x0A36 ||
      c >= 0x0A38 && c <= 0x0A39 ||
      c >= 0x0A59 && c <= 0x0A5C ||
      c == 0x0A5E ||
      c >= 0x0A72 && c <= 0x0A74 ||
      c >= 0x0A85 && c <= 0x0A8B ||
      c == 0x0A8D ||
      c >= 0x0A8F && c <= 0x0A91 ||
      c >= 0x0A93 && c <= 0x0AA8 ||
      c >= 0x0AAA && c <= 0x0AB0 ||
      c >= 0x0AB2 && c <= 0x0AB3 ||
      c >= 0x0AB5 && c <= 0x0AB9 ||
      c == 0x0ABD ||
      c == 0x0AE0 ||
      c >= 0x0B05 && c <= 0x0B0C ||
      c >= 0x0B0F && c <= 0x0B10 ||
      c >= 0x0B13 && c <= 0x0B28 ||
      c >= 0x0B2A && c <= 0x0B30 ||
      c >= 0x0B32 && c <= 0x0B33 ||
      c >= 0x0B36 && c <= 0x0B39 ||
      c == 0x0B3D ||
      c >= 0x0B5C && c <= 0x0B5D ||
      c >= 0x0B5F && c <= 0x0B61 ||
      c >= 0x0B85 && c <= 0x0B8A ||
      c >= 0x0B8E && c <= 0x0B90 ||
      c >= 0x0B92 && c <= 0x0B95 ||
      c >= 0x0B99 && c <= 0x0B9A ||
      c == 0x0B9C ||
      c >= 0x0B9E && c <= 0x0B9F ||
      c >= 0x0BA3 && c <= 0x0BA4 ||
      c >= 0x0BA8 && c <= 0x0BAA ||
      c >= 0x0BAE && c <= 0x0BB5 ||
      c >= 0x0BB7 && c <= 0x0BB9 ||
      c >= 0x0C05 && c <= 0x0C0C ||
      c >= 0x0C0E && c <= 0x0C10 ||
      c >= 0x0C12 && c <= 0x0C28 ||
      c >= 0x0C2A && c <= 0x0C33 ||
      c >= 0x0C35 && c <= 0x0C39 ||
      c >= 0x0C60 && c <= 0x0C61 ||
      c >= 0x0C85 && c <= 0x0C8C ||
      c >= 0x0C8E && c <= 0x0C90 ||
      c >= 0x0C92 && c <= 0x0CA8 ||
      c >= 0x0CAA && c <= 0x0CB3 ||
      c >= 0x0CB5 && c <= 0x0CB9 ||
      c == 0x0CDE ||
      c >= 0x0CE0 && c <= 0x0CE1 ||
      c >= 0x0D05 && c <= 0x0D0C ||
      c >= 0x0D0E && c <= 0x0D10 ||
      c >= 0x0D12 && c <= 0x0D28 ||
      c >= 0x0D2A && c <= 0x0D39 ||
      c >= 0x0D60 && c <= 0x0D61 ||
      c >= 0x0E01 && c <= 0x0E2E ||
      c == 0x0E30 ||
      c >= 0x0E32 && c <= 0x0E33 ||
      c >= 0x0E40 && c <= 0x0E45 ||
      c >= 0x0E81 && c <= 0x0E82 ||
      c == 0x0E84 ||
      c >= 0x0E87 && c <= 0x0E88 ||
      c == 0x0E8A ||
      c == 0x0E8D ||
      c >= 0x0E94 && c <= 0x0E97 ||
      c >= 0x0E99 && c <= 0x0E9F ||
      c >= 0x0EA1 && c <= 0x0EA3 ||
      c == 0x0EA5 ||
      c == 0x0EA7 ||
      c >= 0x0EAA && c <= 0x0EAB ||
      c >= 0x0EAD && c <= 0x0EAE ||
      c == 0x0EB0 ||
      c >= 0x0EB2 && c <= 0x0EB3 ||
      c == 0x0EBD ||
      c >= 0x0EC0 && c <= 0x0EC4 ||
      c >= 0x0F40 && c <= 0x0F47 ||
      c >= 0x0F49 && c <= 0x0F69 ||
      c >= 0x10A0 && c <= 0x10C5 ||
      c >= 0x10D0 && c <= 0x10F6 ||
      c == 0x1100 ||
      c >= 0x1102 && c <= 0x1103 ||
      c >= 0x1105 && c <= 0x1107 ||
      c == 0x1109 ||
      c >= 0x110B && c <= 0x110C ||
      c >= 0x110E && c <= 0x1112 ||
      c == 0x113C ||
      c == 0x113E ||
      c == 0x1140 ||
      c == 0x114C ||
      c == 0x114E ||
      c == 0x1150 ||
      c >= 0x1154 && c <= 0x1155 ||
      c == 0x1159 ||
      c >= 0x115F && c <= 0x1161 ||
      c == 0x1163 ||
      c == 0x1165 ||
      c == 0x1167 ||
      c == 0x1169 ||
      c >= 0x116D && c <= 0x116E ||
      c >= 0x1172 && c <= 0x1173 ||
      c == 0x1175 ||
      c == 0x119E ||
      c == 0x11A8 ||
      c == 0x11AB ||
      c >= 0x11AE && c <= 0x11AF ||
      c >= 0x11B7 && c <= 0x11B8 ||
      c == 0x11BA ||
      c >= 0x11BC && c <= 0x11C2 ||
      c == 0x11EB ||
      c == 0x11F0 ||
      c == 0x11F9 ||
      c >= 0x1E00 && c <= 0x1E9B ||
      c >= 0x1EA0 && c <= 0x1EF9 ||
      c >= 0x1F00 && c <= 0x1F15 ||
      c >= 0x1F18 && c <= 0x1F1D ||
      c >= 0x1F20 && c <= 0x1F45 ||
      c >= 0x1F48 && c <= 0x1F4D ||
      c >= 0x1F50 && c <= 0x1F57 ||
      c == 0x1F59 ||
      c == 0x1F5B ||
      c == 0x1F5D ||
      c >= 0x1F5F && c <= 0x1F7D ||
      c >= 0x1F80 && c <= 0x1FB4 ||
      c >= 0x1FB6 && c <= 0x1FBC ||
      c == 0x1FBE ||
      c >= 0x1FC2 && c <= 0x1FC4 ||
      c >= 0x1FC6 && c <= 0x1FCC ||
      c >= 0x1FD0 && c <= 0x1FD3 ||
      c >= 0x1FD6 && c <= 0x1FDB ||
      c >= 0x1FE0 && c <= 0x1FEC ||
      c >= 0x1FF2 && c <= 0x1FF4 ||
      c >= 0x1FF6 && c <= 0x1FFC ||
      c == 0x2126 ||
      c >= 0x212A && c <= 0x212B ||
      c == 0x212E ||
      c >= 0x2180 && c <= 0x2182 ||
      c >= 0x3041 && c <= 0x3094 ||
      c >= 0x30A1 && c <= 0x30FA ||
      c >= 0x3105 && c <= 0x312C ||
      c >= 0xAC00 && c <= 0xD7A3 ||
      c >= 0x4E00 && c <= 0x9FA5 ||
      c == 0x3007 ||
      c >= 0x3021 && c <= 0x3029;
  };

  Utilities.isNCNameChar = function (c) {
    return c >= 0x0030 && c <= 0x0039
      || c >= 0x0660 && c <= 0x0669
      || c >= 0x06F0 && c <= 0x06F9
      || c >= 0x0966 && c <= 0x096F
      || c >= 0x09E6 && c <= 0x09EF
      || c >= 0x0A66 && c <= 0x0A6F
      || c >= 0x0AE6 && c <= 0x0AEF
      || c >= 0x0B66 && c <= 0x0B6F
      || c >= 0x0BE7 && c <= 0x0BEF
      || c >= 0x0C66 && c <= 0x0C6F
      || c >= 0x0CE6 && c <= 0x0CEF
      || c >= 0x0D66 && c <= 0x0D6F
      || c >= 0x0E50 && c <= 0x0E59
      || c >= 0x0ED0 && c <= 0x0ED9
      || c >= 0x0F20 && c <= 0x0F29
      || c == 0x002E
      || c == 0x002D
      || c == 0x005F
      || Utilities.isLetter(c)
      || c >= 0x0300 && c <= 0x0345
      || c >= 0x0360 && c <= 0x0361
      || c >= 0x0483 && c <= 0x0486
      || c >= 0x0591 && c <= 0x05A1
      || c >= 0x05A3 && c <= 0x05B9
      || c >= 0x05BB && c <= 0x05BD
      || c == 0x05BF
      || c >= 0x05C1 && c <= 0x05C2
      || c == 0x05C4
      || c >= 0x064B && c <= 0x0652
      || c == 0x0670
      || c >= 0x06D6 && c <= 0x06DC
      || c >= 0x06DD && c <= 0x06DF
      || c >= 0x06E0 && c <= 0x06E4
      || c >= 0x06E7 && c <= 0x06E8
      || c >= 0x06EA && c <= 0x06ED
      || c >= 0x0901 && c <= 0x0903
      || c == 0x093C
      || c >= 0x093E && c <= 0x094C
      || c == 0x094D
      || c >= 0x0951 && c <= 0x0954
      || c >= 0x0962 && c <= 0x0963
      || c >= 0x0981 && c <= 0x0983
      || c == 0x09BC
      || c == 0x09BE
      || c == 0x09BF
      || c >= 0x09C0 && c <= 0x09C4
      || c >= 0x09C7 && c <= 0x09C8
      || c >= 0x09CB && c <= 0x09CD
      || c == 0x09D7
      || c >= 0x09E2 && c <= 0x09E3
      || c == 0x0A02
      || c == 0x0A3C
      || c == 0x0A3E
      || c == 0x0A3F
      || c >= 0x0A40 && c <= 0x0A42
      || c >= 0x0A47 && c <= 0x0A48
      || c >= 0x0A4B && c <= 0x0A4D
      || c >= 0x0A70 && c <= 0x0A71
      || c >= 0x0A81 && c <= 0x0A83
      || c == 0x0ABC
      || c >= 0x0ABE && c <= 0x0AC5
      || c >= 0x0AC7 && c <= 0x0AC9
      || c >= 0x0ACB && c <= 0x0ACD
      || c >= 0x0B01 && c <= 0x0B03
      || c == 0x0B3C
      || c >= 0x0B3E && c <= 0x0B43
      || c >= 0x0B47 && c <= 0x0B48
      || c >= 0x0B4B && c <= 0x0B4D
      || c >= 0x0B56 && c <= 0x0B57
      || c >= 0x0B82 && c <= 0x0B83
      || c >= 0x0BBE && c <= 0x0BC2
      || c >= 0x0BC6 && c <= 0x0BC8
      || c >= 0x0BCA && c <= 0x0BCD
      || c == 0x0BD7
      || c >= 0x0C01 && c <= 0x0C03
      || c >= 0x0C3E && c <= 0x0C44
      || c >= 0x0C46 && c <= 0x0C48
      || c >= 0x0C4A && c <= 0x0C4D
      || c >= 0x0C55 && c <= 0x0C56
      || c >= 0x0C82 && c <= 0x0C83
      || c >= 0x0CBE && c <= 0x0CC4
      || c >= 0x0CC6 && c <= 0x0CC8
      || c >= 0x0CCA && c <= 0x0CCD
      || c >= 0x0CD5 && c <= 0x0CD6
      || c >= 0x0D02 && c <= 0x0D03
      || c >= 0x0D3E && c <= 0x0D43
      || c >= 0x0D46 && c <= 0x0D48
      || c >= 0x0D4A && c <= 0x0D4D
      || c == 0x0D57
      || c == 0x0E31
      || c >= 0x0E34 && c <= 0x0E3A
      || c >= 0x0E47 && c <= 0x0E4E
      || c == 0x0EB1
      || c >= 0x0EB4 && c <= 0x0EB9
      || c >= 0x0EBB && c <= 0x0EBC
      || c >= 0x0EC8 && c <= 0x0ECD
      || c >= 0x0F18 && c <= 0x0F19
      || c == 0x0F35
      || c == 0x0F37
      || c == 0x0F39
      || c == 0x0F3E
      || c == 0x0F3F
      || c >= 0x0F71 && c <= 0x0F84
      || c >= 0x0F86 && c <= 0x0F8B
      || c >= 0x0F90 && c <= 0x0F95
      || c == 0x0F97
      || c >= 0x0F99 && c <= 0x0FAD
      || c >= 0x0FB1 && c <= 0x0FB7
      || c == 0x0FB9
      || c >= 0x20D0 && c <= 0x20DC
      || c == 0x20E1
      || c >= 0x302A && c <= 0x302F
      || c == 0x3099
      || c == 0x309A
      || c == 0x00B7
      || c == 0x02D0
      || c == 0x02D1
      || c == 0x0387
      || c == 0x0640
      || c == 0x0E46
      || c == 0x0EC6
      || c == 0x3005
      || c >= 0x3031 && c <= 0x3035
      || c >= 0x309D && c <= 0x309E
      || c >= 0x30FC && c <= 0x30FE;
  };

  Utilities.coalesceText = function (n) {
    for (var m = n.firstChild(); m != null; m = m.nextSibling()) {
      if (m.nodeType() == 3 /*Node.TEXT_NODE*/ || m.nodeType() == 4 /*Node.CDATA_SECTION_NODE*/) {
        var s = m.nodeValue();
        var first = m;
        m = m.nextSibling();
        while (m != null && (m.nodeType() == 3 /*Node.TEXT_NODE*/ || m.nodeType() == 4 /*Node.CDATA_SECTION_NODE*/)) {
          s += m.nodeValue();
          var del = m;
          m = m.nextSibling();
          del.parentNode().removeChild(del);
        }
        if (first.nodeType() == 4 /*Node.CDATA_SECTION_NODE*/) {
          var p = first.parentNode();
          if (first.nextSibling() == null) {
            p.removeChild(first);
            p.appendChild(p.ownerDocument().createTextNode(s));
          } else {
            var next = first.nextSibling();
            p.removeChild(first);
            p.insertBefore(p.ownerDocument().createTextNode(s), next);
          }
        } else {
          first.nodeValue(s);
        }
        if (m == null) {
          break;
        }
      } else if (m.nodeType() == 1 /*Node.ELEMENT_NODE*/) {
        Utilities.coalesceText(m);
      }
    }
  };

  Utilities.constructorName = function (o) {
    if (o.name) {
      return o.name;
    }
    var name = o.toString().match(/function ([^( ]+)+/);
    return name ? name[1] : undefined;
  };

  Utilities.instance_of = function (o, c) {
    while (o != null) {
      if (Utilities.constructorName(o.constructor) === Utilities.constructorName(c)) {
        return true;
      }
      if (o === Object) {
        return false;
      }
      o = o.constructor.superclass;
    }
    return false;
  };

  Utilities.getElementById = function (n, id) {
    // Note that this does not check the DTD to check for actual
    // attributes of type ID, so this may be a bit wrong.
    if (n.nodeType() == 1 /*Node.ELEMENT_NODE*/) {
      if (n.getAttribute("id") == id
        || n.getAttributeNS(null, "id") == id) {
        return n;
      }
    }
    for (var m = n.firstChild(); m != null; m = m.nextSibling()) {
      var res = Utilities.getElementById(m, id);
      if (res != null) {
        return res;
      }
    }
    return null;
  };

// XPathException ////////////////////////////////////////////////////////////

  XPathException.prototype = {};
  XPathException.prototype.constructor = XPathException;
  XPathException.superclass = Object.prototype;

  function XPathException(c, e) {
    this.code = c;
    this.exception = e;
  }

  XPathException.prototype.toString = function () {
    var msg = this.exception ? ": " + this.exception.toString() : "";
    switch (this.code) {
      case XPathException.INVALID_EXPRESSION_ERR:
        return "Invalid expression" + msg;
      case XPathException.TYPE_ERR:
        return "Type error" + msg;
    }
  };

  XPathException.INVALID_EXPRESSION_ERR = 51;
  XPathException.TYPE_ERR = 52;

// XPathExpression ///////////////////////////////////////////////////////////

  XPathExpression.prototype = {};
  XPathExpression.prototype.constructor = XPathExpression;
  XPathExpression.superclass = Object.prototype;

  function XPathExpression(expression, r, xpathParser) {
    this.xpath = xpathParser.parse(expression);
    this.context = new XPathContext();
    this.context.namespaceResolver = new XPathNSResolverWrapper(r);
  }

  XPathExpression.prototype.evaluate = function (node, xpathType, res) {
    this.context.expressionContextNode = node;
    var result = this.xpath.evaluate(this.context);
    return new XPathResult(result, xpathType);
  };

// XPathNSResolverWrapper ////////////////////////////////////////////////////

  XPathNSResolverWrapper.prototype = {};
  XPathNSResolverWrapper.prototype.constructor = XPathNSResolverWrapper;
  XPathNSResolverWrapper.superclass = Object.prototype;

  function XPathNSResolverWrapper(r) {
    this.xpathNSResolver = r;
  }

  XPathNSResolverWrapper.prototype.getNamespace = function (prefix, n) {
    if (this.xpathNSResolver == null) {
      return null;
    }
    return this.xpathNSResolver.lookupNamespaceURI(prefix);
  };

// NodeXPathNSResolver ///////////////////////////////////////////////////////

  NodeXPathNSResolver.prototype = {};
  NodeXPathNSResolver.prototype.constructor = NodeXPathNSResolver;
  NodeXPathNSResolver.superclass = Object.prototype;

  function NodeXPathNSResolver(n) {
    this.node = n;
    this.namespaceResolver = new NamespaceResolver();
  }

  NodeXPathNSResolver.prototype.lookupNamespaceURI = function (prefix) {
    return this.namespaceResolver.getNamespace(prefix, this.node);
  };

// XPathResult ///////////////////////////////////////////////////////////////

  XPathResult.prototype = {};
  XPathResult.prototype.constructor = XPathResult;
  XPathResult.superclass = Object.prototype;

  function XPathResult(v, t) {
    if (t == XPathResult.ANY_TYPE) {
      if (v.constructor === XString) {
        t = XPathResult.STRING_TYPE;
      } else if (v.constructor === XNumber) {
        t = XPathResult.NUMBER_TYPE;
      } else if (v.constructor === XBoolean) {
        t = XPathResult.BOOLEAN_TYPE;
      } else if (v.constructor === XNodeSet) {
        t = XPathResult.UNORDERED_NODE_ITERATOR_TYPE;
      }
    }
    this.resultType = t;
    switch (t) {
      case XPathResult.NUMBER_TYPE:
        this.numberValue = v.numberValue();
        return;
      case XPathResult.STRING_TYPE:
        this.stringValue = v.stringValue();
        return;
      case XPathResult.BOOLEAN_TYPE:
        this.booleanValue = v.booleanValue();
        return;
      case XPathResult.ANY_UNORDERED_NODE_TYPE:
      case XPathResult.FIRST_ORDERED_NODE_TYPE:
        if (v.constructor === XNodeSet) {
          this.singleNodeValue = v.first();
          return;
        }
        break;
      case XPathResult.UNORDERED_NODE_ITERATOR_TYPE:
      case XPathResult.ORDERED_NODE_ITERATOR_TYPE:
        if (v.constructor === XNodeSet) {
          this.invalidIteratorState = false;
          this.nodes = v.toArray();
          this.iteratorIndex = 0;
          return;
        }
        break;
      case XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE:
      case XPathResult.ORDERED_NODE_SNAPSHOT_TYPE:
        if (v.constructor === XNodeSet) {
          this.nodes = v.toArray();
          this.snapshotLength = this.nodes.length;
          return;
        }
        break;
    }
    throw new XPathException(XPathException.TYPE_ERR);
  };

  XPathResult.prototype.iterateNext = function () {
    if (this.resultType != XPathResult.UNORDERED_NODE_ITERATOR_TYPE
      && this.resultType != XPathResult.ORDERED_NODE_ITERATOR_TYPE) {
      throw new XPathException(XPathException.TYPE_ERR);
    }
    return this.nodes[this.iteratorIndex++];
  };

  XPathResult.prototype.snapshotItem = function (i) {
    if (this.resultType != XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE
      && this.resultType != XPathResult.ORDERED_NODE_SNAPSHOT_TYPE) {
      throw new XPathException(XPathException.TYPE_ERR);
    }
    return this.nodes[i];
  };

  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;

  function select(expression, doc, single, mappings) {
    XPathExpression.mappings = mappings;
    var expression = new XPathExpression(expression, null, new XPathParser());
    var type = XPathResult.ANY_TYPE;

    var result = expression.evaluate(doc, type, null);

    if (result.resultType == XPathResult.STRING_TYPE) {
      result = result.stringValue;
    }
    else if (result.resultType == XPathResult.NUMBER_TYPE) {
      result = result.numberValue;
    }
    else if (result.resultType == XPathResult.BOOLEAN_TYPE) {
      result = result.booleanValue;
    }
    else {
      result = result.nodes;
      if (single) {
        result = result[0];
      }
    }

    return result;
  }

  /**
   * jselement.js
   */

  /**
   * Object.keys polyfill
   * @param obj
   * @returns {Array}
   */
  function objectKeys(obj) {
    if (typeof Object.keys === "function") {
      return Object.keys(obj);
    } else {
      var keys = [];
      for (var key in obj) {
        if (obj.hasOwnProperty(key)) {
          keys.push(key);
        }
      }
      return keys;
    }
  }

  /**
   * Array forEach iterator / map polyfill all in one
   * @param array
   * @param func
   * @param scope
   * @returns {Array}
   */
  function each(array, func, scope) {
    var map = [], keys, i;
    if (array instanceof Array) {
      for (i = 0; i < array.length; i++) {
        map.push(func.call(scope || array, array[i], i));
      }
    } else {
      keys = objectKeys(array);
      for (i = 0; i < keys.length; i++) {
        map.push(func.call(scope || array, array[keys[i]], keys[i]));
      }
    }
    return map;
  }

  function NamedNode(nodeName, childNodes) {
    this.nodeName = nodeName;
    this.childNodes = childNodes;
  }

  function UserNode(nodeName, value) {
    this.nodeName = nodeName;
    this.value = value;
  }

  UserNode.prototype = {
    constructor: UserNode,
    toValue: function () {
      return this.value;
    }
  };

  /**
   * Mirrors DOCUMENT_NODE Dom interface
   * @param node
   * @constructor
   */
  function Document(node, options) {
    this._schema = {};
    this._map = {};
    this._node = node;

    each(defaultSchema, function (value, key) {
      this._schema[key] = value;
    }, this);

    if (typeof options === 'object' && options !== null) {
      if (options.hasOwnProperty('schema')) this.schema(options.schema);
      if (options.hasOwnProperty('map')) this.map(options.map);
    }
  }

  Document.prototype = {
    init: function (node) {
      this.node = new Node(node, null, this);
      this.cache = {
        childNodes: [this.node]
      };
      return this;
    },
    schema: function (schema) {
      if (typeof schema === "object") {
        each(schema, function (value, key) {
          this._schema[key] = value;
        }, this);
      }
      return this;
    },
    map: function (map) {
      this._map = map;
      return this;
    },
    nodeType: function () {
      return 9; // DOCUMENT_NODE
    },
    documentElement: function () {
      return this.node;
    },
    nodeName: function () {
      return "#document";
    },
    localName: function () {
      return this.nodeName();
    },
    firstChild: function () {
      return this.node;
    },
    nextSibling: function () {
      return null;
    },
    previousSibling: function () {
      return null;
    },
    childNodes: function () {
      return this.cache.childNodes;
    },
    parentNode: function () {
      return null;
    },
    attributes: function () {
      return this.node.attributes();
    },
    nodeValue: function () {
      return this._node;
    },
    selectAll: function (xpath) {
      this.init(typeof this._schema.onPreProcess === "function" ? this._schema.onPreProcess.call(this, this._node) : this._node);
      if (typeof this._schema.onPreProcess === "function") {
        this.__node = this._node;
        this._node = this.node.node;
      }
      var result = select(xpath, this, false, this._map);
      if (result instanceof Array) {
        // convert wrapped nodes to original node values
        result = each(result, function (node) {
          return node.toValue();
        });
        // add an each property to the array for enumeration
        try {
          // modern
          Object.defineProperty(result, "each", {
            enumerable: false,
            value: function (iterator, scope) {
              return each(result, iterator, scope);
            }
          });
        } catch (e) {
          // old skool
          result.each = function (iterator, scope) {
            return each(result, iterator, scope);
          };
        }
      }
      if (typeof this._schema.onPreProcess === "function") {
        this._node = this.__node;
      }
      if (typeof this._schema.onPostProcess === "function") {
        result = this._schema.onPostProcess.call(this, result);
      }
      return result;
    },
    select: function (xpath) {
      var result = this.selectAll(xpath);
      if (result instanceof Array) {
        return result.length ? result[0] : null;
      }
      return result;
    },
    dispose: function (restore) {
      var node, schema, map;
      if (restore === true) {
        node = this.node.node;
        schema = this._schema;
        map = this._map;
      }
      this.node.dispose();
      if (restore) {
        this.init(node);
      }
      this._schema = schema;
      this._map = map;
    }
  };

  /**
   * Mirrors ELEMENT_NODE Dom interface
   * @param node
   * @param parentNode
   * @param ownerDocument
   * @constructor
   */
  function Node(node, parentNode, ownerDocument) {
    this.node = node;
    this.cache = {
      ownerDocument: ownerDocument,
      parentNode: parentNode
    };
  }

  Node.prototype = {
    nodeType: function () {
      return 1; // ELEMENT_NODE
    },
    ownerDocument: function () {
      return this.cache.ownerDocument;
    },
    root: function () {
      return this.cache.ownerDocument.nodeValue();
    },
    adapter: function (propertyName) {
      if (typeof this.cache.ownerDocument._schema[propertyName] === "function") {
        return this.cache.ownerDocument._schema[propertyName].call(this, this.node);
      } else if (typeof this.cache.ownerDocument._schema[propertyName] === "string") {
        return this.node[this.cache.ownerDocument._schema[propertyName]];
      } else {
        return null;
      }
    },
    childNodes: function () {
      if (typeof this.cache.childNodes === "undefined") {
        var childNodes = this.adapter("childNodes"),
          nodeValue = this.adapter("nodeValue"),
          node;
        this.cache.childNodes = [];
        if (childNodes) {
          each(childNodes, function (childNode) {
            if (childNode instanceof NamedNode) {
              node = new Node(childNode.childNodes, this, this.cache.ownerDocument);
              node.cache.nodeName = childNode.nodeName;
              this.cache.childNodes.push(node);
            } else {
              this.cache.childNodes.push(new Node(childNode, this, this.cache.ownerDocument));
            }
          }, this);
        }
        if (nodeValue) {
          node = new Text(nodeValue, this, this.cache.ownerDocument);
          this.cache.childNodes.splice(0, 0, node);
        }
      }
      return this.cache.childNodes;
    },
    parentNode: function () {
      return this.cache.parentNode;
    },
    getIndex: function () {
      if (typeof this.cache.index !== "number") {
        if (!this.cache.parentNode) {
          this.cache.index = 0;
        } else {
          var array = this.parentNode().childNodes(), i;
          for (i = 0; i < array.length; i++) {
            if (array[i] === this) {
              this.cache.index = i;
              break;
            }
          }
        }
      }
      return this.cache.index;
    },
    firstChild: function () {
      var childNodes = this.childNodes();
      return childNodes.length > 0 ? childNodes[0] : null;
    },
    nextSibling: function () {
      if (!this.cache.parentNode) {
        return null;
      } else {
        var childNodes = this.parentNode().childNodes(),
          index = this.getIndex();
        return index < childNodes.length - 1 ? childNodes[index + 1] : null;
      }
    },
    previousSibling: function () {
      if (!this.cache.parentNode) {
        return null;
      } else {
        var childNodes = this.parentNode().childNodes(),
          index = this.getIndex();
        return index > 0 ? childNodes[index - 1] : null;
      }
    },
    nodeName: function () {
      if (!this.cache.nodeName) {
        this.cache.nodeName = this.adapter("nodeName");
      }
      return this.cache.nodeName;
    },
    localName: function () {
      return this.nodeName();
    },
    nodeValue: function () {
      if (typeof this.cache.nodeValue === "undefined") {
        this.cache.nodeValue = this.adapter("nodeValue");
      }
      return this.cache.nodeValue;
    },
    getAttribute: function (key) {
      var attributes = this.attributes();
      if (attributes !== null) {
        return attributes.values[key];
      }
      return null;
    },
    getAttributeNS: function (key) {
      return this.getAttribute(key);
    },
    attributes: function () {
      if (typeof this.cache.attributes === "undefined") {
        var attributes = this.adapter("attributes"),
          keys = null,
          self = this;
        if (attributes) {
          keys = objectKeys(attributes);
          this.cache.attributes = {
            length: keys.length,
            values: attributes,
            item: function (index) {
              return new Attrib(keys[index],
                attributes[keys[index]], self);
            }
          };
        } else {
          this.cache.attributes = null;
        }
      }
      return this.cache.attributes;
    },
    toValue: function () {
      if (this.node instanceof UserNode) {
        return this.node.toValue();
      }
      return this.node;
    },
    dispose: function () {
      // dispose all children recursively
      if (this.cache.childNodes) {
        each(this.cache.childNodes, function (childNode) {
          childNode.dispose();
        });
      }
      // unbind parent
      if (this.cache.parentNode) {
        delete this.cache.parentNode;
      }
      // unbind cached values
      each(this.cache, function (value, key) {
        delete this.cache[key];
      }, this);
      // unbind node
      delete this.node;
    }
  };

  /**
   * Mirrors ATTRIBUTE_NODE Dom interface
   * @param name
   * @param value
   * @param parentNode
   * @constructor
   */
  function Attrib(name, value, parentNode) {
    this.name = name;
    this.value = value;
    this.cache = {
      parentNode: parentNode
    }
  }

  Attrib.prototype = {
    nodeType: function () {
      return 2; // ATTRIBUTE_NODE
    },
    nodeName: function () {
      return this.name;
    },
    localName: function () {
      return this.nodeName();
    },
    nodeValue: function () {
      return this.value;
    },
    parentNode: function () {
      return this.cache.parentNode;
    },
    toValue: function () {
      return this.value;
    },
    previousSibling: function () {
      return null;
    },
    nextSibling: function () {
      return null;
    },
    firstChild: function () {
      return null;
    }
  };

  /**
   * Mirrors TEXT_NODE Dom interface
   * @param txt
   * @param parentNode
   * @param ownerDocument
   * @constructor
   */
  function Text(txt, parentNode, ownerDocument) {
    this.txt = txt;
    this.cache = {
      ownerDocument: ownerDocument,
      parentNode: parentNode
    }
  }

  Text.prototype = new Node();
  Text.prototype.constructor = Text;
  Text.prototype.nodeType = function () {
    return 3; // TEXT_NODE
  };
  Text.prototype.nodeName = function () {
    return "#text";
  };
  Text.prototype.nodeValue = function () {
    return this.txt;
  };
  Text.prototype.childNodes = function () {
    return null;
  };
  Text.prototype.firstChild = function () {
    return null;
  };
  Text.prototype.toValue = function () {
    return this.txt;
  };

  /**
   * default schema
   */
  var defaultSchema = {
    /**
     * return the name of the given node
     * @param {*} node
     * @returns {string}
     */
    nodeName: function (node) {
      if (node instanceof NamedNode) {
        return node.nodeName;
      }
      return node instanceof Array ? "array" : typeof node;
    },
    /**
     * return an object with key:values representing the given nodes attributes
     * @param {*} node
     * @returns {Object}
     */
    attributes: function (node) {
      if (node instanceof NamedNode) {
        return null;
      }
      var attribs = {}, typeOf, value;
      for (var key in node) {
        if (node.hasOwnProperty(key)) {
          value = node[key];
          typeOf = typeof value;
          if (typeOf === "string"
            || typeOf === "number"
            || typeOf === "string"
            || typeOf === "boolean"
            || typeOf === "function"
            || value instanceof Date
            || value instanceof RegExp) {
            attribs[key] = value;
          }
        }
      }
      return attribs;
    },
    /**
     * return an array of the children of the given node
     * @param {*} node
     * @returns {Array}
     */
    childNodes: function (node) {
      if (node instanceof NamedNode) {
        return node.childNodes;
      }
      if (node instanceof Array) {
        return node;
      }
      var children = [], typeOf, value;
      for (var key in node) {
        if (node.hasOwnProperty(key)) {
          value = node[key];
          typeOf = typeof value;
          if ((typeOf === "object" && value !== null) || value instanceof Array) {
            children.push(new NamedNode(key, value));
          }
        }
      }
      return children;
    },
    /**
     * return the low-level value of the given node
     * @param {*} node
     * @returns {*}
     */
    nodeValue: function (node) {
      if ((typeof node !== "object" && node !== null) && !(node instanceof Array)) {
        return node;
      } else {
        return null;
      }
    }
  };

  var jsel = function (node) {
    return new Document(node);
  };

  jsel.UserNode = function (nodeName, value) {
    return new UserNode(nodeName, value);
  };

  jsel.NamedNode = function (nodeName, childNodes) {
    return new NamedNode(nodeName, childNodes);
  };

  jsel.isNode = function (obj, nodeName) {
    if (!nodeName) {
      return obj instanceof UserNode;
    }
    return obj instanceof UserNode && obj.nodeName === nodeName;
  };

  jsel.schema = {
    Default: defaultSchema
  };

  jsel.addFunction = function (ns, name, fn) {
    FunctionResolver.addCustomFunction(ns, name, fn);
  };

  return jsel;
})();

if (typeof module !== 'undefined') {
  module.exports = jsel;
}