selenium-webdriver 0.0.9 → 0.0.10

data/common/src/js/core/xpath/javascript-xpath-0.1.11.js

@@ -0,0 +1,2816 @@
+/*  JavaScript-XPath 0.1.11
+ *  (c) 2007 Cybozu Labs, Inc.
+ *
+ *  JavaScript-XPath is freely distributable under the terms of an MIT-style license.
+ *  For details, see the JavaScript-XPath web site: http://coderepos.org/share/wiki/JavaScript-XPath
+ *
+/*--------------------------------------------------------------------------*/
+
+
+
+(function () {
+
+var undefined = void(0);
+
+var defaultConfig = {
+    targetFrame: undefined,
+    exportInstaller: false,
+    useNative: true,
+    useInnerText: true
+};
+
+var config;
+
+if (window.jsxpath) {
+    config = window.jsxpath;
+}
+else {
+    var scriptElms = document.getElementsByTagName('script');
+    var scriptElm = scriptElms[scriptElms.length - 1];
+    var scriptSrc = scriptElm.src;
+    config = {};
+    var scriptSrcMatchResult = scriptSrc.match(/\?(.*)$/);
+    if (scriptSrcMatchResult) {
+        var configStrings = scriptSrcMatchResult[1].split('&');
+        for (var i = 0, l = configStrings.length; i < l; i ++) {
+            var configString = configStrings[i];
+            var configStringSplited = configString.split('=');
+            var configName = configStringSplited[0];
+            var configValue = configStringSplited[1];
+            if (configValue == undefined) {
+                configValue == true;
+            }
+            else if (configValue == 'false' || /^-?\d+$/.test(configValue)) {
+                configValue = eval(configValue);
+            }
+            config[configName] = configValue;
+        }
+    }
+}
+
+for (var n in defaultConfig) {
+    if (!(n in config)) config[n] = defaultConfig[n];
+}
+
+config.hasNative = !!(document.implementation
+                        && document.implementation.hasFeature
+                        && document.implementation.hasFeature("XPath", null));
+
+if (config.hasNative && config.useNative && !config.exportInstaller) {
+    return;
+}
+
+
+
+var BinaryExpr;
+var FilterExpr;
+var FunctionCall;
+var Literal;
+var NameTest;
+var NodeSet;
+var NodeType;
+var NodeUtil;
+var Number;
+var PathExpr;
+var Step;
+var UnaryExpr;
+var UnionExpr;
+var VariableReference;
+
+/*
+ * object: user agent identifier
+ */
+var uai = new function() {
+
+    var ua = navigator.userAgent;
+
+    if (RegExp == undefined) {
+        if (ua.indexOf("Opera") >= 0) {
+            this.opera = true;
+        } else if (ua.indexOf("Netscape") >= 0) {
+            this.netscape = true;
+        } else if (ua.indexOf("Mozilla/") == 0) {
+            this.mozilla = true;
+        } else {
+            this.unknown = true;
+        }
+
+        if (ua.indexOf("Gecko/") >= 0) {
+            this.gecko = true;
+        }
+
+        if (ua.indexOf("Win") >= 0) {
+            this.windows = true;
+        } else if (ua.indexOf("Mac") >= 0) {
+            this.mac = true;
+        } else if (ua.indexOf("Linux") >= 0) {
+            this.linux = true;
+        } else if (ua.indexOf("BSD") >= 0) {
+            this.bsd = true;
+        } else if (ua.indexOf("SunOS") >= 0) {
+            this.sunos = true;
+        }
+    }
+    else {
+
+        /* for Trident/Tasman */
+        /*@cc_on
+        @if (@_jscript)
+            function jscriptVersion() {
+                switch (@_jscript_version) {
+                    case 3.0:  return "4.0";
+                    case 5.0:  return "5.0";
+                    case 5.1:  return "5.01";
+                    case 5.5:  return "5.5";
+                    case 5.6:
+                        if ("XMLHttpRequest" in window) return "7.0";
+                        return "6.0";
+                    case 5.7:
+                        return "7.0";
+                    default:   return true;
+                }
+            }
+            if (@_win16 || @_win32 || @_win64) {
+                this.windows = true;
+                this.trident = jscriptVersion();
+            } else if (@_mac || navigator.platform.indexOf("Mac") >= 0) {
+                // '@_mac' may be 'NaN' even if the platform is Mac,
+                // so we check 'navigator.platform', too.
+                this.mac = true;
+                this.tasman = jscriptVersion();
+            }
+            if (/MSIE (\d+\.\d+)b?;/.test(ua)) {
+                this.ie = RegExp.$1;
+                this['ie' + RegExp.$1.charAt(0)] = true;
+            }
+        @else @*/
+
+        /* for AppleWebKit */
+        if (/AppleWebKit\/(\d+(?:\.\d+)*)/.test(ua)) {
+            this.applewebkit = RegExp.$1;
+            if (RegExp.$1.charAt(0) == 4) {
+                this.applewebkit2 = true;
+            }
+            else {
+                this.applewebkit3 = true;
+            }
+        }
+
+        /* for Gecko */
+        else if (typeof Components == "object" &&
+                 (/Gecko\/(\d{8})/.test(ua) ||
+                  navigator.product == "Gecko" && /^(\d{8})$/.test(navigator.productSub))) {
+            this.gecko = RegExp.$1;
+        }
+
+        /*@end @*/
+
+        if (typeof(opera) == "object" && typeof(opera.version) == "function") {
+            this.opera = opera.version();
+            this['opera' + this.opera[0] + this.opera[2]] = true;
+        } else if (typeof opera == "object"
+                && (/Opera[\/ ](\d+\.\d+)/.test(ua))) {
+            this.opera = RegExp.$1;
+        } else if (this.ie) {
+        } else if (/Safari\/(\d+(?:\.\d+)*)/.test(ua)) {
+            this.safari = RegExp.$1;
+        } else if (/NetFront\/(\d+(?:\.\d+)*)/.test(ua)) {
+            this.netfront = RegExp.$1;
+        } else if (/Konqueror\/(\d+(?:\.\d+)*)/.test(ua)) {
+            this.konqueror = RegExp.$1;
+        } else if (ua.indexOf("(compatible;") < 0
+                && (/^Mozilla\/(\d+\.\d+)/.test(ua))) {
+            this.mozilla = RegExp.$1;
+            if (/\([^(]*rv:(\d+(?:\.\d+)*).*?\)/.test(ua))
+                this.mozillarv = RegExp.$1;
+            if (/Firefox\/(\d+(?:\.\d+)*)/.test(ua)) {
+                this.firefox = RegExp.$1;
+            } else if (/Netscape\d?\/(\d+(?:\.\d+)*)/.test(ua)) {
+                this.netscape = RegExp.$1;
+            }
+        } else {
+            this.unknown = true;
+        }
+
+        if (ua.indexOf("Win 9x 4.90") >= 0) {
+            this.windows = "ME";
+        } else if (/Win(?:dows)? ?(NT ?(\d+\.\d+)?|\d+|ME|Vista|XP)/.test(ua)) {
+            this.windows = RegExp.$1;
+            if (RegExp.$2) {
+                this.winnt = RegExp.$2;
+            } else switch (RegExp.$1) {
+                case "2000":   this.winnt = "5.0";  break;
+                case "XP":     this.winnt = "5.1";  break;
+                case "Vista":  this.winnt = "6.0";  break;
+            }
+        } else if (ua.indexOf("Mac") >= 0) {
+            this.mac = true;
+        } else if (ua.indexOf("Linux") >= 0) {
+            this.linux = true;
+        } else if (/(\w*BSD)/.test(ua)) {
+            this.bsd = RegExp.$1;
+        } else if (ua.indexOf("SunOS") >= 0) {
+            this.sunos = true;
+        }
+    }
+};
+
+
+/**
+ * pseudo class: Lexer
+ */
+var Lexer = function(source) {
+    var proto = Lexer.prototype;
+    var tokens = source.match(proto.regs.token);
+    for (var i = 0, l = tokens.length; i < l; i ++) {
+        if (proto.regs.strip.test(tokens[i])) {
+            tokens.splice(i, 1);
+        }
+    }
+    for (var n in proto) tokens[n] = proto[n];
+    tokens.index = 0;
+    return tokens;
+};
+
+Lexer.prototype.regs = {
+    token: /\$?(?:(?![0-9-])[\w-]+:)?(?![0-9-])[\w-]+|\/\/|\.\.|::|\d+(?:\.\d*)?|\.\d+|"[^"]*"|'[^']*'|[!<>]=|(?![0-9-])[\w-]+:\*|\s+|./g,
+    strip: /^\s/
+};
+
+Lexer.prototype.peek = function(i) {
+    return this[this.index + (i||0)];
+};
+Lexer.prototype.next = function() {
+    return this[this.index++];
+};
+Lexer.prototype.back = function() {
+    this.index--;
+};
+Lexer.prototype.empty = function() {
+    return this.length <= this.index;
+};
+
+
+/**
+ * class: Ctx
+ */
+var Ctx = function(node, position, last) {
+    this.node = node;
+    this.position = position || 1;
+    this.last = last || 1;
+};
+
+
+/**
+ * abstract class: BaseExpr
+ */
+var BaseExpr = function() {};
+
+BaseExpr.prototype.number = function(ctx) {
+    var exrs = this.evaluate(ctx);
+    if (exrs.isNodeSet) return exrs.number();
+    return + exrs;
+};
+
+BaseExpr.prototype.string = function(ctx) {
+    var exrs = this.evaluate(ctx);
+    if (exrs.isNodeSet) return exrs.string();
+    return '' + exrs;
+};
+
+BaseExpr.prototype.bool = function(ctx) {
+    var exrs = this.evaluate(ctx);
+    if (exrs.isNodeSet) return exrs.bool();
+    return !! exrs;
+};
+
+
+/**
+ * abstract class: BaseExprHasPredicates
+ */
+var BaseExprHasPredicates = function() {};
+
+BaseExprHasPredicates.parsePredicates = function(lexer, expr) {
+    while (lexer.peek() == '[') {
+        lexer.next();
+        if (lexer.empty()) {
+            throw Error('missing predicate expr');
+        }
+        var predicate = BinaryExpr.parse(lexer);
+        expr.predicate(predicate);
+        if (lexer.empty()) {
+            throw Error('unclosed predicate expr');
+        }
+        if (lexer.next() != ']') {
+            lexer.back();
+            throw Error('bad token: ' + lexer.next());
+        }
+    }
+};
+
+BaseExprHasPredicates.prototyps = new BaseExpr();
+
+BaseExprHasPredicates.prototype.evaluatePredicates = function(nodeset, start) {
+    var predicates, predicate, nodes, node, nodeset, position, reverse;
+
+    reverse = this.reverse;
+    predicates = this.predicates;
+
+    nodeset.sort();
+
+    for (var i = start || 0, l0 = predicates.length; i < l0; i ++) {
+        predicate = predicates[i];
+
+        var deleteIndexes = [];
+        var nodes = nodeset.list();
+
+        for (var j = 0, l1 = nodes.length; j < l1; j ++) {
+
+            position = reverse ? (l1 - j) : (j + 1);
+            exrs = predicate.evaluate(new Ctx(nodes[j], position, l1));
+
+            switch (typeof exrs) {
+                case 'number':
+                    exrs = (position == exrs);
+                    break;
+                case 'string':
+                    exrs = !!exrs;
+                    break;
+                case 'object':
+                    exrs = exrs.bool();
+                    break;
+            }
+
+            if (!exrs) {
+                deleteIndexes.push(j);
+            }
+        }
+
+        for (var j = deleteIndexes.length - 1, l1 = 0; j >= l1; j --) {
+            nodeset.del(deleteIndexes[j]);
+        }
+
+    }
+
+    return nodeset;
+};
+
+
+/**
+ * class: BinaryExpr
+ */
+if (!window.BinaryExpr && window.defaultConfig)
+    window.BinaryExpr = null;
+
+BinaryExpr = function(op, left, right, datatype) {
+    this.op = op;
+    this.left = left;
+    this.right = right;
+
+    this.datatype = BinaryExpr.ops[op][2];
+
+    this.needContextPosition = left.needContextPosition || right.needContextPosition;
+    this.needContextNode = left.needContextNode || right.needContextNode;
+
+    // Optimize [@id="foo"] and [@name="bar"]
+    if (this.op == '=') {
+        if (!right.needContextNode && !right.needContextPosition && 
+            right.datatype != 'nodeset' && right.datatype != 'void' && left.quickAttr) {
+            this.quickAttr = true;
+            this.attrName = left.attrName;
+            this.attrValueExpr = right;
+        }
+        else if (!left.needContextNode && !left.needContextPosition && 
+            left.datatype != 'nodeset' && left.datatype != 'void' && right.quickAttr) {
+            this.quickAttr = true;
+            this.attrName = right.attrName;
+            this.attrValueExpr = left;
+        }
+    }
+};
+
+BinaryExpr.compare = function(op, comp, left, right, ctx) {
+    var type, lnodes, rnodes, nodes, nodeset, primitive;
+
+    left = left.evaluate(ctx);
+    right = right.evaluate(ctx);
+
+    if (left.isNodeSet && right.isNodeSet) {
+        lnodes = left.list();
+        rnodes = right.list();
+        for (var i = 0, l0 = lnodes.length; i < l0; i ++)
+            for (var j = 0, l1 = rnodes.length; j < l1; j ++)
+                if (comp(NodeUtil.to('string', lnodes[i]), NodeUtil.to('string', rnodes[j])))
+                    return true;
+        return false;
+    }
+
+    if (left.isNodeSet || right.isNodeSet) {
+        if (left.isNodeSet)
+            nodeset = left, primitive = right;
+        else
+            nodeset = right, primitive = left;
+
+        nodes = nodeset.list();
+        type = typeof primitive;
+        for (var i = 0, l = nodes.length; i < l; i ++) {
+            if (comp(NodeUtil.to(type, nodes[i]), primitive))
+                return true;
+        }
+        return false;
+    }
+
+    if (op == '=' || op == '!=') {
+        if (typeof left == 'boolean' || typeof right == 'boolean') {
+            return comp(!!left, !!right);
+        }
+        if (typeof left == 'number' || typeof right == 'number') {
+            return comp(+left, +right);
+        }
+        return comp(left, right);
+    }
+
+    return comp(+left, +right);
+};
+
+
+BinaryExpr.ops = {
+    'div': [6, function(left, right, ctx) {
+        return left.number(ctx) / right.number(ctx);
+    }, 'number'],
+    'mod': [6, function(left, right, ctx) {
+        return left.number(ctx) % right.number(ctx);
+    }, 'number'],
+    '*': [6, function(left, right, ctx) {
+        return left.number(ctx) * right.number(ctx);
+    }, 'number'],
+    '+': [5, function(left, right, ctx) {
+        return left.number(ctx) + right.number(ctx);
+    }, 'number'],
+    '-': [5, function(left, right, ctx) {
+        return left.number(ctx) - right.number(ctx);
+    }, 'number'],
+    '<': [4, function(left, right, ctx) {
+        return BinaryExpr.compare('<',
+                    function(a, b) { return a < b }, left, right, ctx);
+    }, 'boolean'],
+    '>': [4, function(left, right, ctx) {
+        return BinaryExpr.compare('>',
+                    function(a, b) { return a > b }, left, right, ctx);
+    }, 'boolean'],
+    '<=': [4, function(left, right, ctx) {
+        return BinaryExpr.compare('<=',
+                    function(a, b) { return a <= b }, left, right, ctx);
+    }, 'boolean'],
+    '>=': [4, function(left, right, ctx) {
+        return BinaryExpr.compare('>=',
+                    function(a, b) { return a >= b }, left, right, ctx);
+    }, 'boolean'],
+    '=': [3, function(left, right, ctx) {
+        return BinaryExpr.compare('=',
+                    function(a, b) { return a == b }, left, right, ctx);
+    }, 'boolean'],
+    '!=': [3, function(left, right, ctx) {
+        return BinaryExpr.compare('!=',
+                    function(a, b) { return a != b }, left, right, ctx);
+    }, 'boolean'],
+    'and': [2, function(left, right, ctx) {
+        return left.bool(ctx) && right.bool(ctx);
+    }, 'boolean'],
+    'or': [1, function(left, right, ctx) {
+        return left.bool(ctx) || right.bool(ctx);
+    }, 'boolean']
+};
+
+
+BinaryExpr.parse = function(lexer) {
+    var op, precedence, info, expr, stack = [], index = lexer.index;
+
+    while (true) {
+
+        if (lexer.empty()) {
+            throw Error('missing right expression');
+        }
+        expr = UnaryExpr.parse(lexer);
+
+        op = lexer.next();
+        if (!op) {
+            break;
+        }
+
+        info = this.ops[op];
+        precedence = info && info[0];
+        if (!precedence) {
+            lexer.back();
+            break;
+        }
+
+        while (stack.length && precedence <= this.ops[stack[stack.length-1]][0]) {
+            expr = new BinaryExpr(stack.pop(), stack.pop(), expr);
+        }
+
+        stack.push(expr, op);
+    }
+
+    while (stack.length) {
+        expr = new BinaryExpr(stack.pop(), stack.pop(), expr);
+    }
+
+    return expr;
+};
+
+BinaryExpr.prototype = new BaseExpr();
+
+BinaryExpr.prototype.evaluate = function(ctx) {
+    return BinaryExpr.ops[this.op][1](this.left, this.right, ctx);
+};
+
+BinaryExpr.prototype.show = function(indent) {
+    indent = indent || '';
+    var t = '';
+    t += indent + 'binary: ' + this.op + '\n';
+    indent += '    ';
+    t += this.left.show(indent);
+    t += this.right.show(indent);
+    return t;
+};
+
+
+/**
+ * class: UnaryExpr
+ */
+if (!window.UnaryExpr && window.defaultConfig)
+    window.UnaryExpr = null;
+
+UnaryExpr = function(op, expr) {
+    this.op = op;
+    this.expr = expr;
+
+    this.needContextPosition = expr.needContextPosition;
+    this.needContextNode = expr.needContextNode;
+};
+
+UnaryExpr.ops = { '-': 1 };
+
+UnaryExpr.parse = function(lexer) {
+    var token;
+    if (this.ops[lexer.peek()])
+        return new UnaryExpr(lexer.next(), UnaryExpr.parse(lexer));
+    else
+        return UnionExpr.parse(lexer);
+};
+
+UnaryExpr.prototype = new BaseExpr();
+
+UnaryExpr.prototype.datatype = 'number';
+
+UnaryExpr.prototype.evaluate = function(ctx) {
+    return - this.expr.number(ctx);
+};
+
+UnaryExpr.prototype.show = function(indent) {
+    indent = indent || '';
+    var t = '';
+    t += indent + 'unary: ' + this.op + '\n';
+    indent += '    ';
+    t += this.expr.show(indent);
+    return t;
+};
+
+
+/**
+ * class: UnionExpr
+ */
+if (!window.UnionExpr && window.defaultConfig)
+    window.UnionExpr = null;
+
+UnionExpr = function() {
+    this.paths = [];
+};
+
+UnionExpr.ops = { '|': 1 };
+
+
+UnionExpr.parse = function(lexer) {
+    var union, expr;
+
+    expr = PathExpr.parse(lexer);
+    if (!this.ops[lexer.peek()])
+        return expr;
+
+    union = new UnionExpr();
+    union.path(expr);
+
+    while (true) {
+        if (!this.ops[lexer.next()]) break;
+        if (lexer.empty()) {
+            throw Error('missing next union location path');
+        }
+        union.path(PathExpr.parse(lexer));
+    }
+
+
+
+    lexer.back();
+    return union;
+};
+
+UnionExpr.prototype = new BaseExpr();
+
+UnionExpr.prototype.datatype = 'nodeset';
+
+UnionExpr.prototype.evaluate = function(ctx) {
+    var paths = this.paths;
+    var nodeset = new NodeSet();
+    for (var i = 0, l = paths.length; i < l; i ++) {
+        var exrs = paths[i].evaluate(ctx);
+        if (!exrs.isNodeSet) throw Error('PathExpr must be nodeset');
+        nodeset.merge(exrs);
+    }
+    return nodeset;
+};
+
+UnionExpr.prototype.path = function(path) {
+    this.paths.push(path);
+
+    if (path.needContextPosition) {
+        this.needContextPosition = true;
+    }
+    if (path.needContextNode) {
+        this.needContextNode = true;
+    }
+}
+UnionExpr.prototype.show = function(indent) {
+    indent = indent || '';
+    var t = '';
+    t += indent + 'union:' + '\n';
+    indent += '    ';
+    for (var i = 0; i < this.paths.length; i ++) {
+        t += this.paths[i].show(indent);
+    }
+    return t;
+};
+
+
+/**
+ * class: PathExpr
+ */
+if (!window.PathExpr && window.defaultConfig)
+    window.PathExpr = null;
+
+PathExpr = function(filter) {
+    this.filter = filter;
+    this.steps = [];
+
+    this.datatype = filter.datatype;
+
+    this.needContextPosition = filter.needContextPosition;
+    this.needContextNode = filter.needContextNode;
+};
+
+PathExpr.ops = { '//': 1, '/': 1 };
+
+PathExpr.parse = function(lexer) {
+    var op, expr, path, token;
+
+    if (this.ops[lexer.peek()]) {
+        op = lexer.next();
+        token = lexer.peek();
+
+        if (op == '/' && (lexer.empty() || 
+                (token != '.' && token != '..' && token != '@' && token != '*' && 
+                !/(?![0-9])[\w]/.test(token)))) { 
+            return FilterExpr.root();
+        }
+
+        path = new PathExpr(FilterExpr.root()); // RootExpr
+
+        if (lexer.empty()) {
+            throw Error('missing next location step');
+        }
+        expr = Step.parse(lexer);
+        path.step(op, expr);
+    }
+    else {
+        expr = FilterExpr.parse(lexer);
+        if (!expr) {
+            expr = Step.parse(lexer);
+            path = new PathExpr(FilterExpr.context());
+            path.step('/', expr);
+        }
+        else if (!this.ops[lexer.peek()])
+            return expr;
+        else
+            path = new PathExpr(expr);
+    }
+
+    while (true) {
+        if (!this.ops[lexer.peek()]) break;
+        op = lexer.next();
+        if (lexer.empty()) {
+            throw Error('missing next location step');
+        }
+        path.step(op, Step.parse(lexer));
+    }
+
+    return path;
+};
+
+PathExpr.prototype = new BaseExpr();
+
+PathExpr.prototype.evaluate = function(ctx) {
+    var nodeset = this.filter.evaluate(ctx);
+    if (!nodeset.isNodeSet) throw Exception('Filter nodeset must be nodeset type');
+
+    var steps = this.steps;
+
+    for (var i = 0, l0 = steps.length; i < l0 && nodeset.length; i ++) {
+        var step = steps[i][1];
+        var reverse = step.reverse;
+        var iter = nodeset.iterator(reverse);
+        var prevNodeset = nodeset;
+        nodeset = null;
+        var node, next;
+        if (!step.needContextPosition && step.axis == 'following') {
+            for (node = iter(); next = iter(); node = next) {
+
+                // Safari 2 node.contains problem
+                if (uai.applewebkit2) {
+                    var contains = false;
+                    var ancestor = next;
+                    do {
+                        if (ancestor == node) {
+                            contains = true;
+                            break;
+                        }
+                    } while (ancestor = ancestor.parentNode);
+                    if (!contains) break;
+                }
+                else {
+                    try { if (!node.contains(next)) break }
+                    catch(e) { if (!(next.compareDocumentPosition(node) & 8)) break }
+                }
+            }
+            nodeset = step.evaluate(new Ctx(node));
+        }
+        else if (!step.needContextPosition && step.axis == 'preceding') {
+            node = iter();
+            nodeset = step.evaluate(new Ctx(node));
+        }
+        else {
+            node = iter();
+            var j = 0;
+            nodeset = step.evaluate(new Ctx(node), false, prevNodeset, j);
+            while (node = iter()) {
+                j ++;
+                nodeset.merge(step.evaluate(new Ctx(node), false, prevNodeset, j));
+            }
+        }
+    }
+
+    return nodeset;
+};
+
+PathExpr.prototype.step = function(op, step) {
+    step.op = op;
+    this.steps.push([op, step]);
+
+    this.quickAttr = false;
+
+    if (this.steps.length == 1) {
+        if (op == '/' && step.axis == 'attribute') {
+            var test = step.test;
+            if (!test.notOnlyElement && test.name != '*') {
+                this.quickAttr = true;
+                this.attrName = test.name;
+            }
+        }
+    }
+};
+
+PathExpr.prototype.show = function(indent) {
+    indent = indent || '';
+    var t = '';
+    t += indent + 'path:' + '\n';
+    indent += '    ';
+    t += indent + 'filter:' + '\n';
+    t += this.filter.show(indent + '    ');
+    if (this.steps.length) {
+        t += indent + 'steps:' + '\n';
+        indent += '    ';
+        for (var i = 0; i < this.steps.length; i ++) {
+            var step = this.steps[i];
+            t += indent + 'operator: ' + step[0] + '\n';
+            t += step[1].show(indent);
+        }
+    }
+    return t;
+};
+
+
+/**
+ * class: FilterExpr
+ */
+if (!window.FilterExpr && window.defaultConfig)
+    window.FilterExpr = null;
+
+FilterExpr = function(primary) {
+    this.primary = primary;
+    this.predicates = [];
+
+    this.datatype = primary.datatype;
+
+    this.needContextPosition = primary.needContextPosition;
+
+    this.needContextNode = primary.needContextNode;
+};
+
+FilterExpr.parse = function(lexer) {
+    var expr, filter, token, ch;
+
+    token = lexer.peek();
+    ch = token.charAt(0);
+
+    switch (ch) {
+        case '$':
+            expr = VariableReference.parse(lexer);
+            break;
+
+        case '(':
+            lexer.next();
+            expr = BinaryExpr.parse(lexer);
+            if (lexer.empty()) {
+                throw Error('unclosed "("');
+            }
+            if (lexer.next() != ')') {
+                lexer.back();
+                throw Error('bad token: ' + lexer.next());
+            }
+            break;
+
+        case '"':
+        case "'":
+            expr = Literal.parse(lexer);
+            break;
+
+        default:
+            if (!isNaN(+token)) {
+                expr = Number.parse(lexer);
+            }
+
+            else if (NodeType.types[token]) {
+                return null;
+            }
+
+            else if (/(?![0-9])[\w]/.test(ch) && lexer.peek(1) == '(') {
+                expr = FunctionCall.parse(lexer);
+            }
+            else {
+                return null;
+            }
+            break;
+    }
+
+    if (lexer.peek() != '[') return expr;
+
+    filter = new FilterExpr(expr);
+
+    BaseExprHasPredicates.parsePredicates(lexer, filter);
+
+    return filter;
+};
+
+FilterExpr.root = function() {
+    return new FunctionCall('root-node');
+};
+FilterExpr.context = function() {
+    return new FunctionCall('context-node');
+};
+
+FilterExpr.prototype = new BaseExprHasPredicates();
+
+FilterExpr.prototype.evaluate = function(ctx) {
+    var nodeset = this.primary.evaluate(ctx);
+    if(!nodeset.isNodeSet) {
+        if (this.predicates.length)
+            throw Error(
+                'Primary result must be nodeset type ' +
+                'if filter have predicate expression');
+        return nodeset;
+    }
+
+    return  this.evaluatePredicates(nodeset);
+};
+
+FilterExpr.prototype.predicate = function(predicate) {
+    this.predicates.push(predicate);
+};
+
+FilterExpr.prototype.show = function(indent) {
+    indent = indent || '';
+    var t = '';
+    t += indent + 'filter: ' + '\n';
+    indent += '    ';
+    t += this.primary.show(indent);
+    if (this.predicates.length) {
+        t += indent + 'predicates: ' + '\n';
+        indent += '    ';
+        for (var i = 0; i < this.predicates.length; i ++) {
+            t += this.predicates[i].show(indent);
+        }
+    }
+    return t;
+};
+
+
+if (!window.NodeUtil && window.defaultConfig)
+    window.NodeUtil = null;
+
+NodeUtil = {
+    to: function(valueType, node) {
+        var t, type = node.nodeType;
+        // Safari2: innerText contains some bugs
+        if (type == 1 && config.useInnerText && !uai.applewebkit2) {
+            t = node.textContent;
+            t = (t == undefined || t == null) ? node.innerText : t;
+            t = (t == undefined || t == null) ? '' : t;
+        }
+        if (typeof t != 'string') {
+/*@cc_on
+            if (type == 1 && node.nodeName.toLowerCase() == 'title') {
+                t = node.text;
+            }
+            else
+@*/
+            if (type == 9 || type == 1) {
+                if (type == 9) {
+                    node =  node.documentElement;
+                }
+                else {
+                    node = node.firstChild;
+                }
+                for (t = '', stack = [], i = 0; node;) {
+                    do {
+                        if (node.nodeType != 1) {
+                            t += node.nodeValue;
+                        }
+/*@cc_on
+                        else if (node.nodeName.toLowerCase() == 'title') {
+                            t += node.text;
+                        }
+@*/
+                        stack[i++] = node; // push
+                    } while (node = node.firstChild);
+                    while (i && !(node = stack[--i].nextSibling)) {}
+                }
+            }
+            else {
+                t = node.nodeValue;
+            }
+        }
+        switch (valueType) {
+            case 'number':
+                return + t;
+            case 'boolean':
+                return !! t;
+            default:
+                return t;
+        }
+    },
+    attrPropMap: {
+        name: 'name',
+        'class': 'className',
+        dir: 'dir',
+        id: 'id',
+        name: 'name',
+        title: 'title'
+    },
+    attrMatch: function(node, attrName, attrValue) {
+/*@cc_on @if (@_jscript)
+        var propName = NodeUtil.attrPropMap[attrName];
+        if (!attrName ||
+            attrValue == null && (
+                propName && node[propName] ||
+                !propName && node.getAttribute && node.getAttribute(attrName, 2)
+            ) ||
+            attrValue != null && (
+                propName && node[propName] == attrValue ||
+                !propName && node.getAttribute && node.getAttribute(attrName, 2) == attrValue
+            )) {
+@else @*/
+        if (!attrName ||
+            attrValue == null && node.hasAttribute && node.hasAttribute(attrName) ||
+            attrValue != null && node.getAttribute && node.getAttribute(attrName) == attrValue) {
+/*@end @*/
+            return true;
+        }
+        else {
+            return false;
+        }
+    },
+    getDescendantNodes: function(test, node, nodeset, attrName, attrValue, prevNodeset, prevIndex) {
+        if (prevNodeset) {
+            prevNodeset.delDescendant(node, prevIndex);
+        }
+/*@cc_on
+        try {
+            if (!test.notOnlyElement || test.type == 8 || (attrName && test.type == 0)) {
+
+                var all = node.all;
+                if (!all) {
+                    return nodeset;
+                }
+
+                var name = test.name;
+                if (test.type == 8) name = '!';
+                else if (test.type == 0) name = '*';
+
+                if (name != '*') {
+                    all = all.tags(name);
+                    if (!all) {
+                        return nodeset;
+                    }
+                }
+
+                if (attrName) {
+                    var result = []
+                    var i = 0;
+                    if (attrValue != null && (attrName == 'id' || attrName == 'name')) {
+                        all = all[attrValue];
+                        if (!all) {
+                            return nodeset;
+                        }
+                        if (!all.length || all.nodeType) {
+                            all = [all];
+                        }
+                    }
+        
+                    while (node = all[i++]) {
+                        if (NodeUtil.attrMatch(node, attrName, attrValue)) result.push(node);
+                    }
+
+                    all = result;
+                }
+
+                var i = 0;
+                while (node = all[i++]) {
+                    if (name != '*' || node.tagName != '!') {
+                        nodeset.push(node);
+                    }
+                }
+
+                return nodeset;
+            }
+
+            (function (parent) {
+                var g = arguments.callee;
+                var node = parent.firstChild;
+                if (node) {
+                    for (; node; node = node.nextSibling) {
+                        if (NodeUtil.attrMatch(node, attrName, attrValue)) {
+                            if (test.match(node)) nodeset.push(node);
+                        }
+                        g(node);
+                    }
+                }
+            })(node);
+
+            return nodeset;
+        }
+        catch(e) {
+@*/
+        if (attrValue && attrName == 'id' && node.getElementById) {
+            node = node.getElementById(attrValue);
+            if (node && test.match(node)) {
+                nodeset.push(node);
+            }
+        }
+        else if (attrValue && attrName == 'name' && node.getElementsByName) {
+            var nodes = node.getElementsByName(attrValue);
+            for (var i = 0, l = nodes.length; i < l; i ++) {
+                node = nodes[i];
+                if (uai.opera ? (node.name == attrValue && test.match(node)) : test.match(node)) {
+                    nodeset.push(node);
+                }
+            }
+        }
+        else if (attrValue && attrName == 'class' && node.getElementsByClassName) {
+            var nodes = node.getElementsByClassName(attrValue);
+            for (var i = 0, l = nodes.length; i < l; i ++) {
+                node = nodes[i];
+                if (node.className == attrValue && test.match(node)) {
+                    nodeset.push(node);
+                }
+            }
+        }
+        else if (test.notOnlyElement) {
+            (function (parent) {
+                var f = arguments.callee;
+                for (var node = parent.firstChild; node; node = node.nextSibling) {
+                    if (NodeUtil.attrMatch(node, attrName, attrValue)) {
+                        if (test.match(node.nodeType)) nodeset.push(node);
+                    }
+                    f(node);
+                }
+            })(node);
+        }
+        else {
+            var name = test.name;
+            if (node.getElementsByTagName) {
+                var nodes = node.getElementsByTagName(name);
+                if (nodes) {
+                    var i = 0;
+                    while (node = nodes[i++]) {
+                        if (NodeUtil.attrMatch(node, attrName, attrValue)) nodeset.push(node);
+                    }
+                }
+            }
+        }
+        return nodeset;
+/*@cc_on
+        }
+@*/
+    },
+
+    getChildNodes: function(test, node, nodeset, attrName, attrValue) {
+
+/*@cc_on
+        try {
+            var children;
+
+            if ((!test.notOnlyElement || test.type == 8 || (attrName && test.type == 0)) && (children = node.children)) {
+                var name, elm;
+
+                name = test.name;
+                if (test.type == 8) name = '!';
+                else if (test.type == 0) name = '*';
+
+                if (name != '*') {
+                    children = children.tags(name);
+                    if (!children) {
+                        return nodeset;
+                    }
+                }
+
+                if (attrName) {
+                    var result = []
+                    var i = 0;
+                    if (attrName == 'id' || attrName == 'name') {
+                        children = children[attrValue];
+        
+                        if (!children) {
+                            return nodeset;
+                        }
+        
+                        if (!children.length || children.nodeType) {
+                            children = [children];
+                        }
+                    }
+        
+                    while (node = children[i++]) {
+                        if (NodeUtil.attrMatch(node, attrName, attrValue)) result.push(node);
+                    }
+                    children = result;
+                }
+
+                var i = 0;
+                while (node = children[i++]) {
+                    if (name != '*' || node.tagName != '!') {
+                        nodeset.push(node);
+                    }
+                }
+
+                return nodeset;
+            }
+
+            for (var i = 0, node = node.firstChild; node; i++, node = node.nextSibling) {
+                if (NodeUtil.attrMatch(node, attrName, attrValue)) {
+                    if (test.match(node)) nodeset.push(node);
+                }
+            }
+
+            return nodeset;
+        } catch(e) {
+@*/
+        for (var node = node.firstChild; node; node = node.nextSibling) {
+            if (NodeUtil.attrMatch(node, attrName, attrValue)) {
+                if (test.match(node)) nodeset.push(node);
+            }
+        }
+        return nodeset;
+/*@cc_on
+        }
+@*/
+    }
+};
+
+/*@cc_on
+var AttributeWrapper = function(node, parent, sourceIndex) {
+    this.node = node;
+    this.nodeType = 2;
+    this.nodeValue = node.nodeValue;
+    this.nodeName = node.nodeName;
+    this.parentNode = parent;
+    this.ownerElement = parent;
+    this.parentSourceIndex = sourceIndex;
+};
+
+@*/
+
+
+/**
+ * class: Step
+ */
+if (!window.Step && window.defaultConfig)
+    window.Step = null;
+
+Step = function(axis, test) {
+    // TODO check arguments and throw axis error
+    this.axis = axis;
+    this.reverse = Step.axises[axis][0];
+    this.func = Step.axises[axis][1];
+    this.test = test;
+    this.predicates = [];
+    this._quickAttr = Step.axises[axis][2]
+};
+
+Step.axises = {
+
+    ancestor: [true, function(test, node, nodeset, _, __, prevNodeset, prevIndex) {
+        while (node = node.parentNode) {
+            if (prevNodeset && node.nodeType == 1) {
+                prevNodeset.reserveDelByNode(node, prevIndex, true);
+            }
+            if (test.match(node)) nodeset.unshift(node);
+        }
+        return nodeset;
+    }],
+
+    'ancestor-or-self': [true, function(test, node, nodeset, _, __, prevNodeset, prevIndex) {
+        do {
+            if (prevNodeset && node.nodeType == 1) {
+                prevNodeset.reserveDelByNode(node, prevIndex, true);
+            }
+            if (test.match(node)) nodeset.unshift(node);
+        } while (node = node.parentNode)
+        return nodeset;
+    }],
+
+    attribute: [false, function(test, node, nodeset) {
+        var attrs = node.attributes;
+        if (attrs) {
+/*@cc_on
+            var sourceIndex = node.sourceIndex;
+@*/
+            if ((test.notOnlyElement && test.type == 0) || test.name == '*') {
+                for (var i = 0, attr; attr = attrs[i]; i ++) {
+/*@cc_on @if (@_jscript)
+                    if (attr.nodeValue) {
+                        nodeset.push(new AttributeWrapper(attr, node, sourceIndex));
+                    }
+@else @*/
+                    nodeset.push(attr);
+/*@end @*/
+                }
+            }
+            else {
+                var attr = attrs.getNamedItem(test.name);
+                
+/*@cc_on @if (@_jscript)
+                if (attr && attr.nodeValue) {
+                    attr = new AttributeWrapper(attr, node, sourceIndex);;
+@else @*/
+                if (attr) {
+/*@end @*/
+                    nodeset.push(attr);
+                }
+            }
+        }
+        return nodeset;
+    }],
+
+    child: [false, NodeUtil.getChildNodes, true],
+
+    descendant: [false, NodeUtil.getDescendantNodes, true],
+
+    'descendant-or-self': [false, function(test, node, nodeset, attrName, attrValue, prevNodeset, prevIndex) {
+        if (NodeUtil.attrMatch(node, attrName, attrValue)) {
+            if (test.match(node)) nodeset.push(node);
+        }
+        return NodeUtil.getDescendantNodes(test, node, nodeset, attrName, attrValue, prevNodeset, prevIndex);
+    }, true],
+
+    following: [false, function(test, node, nodeset, attrName, attrValue) {
+        do {
+            var child = node;
+            while (child = child.nextSibling) {
+                if (NodeUtil.attrMatch(child, attrName, attrValue)) {
+                    if (test.match(child)) nodeset.push(child);
+                }
+                nodeset = NodeUtil.getDescendantNodes(test, child, nodeset, attrName, attrValue);
+            }
+        } while (node = node.parentNode);
+        return nodeset;
+    }, true],
+
+    'following-sibling': [false, function(test, node, nodeset, _, __, prevNodeset, prevIndex) {
+        while (node = node.nextSibling) {
+
+            if (prevNodeset && node.nodeType == 1) {
+                prevNodeset.reserveDelByNode(node, prevIndex);
+            }
+
+            if (test.match(node)) {
+                nodeset.push(node);
+            }
+        }
+        return nodeset;
+    }],
+
+    namespace: [false, function(test, node, nodeset) {
+        // not implemented
+        return nodeset;
+    }],
+
+    parent: [false, function(test, node, nodeset) {
+        if (node.nodeType == 9) {
+            return nodeset;
+        }
+        if (node.nodeType == 2) {
+            nodeset.push(node.ownerElement);
+            return nodeset;
+        }
+        var node = node.parentNode;
+        if (test.match(node)) nodeset.push(node);
+        return nodeset;
+    }],
+
+    preceding: [true, function(test, node, nodeset, attrName, attrValue) {
+        var parents = [];
+        do {
+            parents.unshift(node);
+        } while (node = node.parentNode);
+
+        for (var i = 1, l0 = parents.length; i < l0; i ++) {
+            var siblings = [];
+            node = parents[i];
+            while (node = node.previousSibling) {
+                siblings.unshift(node);
+            }
+
+            for (var j = 0, l1 = siblings.length; j < l1; j ++) {
+                node = siblings[j];
+                if (NodeUtil.attrMatch(node, attrName, attrValue)) {
+                    if (test.match(node)) nodeset.push(node);
+                }
+                nodeset = NodeUtil.getDescendantNodes(test, node, nodeset, attrName, attrValue);
+            }
+        }
+        return nodeset;
+    }, true],
+
+    'preceding-sibling': [true, function(test, node, nodeset, _, __, prevNodeset, prevIndex) {
+        while (node = node.previousSibling) {
+
+            if (prevNodeset && node.nodeType == 1) {
+                prevNodeset.reserveDelByNode(node, prevIndex, true);
+            }
+
+            if (test.match(node)) {
+                nodeset.unshift(node)
+            }
+        }
+        return nodeset;
+    }],
+
+    self: [false, function(test, node, nodeset) {
+        if (test.match(node)) nodeset.push(node);
+        return nodeset;
+    }]
+};
+
+Step.parse = function(lexer) {
+    var axis, test, step, token;
+
+    if (lexer.peek() == '.') {
+        step = this.self();
+        lexer.next();
+    }
+    else if (lexer.peek() == '..') {
+        step = this.parent();
+        lexer.next();
+    }
+    else {
+        if (lexer.peek() == '@') {
+            axis = 'attribute';
+            lexer.next();
+            if (lexer.empty()) {
+                throw Error('missing attribute name');
+            }
+        }
+        else {
+            if (lexer.peek(1) == '::') {
+                
+                if (!/(?![0-9])[\w]/.test(lexer.peek().charAt(0))) {
+                    throw Error('bad token: ' + lexer.next());
+                }
+        
+                axis = lexer.next();
+                lexer.next();
+
+                if (!this.axises[axis]) {
+                    throw Error('invalid axis: ' + axis);
+                }
+                if (lexer.empty()) {
+                    throw Error('missing node name');
+                }
+            }
+            else {
+                axis = 'child';
+            }
+        }
+    
+        token = lexer.peek();
+        if (!/(?![0-9])[\w]/.test(token.charAt(0))) {
+            if (token == '*') {
+                test = NameTest.parse(lexer)
+            }
+            else {
+                throw Error('bad token: ' + lexer.next());
+            }
+        }
+        else {
+            if (lexer.peek(1) == '(') {
+                if (!NodeType.types[token]) {
+                    throw Error('invalid node type: ' + token);
+                }
+                test = NodeType.parse(lexer)
+            }
+            else {
+                test = NameTest.parse(lexer);
+            }
+        }
+        step = new Step(axis, test);
+    }
+
+    BaseExprHasPredicates.parsePredicates(lexer, step);
+
+    return step;
+};
+
+Step.self = function() {
+    return new Step('self', new NodeType('node'));
+};
+
+Step.parent = function() {
+    return new Step('parent', new NodeType('node'));
+};
+
+Step.prototype = new BaseExprHasPredicates();
+
+Step.prototype.evaluate = function(ctx, special, prevNodeset, prevIndex) {
+    var node = ctx.node;
+    var reverse = false;
+
+    if (!special && this.op == '//') {
+
+        if (!this.needContextPosition && this.axis == 'child') {
+            if (this.quickAttr) {
+                var attrValue = this.attrValueExpr ? this.attrValueExpr.string(ctx) : null;
+                var nodeset = NodeUtil.getDescendantNodes(this.test, node, new NodeSet(), this.attrName, attrValue, prevNodeset, prevIndex);
+                nodeset = this.evaluatePredicates(nodeset, 1);
+            }
+            else {
+                var nodeset = NodeUtil.getDescendantNodes(this.test, node, new NodeSet(), null, null, prevNodeset, prevIndex);
+                nodeset = this.evaluatePredicates(nodeset);
+            }
+        }
+        else {
+            var step = new Step('descendant-or-self', new NodeType('node'));
+            var nodes = step.evaluate(ctx, false, prevNodeset, prevIndex).list();
+            var nodeset = null;
+            step.op = '/';
+            for (var i = 0, l = nodes.length; i < l; i ++) {
+                if (!nodeset) {
+                    nodeset = this.evaluate(new Ctx(nodes[i]), true);
+                }
+                else {
+                    nodeset.merge(this.evaluate(new Ctx(nodes[i]), true));
+                }
+            }
+            nodeset = nodeset || new NodeSet();
+        }
+    }
+    else {
+
+        if (this.needContextPosition) {
+            prevNodeset = null;
+            prevIndex = null;
+        }
+
+        if (this.quickAttr) {
+            var attrValue = this.attrValueExpr ? this.attrValueExpr.string(ctx) : null;
+            var nodeset = this.func(this.test, node, new NodeSet(), this.attrName, attrValue, prevNodeset, prevIndex);
+            nodeset = this.evaluatePredicates(nodeset, 1);
+        }
+        else {
+            var nodeset = this.func(this.test, node, new NodeSet(), null, null, prevNodeset, prevIndex);
+            nodeset = this.evaluatePredicates(nodeset);
+        }
+        if (prevNodeset) {
+            prevNodeset.doDel();
+        }
+    }
+    return nodeset;
+};
+
+Step.prototype.predicate = function(predicate) {
+    this.predicates.push(predicate);
+
+    if (predicate.needContextPosition ||
+        predicate.datatype == 'number'||
+        predicate.datatype == 'void') {
+        this.needContextPosition = true;
+    }
+
+    if (this._quickAttr && this.predicates.length == 1 && predicate.quickAttr) {
+        var attrName = predicate.attrName;
+/*@cc_on @if (@_jscript)
+        this.attrName = attrName.toLowerCase();
+@else @*/
+        this.attrName = attrName;
+/*@end @*/
+        this.attrValueExpr = predicate.attrValueExpr;
+        this.quickAttr = true;
+    }
+};
+
+Step.prototype.show = function(indent) {
+    indent = indent || '';
+    var t = '';
+    t += indent + 'step: ' + '\n';
+    indent += '    ';
+    if (this.axis) t += indent + 'axis: ' + this.axis + '\n';
+    t += this.test.show(indent);
+    if (this.predicates.length) {
+        t += indent + 'predicates: ' + '\n';
+        indent += '    ';
+        for (var i = 0; i < this.predicates.length; i ++) {
+            t += this.predicates[i].show(indent);
+        }
+    }
+    return t;
+};
+
+
+
+/**
+ * NodeType
+ */
+if (!window.NodeType && window.defaultConfig)
+    window.NodeType = null;
+    
+NodeType = function(name, literal) {
+    this.name = name;
+    this.literal = literal;
+
+    switch (name) {
+        case 'comment':
+            this.type = 8;
+            break;
+        case 'text':
+            this.type = 3;
+            break;
+        case 'processing-instruction':
+            this.type = 7;
+            break;
+        case 'node':
+            this.type = 0;
+            break;
+    }
+};
+
+NodeType.types = {
+    'comment':1, 'text':1, 'processing-instruction':1, 'node':1
+};
+
+NodeType.parse = function(lexer) {
+    var type, literal, ch;
+    type = lexer.next();
+    lexer.next();
+    if (lexer.empty()) {
+        throw Error('bad nodetype');
+    }
+    ch = lexer.peek().charAt(0);
+    if (ch == '"' || ch == "'") {
+        literal = Literal.parse(lexer);
+    }
+    if (lexer.empty()) {
+        throw Error('bad nodetype');
+    }
+    if (lexer.next() != ')') {
+        lexer.back();
+        throw Error('bad token ' + lexer.next());
+    }
+    return new NodeType(type, literal);
+};
+
+NodeType.prototype = new BaseExpr();
+
+NodeType.prototype.notOnlyElement = true;
+
+NodeType.prototype.match = function(node) {
+    return !this.type || this.type == node.nodeType;
+};
+
+NodeType.prototype.show = function(indent) {
+    indent = indent || '';
+    var t = '';
+    t += indent + 'nodetype: ' + this.type + '\n';
+    if (this.literal) {
+        indent += '    ';
+        t += this.literal.show(indent);
+    }
+    return t;
+};
+
+
+/**
+ * NodeType
+ */
+if (!window.NameTest && window.defaultConfig)
+    window.NameTest = null;
+
+NameTest = function(name) {
+    this.name = name.toLowerCase();
+};
+
+NameTest.parse = function(lexer) {
+    if (lexer.peek() != '*' &&  lexer.peek(1) == ':' && lexer.peek(2) == '*') {
+        return new NameTest(lexer.next() + lexer.next() + lexer.next());
+    }
+    return new NameTest(lexer.next());
+};
+
+NameTest.prototype = new BaseExpr();
+
+NameTest.prototype.match = function(node) {
+    var type = node.nodeType;
+
+    if (type == 1 || type == 2) {
+        if (this.name == '*' || this.name == node.nodeName.toLowerCase()) {
+            return true;
+        }
+    }
+    return false;
+};
+
+NameTest.prototype.show = function(indent) {
+    indent = indent || '';
+    var t = '';
+    t += indent + 'nametest: ' + this.name + '\n';
+    return t;
+};
+
+
+/**
+ * class: VariableRefernce
+ */
+if (!window.VariableReference && window.defaultConfig)
+    window.VariableReference = null;
+    
+VariableReference = function(name) {
+    this.name = name.substring(1);
+};
+
+
+VariableReference.parse = function(lexer) {
+    var token = lexer.next();
+    if (token.length < 2) {
+        throw Error('unnamed variable reference');
+    }
+    return new VariableReference(token)
+};
+
+VariableReference.prototype = new BaseExpr();
+
+VariableReference.prototype.datatype = 'void';
+
+VariableReference.prototype.show = function(indent) {
+    indent = indent || '';
+    var t = '';
+    t += indent + 'variable: ' + this.name + '\n';
+    return t;
+};
+
+
+/**
+ * class: Literal
+ */
+if (!window.Literal && window.defaultConfig)
+    window.Literal = null;
+
+Literal = function(text) {
+    this.text = text.substring(1, text.length - 1);
+};
+
+Literal.parse = function(lexer) {
+    var token = lexer.next();
+    if (token.length < 2) {
+        throw Error('unclosed literal string');
+    }
+    return new Literal(token)
+};
+
+Literal.prototype = new BaseExpr();
+
+Literal.prototype.datatype = 'string';
+
+Literal.prototype.evaluate = function(ctx) {
+    return this.text;
+};
+
+Literal.prototype.show = function(indent) {
+    indent = indent || '';
+    var t = '';
+    t += indent + 'literal: ' + this.text + '\n';
+    return t;
+};
+
+
+/**
+ * class: Number
+ */
+if (!window.Number && window.defaultConfig)
+    window.Number = null;
+
+Number = function(digit) {
+    this.digit = +digit;
+};
+
+
+Number.parse = function(lexer) {
+    return new Number(lexer.next());
+};
+
+Number.prototype = new BaseExpr();
+
+Number.prototype.datatype = 'number';
+
+Number.prototype.evaluate = function(ctx) {
+    return this.digit;
+};
+
+Number.prototype.show = function(indent) {
+    indent = indent || '';
+    var t = '';
+    t += indent + 'number: ' + this.digit + '\n';
+    return t;
+};
+
+
+/**
+ * class: FunctionCall
+ */
+if (!window.FunctionCall && window.defaultConfig)
+    window.FunctionCall = null;
+
+FunctionCall = function(name) {
+    var info = FunctionCall.funcs[name];
+    if (!info)
+        throw Error(name +' is not a function');
+
+    this.name = name;
+    this.func = info[0];
+    this.args = [];
+
+    this.datatype = info[1];
+
+    if (info[2]) {
+        this.needContextPosition = true;
+    }
+
+    this.needContextNodeInfo = info[3];
+    this.needContextNode = this.needContextNodeInfo[0]
+};
+
+FunctionCall.funcs = {
+
+    // Original Function
+    'context-node': [function() {
+        if (arguments.length != 0) {
+            throw Error('Function context-node expects ()');
+        }
+        var ns;
+        ns = new NodeSet();
+        ns.push(this.node);
+        return ns;
+    }, 'nodeset', false, [true]],
+
+    // Original Function
+    'root-node': [function() {
+        if (arguments.length != 0) {
+            throw Error('Function root-node expects ()');
+        }
+        var ns, ctxn;
+        ns = new NodeSet();
+        ctxn = this.node;
+        if (ctxn.nodeType == 9)
+            ns.push(ctxn);
+        else
+            ns.push(ctxn.ownerDocument);
+        return ns;
+    }, 'nodeset', false, []],
+
+    last: [function() {
+        if (arguments.length != 0) {
+            throw Error('Function last expects ()');
+        }
+        return this.last;
+    }, 'number', true, []],
+
+    position: [function() {
+        if (arguments.length != 0) {
+            throw Error('Function position expects ()');
+        }
+        return this.position;
+    }, 'number', true, []],
+
+    count: [function(ns) {
+        if (arguments.length != 1 || !(ns = ns.evaluate(this)).isNodeSet) {
+            throw Error('Function count expects (nodeset)');
+        }
+        return ns.length;
+    }, 'number', false, []],
+
+    id: [function(s) {
+        var ids, ns, i, id, elm, ctxn, doc;
+        if (arguments.length != 1) {
+            throw Error('Function id expects (object)');
+        }
+        ctxn = this.node;
+        if (ctxn.nodeType == 9)
+            doc = ctxn;
+        else
+            doc = ctxn.ownerDocument;
+/*@cc_on
+        all = doc.all;
+@*/
+        s = s.string(this);
+        ids = s.split(/\s+/);
+        ns = new NodeSet();
+        for (i = 0, l = ids.length; i < l; i ++) {
+            id = ids[i];
+
+/*@cc_on @if (@_jscript)
+            elm = all[id];
+            if (elm) {
+                if ((!elm.length || elm.nodeType) && id == elm.id) {
+                    ns.push(elm)
+                }
+                else if (elm.length) {
+                    var elms = elm;
+                    for (var j = 0, l0 = elms.length; j < l0; j ++) {
+                        var elem = elms[j];
+                        if (id == elem.id) {
+                            ns.push(elem);
+                            break;
+                        }
+                    }
+                }
+            }
+@else @*/
+            elm = doc.getElementById(id);
+            if (uai.opera && elm && elm.id != id) {
+                var elms = doc.getElementsByName(id);
+                for (var j = 0, l0 = elms.length; j < l0; j ++) {
+                    elm = elms[j];
+                    if (elm.id == id) {
+                        ns.push(elm);
+                    }
+                }
+            }
+            else {
+                if (elm) ns.push(elm)
+            }
+/*@end @*/
+
+        }
+        ns.isSorted = false;
+        return ns;
+    }, 'nodeset', false, []],
+
+    'local-name': [function(ns) {
+        var nd;
+        switch (arguments.length) {
+            case 0:
+                nd = this.node;
+                break;
+            case 1:
+                if ((ns = ns.evaluate(this)).isNodeSet) {
+                    nd = ns.first();
+                    break;
+                }
+            default:
+                throw Error('Function local-name expects (nodeset?)');
+                break;
+        }
+        return '' + nd.nodeName.toLowerCase();
+    }, 'string', false, [true, false]],
+
+    name: [function(ns) {
+        // not implemented
+        return FunctionCall.funcs['local-name'][0].apply(this, arguments);
+    }, 'string', false, [true, false]],
+
+    'namespace-uri': [function(ns) {
+        // not implemented
+        return '';
+    }, 'string', false, [true, false]],
+
+    string: [function(s) {
+        switch (arguments.length) {
+            case 0:
+                s = NodeUtil.to('string', this.node);
+                break;
+            case 1:
+                s = s.string(this);
+                break;
+            default:
+                throw Error('Function string expects (object?)');
+                break;
+        }
+        return s;
+    }, 'string', false, [true, false]],
+
+    concat: [function(s1, s2) {
+        if (arguments.length < 2) {
+            throw Error('Function concat expects (string, string[, ...])');
+        }
+        for (var t = '', i = 0, l = arguments.length; i < l; i ++) {
+            t += arguments[i].string(this);
+        }
+        return t;
+    }, 'string', false, []],
+
+    'starts-with': [function(s1, s2) {
+        if (arguments.length != 2) {
+            throw Error('Function starts-with expects (string, string)');
+        }
+        s1 = s1.string(this);
+        s2 = s2.string(this);
+        return s1.indexOf(s2) == 0;
+    }, 'boolean', false, []],
+
+    contains: [function(s1, s2) {
+        if (arguments.length != 2) {
+            throw Error('Function contains expects (string, string)');
+        }
+        s1 = s1.string(this);
+        s2 = s2.string(this);
+        return s1.indexOf(s2) != -1;
+    }, 'boolean', false, []],
+
+    substring: [function(s, n1, n2) {
+        var a1, a2;
+        s = s.string(this);
+        n1 = n1.number(this);
+        switch (arguments.length) {
+            case 2:
+                n2 = s.length - n1 + 1;
+                break;
+            case 3:
+                n2 = n2.number(this);
+                break;
+            default:
+                throw Error('Function substring expects (string, string)');
+                break;
+        }
+        n1 = Math.round(n1);
+        n2 = Math.round(n2);
+        a1 = n1 - 1;
+        a2 = n1 + n2 - 1;
+        if (a2 == Infinity) {
+            return s.substring(a1 < 0 ? 0 : a1);
+        }
+        else {
+            return s.substring(a1 < 0 ? 0 : a1, a2)
+        }
+    }, 'string', false, []],
+
+    'substring-before': [function(s1, s2) {
+        var n;
+        if (arguments.length != 2) {
+            throw Error('Function substring-before expects (string, string)');
+        }
+        s1 = s1.string(this);
+        s2 = s2.string(this);
+        n = s1.indexOf(s2);
+        if (n == -1) return '';
+        return s1.substring(0, n);
+    }, 'string', false, []],
+
+    'substring-after': [function(s1, s2) {
+        if (arguments.length != 2) {
+            throw Error('Function substring-after expects (string, string)');
+        }
+        s1 = s1.string(this);
+        s2 = s2.string(this);
+        var n = s1.indexOf(s2);
+        if (n == -1) return '';
+        return s1.substring(n + s2.length);
+    }, 'string', false, []],
+
+    'string-length': [function(s) {
+        switch (arguments.length) {
+            case 0:
+                s = NodeUtil.to('string', this.node);
+                break;
+            case 1:
+                s = s.string(this);
+                break;
+            default:
+                throw Error('Function string-length expects (string?)');
+                break;
+        }
+        return s.length;
+    }, 'number', false, [true, false]],
+
+    'normalize-space': [function(s) {
+        switch (arguments.length) {
+            case 0:
+                s = NodeUtil.to('string', this.node);
+                break;
+            case 1:
+                s = s.string(this);
+                break;
+            default:
+                throw Error('Function normalize-space expects (string?)');
+                break;
+        }
+        return s.replace(/\s+/g, ' ').replace(/^ /, '').replace(/ $/, '');
+    }, 'string', false, [true, false]],
+
+    translate: [function(s1, s2, s3) {
+        if (arguments.length != 3) {
+            throw Error('Function translate expects (string, string, string)');
+        }
+        s1 = s1.string(this);
+        s2 = s2.string(this);
+        s3 = s3.string(this);
+
+        var map = [];
+        for (var i = 0, l = s2.length; i < l; i ++) {
+            var ch = s2.charAt(i);
+            if (!map[ch]) map[ch] = s3.charAt(i) || '';
+        }
+        for (var t = '', i = 0, l = s1.length; i < l; i ++) {
+            var ch = s1.charAt(i);
+            var replace = map[ch]
+            t += (replace != undefined) ? replace : ch;
+        }
+        return t;
+    }, 'string', false, []],
+
+    'boolean': [function(b) {
+        if (arguments.length != 1) {
+            throw Error('Function boolean expects (object)');
+        }
+        return b.bool(this)
+    }, 'boolean', false, []],
+
+    not: [function(b) {
+        if (arguments.length != 1) {
+            throw Error('Function not expects (object)');
+        }
+        return !b.bool(this)
+    }, 'boolean', false, []],
+
+    'true': [function() {
+        if (arguments.length != 0) {
+            throw Error('Function true expects ()');
+        }
+        return true;
+    }, 'boolean', false, []],
+
+    'false': [function() {
+        if (arguments.length != 0) {
+            throw Error('Function false expects ()');
+        }
+        return false;
+    }, 'boolean', false, []],
+
+    lang: [function(s) {
+        // not implemented
+        return false;
+    }, 'boolean', false, []],
+
+    number: [function(n) {
+        switch (arguments.length) {
+            case 0:
+                n = NodeUtil.to('number', this.node);
+                break;
+            case 1:
+                n = n.number(this);
+                break;
+            default:
+                throw Error('Function number expects (object?)');
+                break;
+        }
+        return n;
+    }, 'number', false, [true, false]],
+
+    sum: [function(ns) {
+        var nodes, n, i, l;
+        if (arguments.length != 1 || !(ns = ns.evaluate(this)).isNodeSet) {
+            throw Error('Function sum expects (nodeset)');
+        }
+        nodes = ns.list();
+        n = 0;
+        for (i = 0, l = nodes.length; i < l; i ++) {
+            n += NodeUtil.to('number', nodes[i]);
+        }
+        return n;
+    }, 'number', false, []],
+
+    floor: [function(n) {
+        if (arguments.length != 1) {
+            throw Error('Function floor expects (number)');
+        }
+        n = n.number(this);
+        return Math.floor(n);
+    }, 'number', false, []],
+
+    ceiling: [function(n) {
+        if (arguments.length != 1) {
+            throw Error('Function ceiling expects (number)');
+        }
+        n = n.number(this);
+        return Math.ceil(n);
+    }, 'number', false, []],
+
+    round: [function(n) {
+        if (arguments.length != 1) {
+            throw Error('Function round expects (number)');
+        }
+        n = n.number(this);
+        return Math.round(n);
+    }, 'number', false, []]
+};
+
+FunctionCall.parse = function(lexer) {
+    var expr, func = new FunctionCall(lexer.next());
+    lexer.next();
+    while (lexer.peek() != ')') {
+        if (lexer.empty()) {
+            throw Error('missing function argument list');
+        }
+        expr = BinaryExpr.parse(lexer);
+        func.arg(expr);
+        if (lexer.peek() != ',') break;
+        lexer.next();
+    }
+    if (lexer.empty()) {
+        throw Error('unclosed function argument list');
+    }
+    if (lexer.next() != ')') {
+        lexer.back();
+        throw Error('bad token: ' + lexer.next());
+    }
+    return func
+};
+
+FunctionCall.prototype = new BaseExpr();
+
+FunctionCall.prototype.evaluate = function (ctx) {
+    return this.func.apply(ctx, this.args);
+};
+
+FunctionCall.prototype.arg = function(arg) {
+    this.args.push(arg);
+
+    if (arg.needContextPosition) {
+        this.needContextPosition = true;
+    }
+
+    var args = this.args;
+    if (arg.needContextNode) {
+        args.needContexNode = true;
+    }
+    this.needContextNode = args.needContextNode ||
+                            this.needContextNodeInfo[args.length];
+};
+
+FunctionCall.prototype.show = function(indent) {
+    indent = indent || '';
+    var t = '';
+    t += indent + 'function: ' + this.name + '\n';
+    indent += '    ';
+
+    if (this.args.length) {
+        t += indent + 'arguments: ' + '\n';
+        indent += '    ';
+        for (var i = 0; i < this.args.length; i ++) {
+            t += this.args[i].show(indent);
+        }
+    }
+
+    return t;
+};
+
+
+/*@cc_on @if (@_jscript)
+var NodeWrapper = function(node, sourceIndex, subIndex, attributeName) {
+    this.node = node;
+    this.nodeType = node.nodeType;
+    this.sourceIndex = sourceIndex;
+    this.subIndex = subIndex;
+    this.attributeName = attributeName || '';
+    this.order = String.fromCharCode(sourceIndex) + String.fromCharCode(subIndex) + attributeName;
+};
+
+NodeWrapper.prototype.toString = function() {
+    return this.order;
+};
+@else @*/
+var NodeID = {
+    uuid: 1,
+    get: function(node) {
+        return node.__jsxpath_id__ || (node.__jsxpath_id__ = this.uuid++);
+    }
+};
+/*@end @*/
+
+if (!window.NodeSet && window.defaultConfig)
+    window.NodeSet = null;
+    
+NodeSet = function() {
+    this.length = 0;
+    this.nodes = [];
+    this.seen = {};
+    this.idIndexMap = null;
+    this.reserveDels = [];
+};
+
+NodeSet.prototype.isNodeSet = true;
+NodeSet.prototype.isSorted = true;
+
+/*@_cc_on
+NodeSet.prototype.shortcut = true;
+@*/
+
+NodeSet.prototype.merge = function(nodeset) {
+    this.isSorted = false;
+    if (nodeset.only) {
+        return this.push(nodeset.only);
+    }
+
+    if (this.only){
+        var only = this.only;
+        delete this.only;
+        this.push(only);
+        this.length --;
+    }
+
+    var nodes = nodeset.nodes;
+    for (var i = 0, l = nodes.length; i < l; i ++) {
+        this._add(nodes[i]);
+    }
+};
+
+NodeSet.prototype.sort = function() {
+    if (this.only) return;
+    if (this.sortOff) return;
+
+    if (!this.isSorted) {
+        this.isSorted = true;
+        this.idIndexMap = null;
+
+/*@cc_on
+        if (this.shortcut) {
+            this.nodes.sort();
+        }
+        else {
+            this.nodes.sort(function(a, b) {
+                var result;
+                result = a.sourceIndex - b.sourceIndex;
+                if (result == 0)
+                    return a.subIndex - a.subIndex;
+                else
+                    return result;
+            });
+        }
+        return;
+@*/
+        var nodes = this.nodes;
+        nodes.sort(function(a, b) {
+            if (a == b) return 0;
+
+            if (a.compareDocumentPosition) {
+                var result = a.compareDocumentPosition(b);
+                if (result & 2) return 1;
+                if (result & 4) return -1;
+                return 0;
+            }
+            else {
+                var node1 = a, node2 = b, ancestor1 = a, ancestor2 = b, deep1 = 0, deep2 = 0;
+
+                while(ancestor1 = ancestor1.parentNode) deep1 ++;
+                while(ancestor2 = ancestor2.parentNode) deep2 ++;
+
+                // same deep
+                if (deep1 > deep2) {
+                    while (deep1-- != deep2) node1 = node1.parentNode;
+                    if (node1 == node2) return 1;
+                }
+                else if (deep2 > deep1) {
+                    while (deep2-- != deep1) node2 = node2.parentNode;
+                    if (node1 == node2) return -1;
+                }
+
+                while ((ancestor1 = node1.parentNode) != (ancestor2 = node2.parentNode)) {
+                    node1 = ancestor1;
+                    node2 = ancestor2;
+                }
+
+                // node1 is node2's sibling
+                while (node1 = node1.nextSibling) if (node1 == node2) return -1;
+
+                return 1;
+            }
+        });
+    }
+};
+
+
+/*@cc_on @if (@_jscript)
+NodeSet.prototype.sourceOffset = 1;
+NodeSet.prototype.subOffset = 2;
+NodeSet.prototype.createWrapper = function(node) {
+    var parent, child, attributes, attributesLength, sourceIndex, subIndex, attributeName;
+
+    sourceIndex = node.sourceIndex;
+
+    if (typeof sourceIndex != 'number') {
+        type = node.nodeType;
+        switch (type) {
+            case 2:
+                parent = node.parentNode;
+                sourceIndex = node.parentSourceIndex;
+                subIndex = -1;
+                attributeName = node.nodeName;
+                break;
+            case 9:
+                subIndex = -2;
+                sourceIndex = -1;
+                break;
+            default:
+                child = node;
+                subIndex = 0;
+                do {
+                    subIndex ++;
+                    sourceIndex = child.sourceIndex;
+                    if (sourceIndex) {
+                        parent = child;
+                        child = child.lastChild;
+                        if (!child) {
+                            child = parent;
+                            break;
+                        }
+                        subIndex ++;
+                    }
+                } while (child = child.previousSibling);
+                if (!sourceIndex) {
+                    sourceIndex = node.parentNode.sourceIndex;
+                }
+                break;
+        }
+    }
+    else {
+        subIndex = -2;
+    }
+
+    sourceIndex += this.sourceOffset;
+    subIndex += this.subOffset;
+
+    return new NodeWrapper(node, sourceIndex, subIndex, attributeName);
+};
+
+NodeSet.prototype.reserveDelBySourceIndexAndSubIndex = function(sourceIndex, subIndex, offset, reverse) {
+    var map = this.createIdIndexMap();
+    var index;
+    if ((map = map[sourceIndex]) && (index = map[subIndex])) {
+        if (reverse && (this.length - offset - 1) > index || !reverse && offset < index) {
+            var obj = {
+                value: index,
+                order: String.fromCharCode(index),
+                toString: function() { return this.order },
+                valueOf: function() { return this.value }
+            };
+            this.reserveDels.push(obj);
+        }
+    }
+};
+@else @*/
+NodeSet.prototype.reserveDelByNodeID = function(id, offset, reverse) {
+    var map = this.createIdIndexMap();
+    var index;
+    if (index = map[id]) {
+        if (reverse && (this.length - offset - 1) > index || !reverse && offset < index) {
+            var obj = {
+                value: index,
+                order: String.fromCharCode(index),
+                toString: function() { return this.order },
+                valueOf: function() { return this.value }
+            };
+            this.reserveDels.push(obj);
+        }
+    }
+};
+/*@end @*/
+
+NodeSet.prototype.reserveDelByNode = function(node, offset, reverse) {
+/*@cc_on @if (@_jscript)
+    node = this.createWrapper(node);
+    this.reserveDelBySourceIndexAndSubIndex(node.sourceIndex, node.subIndex, offset, reverse);
+@else @*/
+    this.reserveDelByNodeID(NodeID.get(node), offset, reverse);
+/*@end @*/
+};
+
+NodeSet.prototype.doDel = function() {
+    if (!this.reserveDels.length) return;
+
+    if (this.length < 0x10000) {
+        var dels = this.reserveDels.sort(function(a, b) { return b - a });
+    }
+    else {
+        var dels = this.reserveDels.sort(function(a, b) { return b - a });
+    }
+    for (var i = 0, l = dels.length; i < l; i ++) {
+        this.del(dels[i]);
+    }
+    this.reserveDels = [];
+    this.idIndexMap = null;
+};
+
+NodeSet.prototype.createIdIndexMap = function() {
+    if (this.idIndexMap) {
+        return this.idIndexMap;
+    }
+    else {
+        var map = this.idIndexMap = {};
+        var nodes = this.nodes;
+        for (var i = 0, l = nodes.length; i < l; i ++) {
+            var node = nodes[i];
+/*@cc_on @if (@_jscript)
+            var sourceIndex = node.sourceIndex;
+            var subIndex = node.subIndex;
+            if (!map[sourceIndex]) map[sourceIndex] = {};
+            map[sourceIndex][subIndex] = i;
+@else @*/
+            var id = NodeID.get(node);
+            map[id] = i;
+/*@end @*/
+        }
+        return map;
+    }
+};
+
+NodeSet.prototype.del = function(index) {
+    this.length --;
+    if (this.only) {
+        delete this.only;
+    }
+    else {  
+        var node = this.nodes.splice(index, 1)[0];
+
+        if (this._first == node) {
+            delete this._first;
+            delete this._firstSourceIndex;
+            delete this._firstSubIndex;
+        }
+
+/*@cc_on @if (@_jscript)
+        delete this.seen[node.sourceIndex][node.subIndex];
+@else @*/
+        delete this.seen[NodeID.get(node)];
+/*@end @*/
+    }
+};
+
+
+NodeSet.prototype.delDescendant = function(elm, offset) {
+    if (this.only) return;
+    var nodeType = elm.nodeType;
+    if (nodeType != 1 && nodeType != 9) return;
+    if (uai.applewebkit2) return;
+
+    // element || document
+    if (!elm.contains) {
+        if (nodeType == 1) {
+            var _elm = elm;
+            elm = {
+                contains: function(node) {
+                    return node.compareDocumentPosition(_elm) & 8;
+                }
+            };
+        }
+        else {
+            // document
+            elm = {
+                contains: function() {
+                    return true;
+                }
+            };
+        }
+    }
+
+    var nodes = this.nodes;
+    for (var i = offset + 1; i < nodes.length; i ++) {
+
+/*@cc_on @if (@_jscript)
+        if (nodes[i].node.nodeType == 1 && elm.contains(nodes[i].node)) {
+@else @*/
+        if (elm.contains(nodes[i])) {
+/*@end @*/
+            this.del(i);
+            i --;
+        }
+    }
+};
+
+NodeSet.prototype._add = function(node, reverse) {
+
+/*@cc_on @if (@_jscript)
+
+    var first, firstSourceIndex, firstSubIndex, sourceIndex, subIndex, attributeName;
+
+    sourceIndex = node.sourceIndex;
+    subIndex = node.subIndex;
+    attributeName = node.attributeName;
+    seen = this.seen;
+
+    seen = seen[sourceIndex] || (seen[sourceIndex] = {});
+
+    if (node.nodeType == 2) {
+        seen = seen[subIndex] || (seen[subIndex] = {});
+        if (seen[attributeName]) {
+            return true;
+        }
+        seen[attributeName] = true;
+    }
+    else {
+        if (seen[subIndex]) {
+            return true;
+        }
+        seen[subIndex] = true;
+    }
+
+    if (sourceIndex >= 0x10000 || subIndex >= 0x10000) {
+        this.shortcut = false;
+    }
+
+    // if this._first is undefined and this.nodes is not empty
+    // then first node shortcut is disabled.
+    if (this._first || this.nodes.length == 0) {
+        first = this._first;
+        firstSourceIndex = this._firstSourceIndex;
+        firstSubIndex = this._firstSubIndex;
+        if (!first || firstSourceIndex > sourceIndex || (firstSourceIndex == sourceIndex && firstSubIndex > subIndex)) {
+            this._first = node;
+            this._firstSourceIndex = sourceIndex;
+            this._firstSubIndex = subIndex
+        }
+    }
+
+@else @*/
+
+    var seen = this.seen;
+    var id = NodeID.get(node);
+    if (seen[id]) return true;
+    seen[id] = true;
+
+/*@end @*/
+
+    this.length++;
+    if (reverse) 
+        this.nodes.unshift(node);
+    else
+        this.nodes.push(node);
+};
+
+
+NodeSet.prototype.unshift = function(node) {
+    if (!this.length) {
+        this.length ++;
+        this.only = node;
+        return
+    }
+    if (this.only){
+        var only = this.only;
+        delete this.only;
+        this.unshift(only);
+        this.length --;
+    }
+/*@cc_on
+    node = this.createWrapper(node);
+@*/
+    return this._add(node, true);
+};
+
+
+NodeSet.prototype.push = function(node) {
+    if (!this.length) {
+        this.length ++;
+        this.only = node;
+        return;
+    }
+    if (this.only) {
+        var only = this.only;
+        delete this.only;
+        this.push(only);
+        this.length --;
+    }
+/*@cc_on
+    node = this.createWrapper(node);
+@*/
+    return this._add(node);
+};
+
+NodeSet.prototype.first = function() {
+    if (this.only) return this.only;
+/*@cc_on
+    if (this._first) return this._first.node;
+    if (this.nodes.length > 1) this.sort();
+    var node = this.nodes[0];
+    return node ? node.node : undefined;
+@*/
+    if (this.nodes.length > 1) this.sort();
+    return this.nodes[0];
+};
+
+NodeSet.prototype.list = function() {
+    if (this.only) return [this.only];
+    this.sort();
+/*@cc_on
+    var i, l, nodes, results;
+    nodes = this.nodes;
+    results = [];
+    for (i = 0, l = nodes.length; i < l; i ++) {
+        results.push(nodes[i].node);
+    }
+    return results;
+@*/
+    return this.nodes;
+};
+
+NodeSet.prototype.string = function() {
+    var node = this.only || this.first();
+    return node ? NodeUtil.to('string', node) : '';
+};
+
+NodeSet.prototype.bool = function() {
+    return !! (this.length || this.only);
+};
+
+NodeSet.prototype.number = function() {
+    return + this.string();
+};
+
+NodeSet.prototype.iterator = function(reverse) {
+    this.sort();
+    var nodeset = this;
+
+    if (!reverse) {
+        var count = 0;
+        return function() {
+            if (nodeset.only && count++ == 0) return nodeset.only;
+/*@cc_on @if(@_jscript)
+            var wrapper = nodeset.nodes[count++];
+            if (wrapper) return wrapper.node;
+            return undefined;
+@else @*/
+            return nodeset.nodes[count++];
+/*@end @*/
+        };
+    }
+    else {
+        var count = 0;
+        return function() {
+            var index = nodeset.length - (count++) - 1;
+            if (nodeset.only && index == 0) return nodeset.only;
+/*@cc_on @if(@_jscript)
+            var wrapper = nodeset.nodes[index];
+            if (wrapper) return wrapper.node;
+            return undefined;
+@else @*/
+            return nodeset.nodes[index];
+/*@end @*/
+        };
+    }
+};
+
+
+var install = function(win) {
+
+    win = win || this;
+    var doc = win.document;
+    var undefined = win.undefined;
+
+    win.XPathExpression = function(expr) {
+        if (!expr.length) {
+            throw win.Error('no expression');
+        }
+        var lexer = this.lexer = Lexer(expr);
+        if (lexer.empty()) {
+            throw win.Error('no expression');
+        }
+        this.expr = BinaryExpr.parse(lexer);
+        if (!lexer.empty()) {
+            throw win.Error('bad token: ' + lexer.next());
+        }
+    };
+    
+    win.XPathExpression.prototype.evaluate = function(node, type) {
+        return new win.XPathResult(this.expr.evaluate(new Ctx(node)), type);
+    };
+    
+    win.XPathResult = function (value, type) {
+        if (type == 0) {
+            switch (typeof value) {
+                case 'object':  type ++; // 4
+                case 'boolean': type ++; // 3
+                case 'string':  type ++; // 2
+                case 'number':  type ++; // 1
+            }
+        }
+    
+        this.resultType = type;
+    
+        switch (type) {
+            case 1:
+                this.numberValue = value.isNodeSet ? value.number() : +value;
+                return;
+            case 2:
+                this.stringValue = value.isNodeSet ? value.string() : '' + value;
+                return;
+            case 3:
+                this.booleanValue = value.isNodeSet ? value.bool() : !! value;
+                return;
+            case 4: case 5: case 6: case 7:
+                this.nodes = value.list();
+                this.snapshotLength = value.length;
+                this.index = 0;
+                this.invalidIteratorState = false;
+                break;
+            case 8: case 9:
+                this.singleNodeValue = value.first();
+                return;
+        }
+    };
+    
+    win.XPathResult.prototype.iterateNext = function() { return this.nodes[this.index++] };
+    win.XPathResult.prototype.snapshotItem = function(i) { return this.nodes[i] };
+    
+    win.XPathResult.ANY_TYPE = 0;
+    win.XPathResult.NUMBER_TYPE = 1;
+    win.XPathResult.STRING_TYPE = 2;
+    win.XPathResult.BOOLEAN_TYPE = 3;
+    win.XPathResult.UNORDERED_NODE_ITERATOR_TYPE = 4;
+    win.XPathResult.ORDERED_NODE_ITERATOR_TYPE = 5;
+    win.XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE = 6;
+    win.XPathResult.ORDERED_NODE_SNAPSHOT_TYPE = 7;
+    win.XPathResult.ANY_UNORDERED_NODE_TYPE = 8;
+    win.XPathResult.FIRST_ORDERED_NODE_TYPE = 9;
+    
+    
+    doc.createExpression = function(expr) {
+        return new win.XPathExpression(expr, null);
+    };
+    
+    doc.evaluate = function(expr, context, _, type) {
+        return doc.createExpression(expr, null).evaluate(context, type);
+    };
+};
+
+var win;
+
+if (config.targetFrame) {
+    var frame = document.getElementById(config.targetFrame);
+    if (frame) win = frame.contentWindow;
+}
+
+if (config.exportInstaller) {
+    window.install = install;
+}
+
+if (!config.hasNative || !config.useNative) {
+    install(win || window);
+}
+
+
+})();
+
+// Thanks for reading this source code. We love JavaScript.
+