RubyGems - rubinium - Versions diffs - 0.1.1 - Mend

rubinium 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (161) hide show

data/vendor/selenium-0.6.0/selenium/tests/readme.txt ADDED

	@@ -0,0 +1 @@
1	+ Create a TestSuite.html page, and a number of test pages here. Read the docs!

data/vendor/selenium-0.6.0/selenium/tests/tableparser/tableparser-tests.html ADDED

@@ -0,0 +1,122 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<!--
+Copyright 2004 ThoughtWorks, Inc
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+     http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<html>
+  <head>
+	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <title>JsUnit Utility Tests</title>
+    <link rel="stylesheet" type="text/css" href="jsunit/css/jsUnitStyle.css">
+<script language="JavaScript" type="text/javascript" src="/jsunit/app/jsUnitCore.js"></script>
+<script language="JavaScript" type="text/javascript" src="/jsmock/mock.js"></script>
+<script language="JavaScript" type="text/javascript" src="/selenium-commandhandlers.js"></script>
+<script language="JavaScript" type="text/javascript" src="/selenium-tableparser.js"></script>
+<script language="JavaScript" type="text/javascript" src="/htmlutils.js"></script>
+<script language="JavaScript" type="text/javascript">
+///////////////////// HTML TABLE PARSING /////////////////////
+function setUp() {
+    tableParser = new TableParser();
+}
+function assertCommand(expectedName, expectedTarget, expectedValue, command) {
+    assertEquals(expectedName, command.command);
+    assertEquals(expectedTarget, command.target);
+    assertEquals(expectedValue, command.value);
+}
+function testShouldParseOneArgHtmlTableRowToJavascript() {
+    var row = document.getElementsByTagName("table")[0].rows[1]
+    var command = tableParser.createCommandFromHtmlRow(row);
+    assertCommand("click", "someButton", "", command);
+}
+function testShouldParseTwoArgHtmlTableRowToJavascript() {
+    var row = document.getElementsByTagName("table")[0].rows[2]
+    var command = tableParser.createCommandFromHtmlRow(row);
+    assertCommand("verifyText", "someButton", "Click me!", command);
+}
+function testShouldFailWithBadWikiRowFormat() {
+    var row = document.getElementsByTagName("table")[0].rows[3]
+    try {
+        tableParser.createCommandFromHtmlRow(row)
+        fail("Should fail")
+    } catch(expected) {
+        assertEquals("Bad HTML row format. Rows must have 3 coumns, but had 4", expected.message)
+    }
+}
+///////////////////// WIKI TABLE PARSING /////////////////////
+function testShouldParseOneArgWikiTableRowToJavascript() {
+    var wikiRow = "| click | someButton ||"
+    var command = tableParser.createCommandFromWikiRow(wikiRow);
+    assertCommand("click", "someButton", "", command);
+}
+function testShouldParseTwoArgWikiTableRowToJavascript() {
+    var wikiRow = "| verifyText | someButton |Click me!|"
+    var command = tableParser.createCommandFromWikiRow(wikiRow);
+    assertCommand("verifyText", "someButton", "Click me!", command);
+}
+function testShouldFailWithBadWikiRowFormat() {
+    var wikiRow = "| verifyText | someButton |Click me!||"
+    try {
+        tableParser.createCommandFromWikiRow(wikiRow);
+        fail("Should fail")
+    } catch(expected) {
+        assertEquals("Bad wiki row format:| verifyText | someButton |Click me!||", expected.message)
+    }
+}
+</script>
+  </head>
+  <body>
+    <h1>TableParser Tests</h1>
+    <p>This page contains tests for TableParser. To see them, take a look at the source. To run them, load this file via JsUnit's testRunner.html</p>
+<input id="someField"/>
+<table cellpadding="1" cellspacing="1" border="1">
+  <tbody>
+    <tr>
+      <td rowspan="1" colspan="3">Test Type<br>
+      </td>
+    </tr>
+    <tr>
+      <td>click</td>
+      <td>someButton</td>
+      <td>&nbsp;</td>
+    </tr>
+    <tr>
+      <td>verifyText</td>
+      <td>someButton</td>
+      <td>Click me!</td>
+    </tr>
+    <tr>
+      <td>this</td>
+      <td>is</td>
+      <td>a bad</td>
+      <td>row</td>
+    </tr>
+  </tbody>
+</table>
+  </body>
+</html>

data/vendor/selenium-0.6.0/selenium/tests/tinyWebServer.py ADDED

@@ -0,0 +1,70 @@
+# Copyright 2004 ThoughtWorks, Inc
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+# minimal web server.
+# serves files relative to the current directory.
+# cgi-bin directory serves Python CGIs.
+import BaseHTTPServer
+import CGIHTTPServer
+import time
+import httplib
+import sys
+PORT = 8000
+class HTTPHandler(CGIHTTPServer.CGIHTTPRequestHandler):
+    """
+    Simple Web Server that can handle query strings in a request URL and can be stopped with a request
+    """
+    quitRequestReceived = False
+    def do_GET(self):
+        # SimpleHTTPServer doesn't know how to handle query strings in
+        # 'GET' requests, so we're processing them here:
+        if self.path.find('?') != -1:
+            self.path, self.query_string = self.path.split('?', 1)
+        else:
+            self.query_string = ''
+        # Add a delay before serving up the slow-loading test page
+        if self.path.find('test_slowloading_page') != -1:
+            time.sleep(0.3)
+        # Carry on with the rest of the processing...
+        CGIHTTPServer.CGIHTTPRequestHandler.do_GET(self)
+    def do_QUIT(self):
+        self.send_response(200)
+        self.end_headers()
+        HTTPHandler.quitRequestReceived = True
+if __name__ == '__main__':
+	port = PORT
+	if len(sys.argv) > 1:
+	    port = int(sys.argv[1])
+        server_address = ('', port)
+    	httpd = BaseHTTPServer.HTTPServer(server_address, HTTPHandler)
+    	print "serving at port", port
+    	print "To access the Selenium test suite, open"
+    	print "  http://localhost:%s/index.html" % port
+    	while not HTTPHandler.quitRequestReceived :
+        	httpd.handle_request()

data/vendor/selenium-0.6.0/selenium/user-extensions.js.sample ADDED

@@ -0,0 +1,62 @@
+/*
+ * By default, Selenium looks for a file called "user-extensions.js", and loads and javascript
+ * code found in that file. This file is a sample of what that file could look like.
+ *
+ * user-extensions.js provides a convenient location for adding extensions to Selenium, like
+ * new actions, checks and locator-strategies.
+ * By default, this file does not exist. Users can create this file and place their extension code
+ * in this common location, removing the need to modify the Selenium sources, and hopefully assisting
+ * with the upgrade process.
+ */
+// The following examples try to give an indication of how Selenium can be extended with javascript.
+// All do* methods on the Selenium prototype are added as actions.
+// Eg add a typeRepeated action to Selenium, which types the text twice into a text box.
+// The typeTwiceAndWait command will be available automatically
+Selenium.prototype.doTypeRepeated = function(locator, text) {
+    // All locator-strategies are automatically handled by "findElement"
+    var element = this.page().findElement(locator);
+    // Create the text to type
+    var valueToType = text + text;
+    // Replace the element text with the new text
+    this.page().replaceText(element, valueToType);
+};
+// All assert* methods on the Selenium prototype are added as checks.
+// Eg add a assertValueRepeated check, that makes sure that the element value
+// consists of the supplied text repeated.
+// The verify version will be available automatically.
+Selenium.prototype.assertValueRepeated = function(locator, text) {
+    // All locator-strategies are automatically handled by "findElement"
+    var element = this.page().findElement(locator);
+    // Create the text to verify
+    var expectedValue = text + text;
+    // Get the actual element value
+    var actualValue = element.value;
+    // Make sure the actual value matches the expected
+    this.assertMatches(expectedValue, actualValue);
+};
+// All locateElementBy* methods are added as locator-strategies.
+// Eg add a "valuerepeated=" locator, that finds the first element with the supplied value, repeated.
+// The "inDocument" is a the document you are searching.
+PageBot.prototype.locateElementByValueRepeated = function(text, inDocument) {
+    // Create the text to search for
+    var expectedValue = text + text;
+    // Loop through all elements, looking for ones that have a value === our expected value
+    var allElements = inDocument.getElementsByTagName("*");
+    for (var i = 0; i < allElements.length; i++) {
+        var testElement = allElements[i];
+        if (testElement.value && testElement.value === expectedValue) {
+            return testElement;
+        }
+    }
+    return null;
+};

data/vendor/selenium-0.6.0/selenium/version.txt ADDED

	@@ -0,0 +1 @@
1	+ 0.6.0

data/vendor/selenium-0.6.0/selenium/xmlextras.js ADDED

@@ -0,0 +1,153 @@
+// This is a third party JavaScript library from
+// http://webfx.eae.net/dhtml/xmlextras/xmlextras.html
+// i.e. This has not been written by ThoughtWorks.
+//<script>
+//////////////////
+// Helper Stuff //
+//////////////////
+// used to find the Automation server name
+function getDomDocumentPrefix() {
+	if (getDomDocumentPrefix.prefix)
+		return getDomDocumentPrefix.prefix;
+	var prefixes = ["MSXML2", "Microsoft", "MSXML", "MSXML3"];
+	var o;
+	for (var i = 0; i < prefixes.length; i++) {
+		try {
+			// try to create the objects
+			o = new ActiveXObject(prefixes[i] + ".DomDocument");
+			return getDomDocumentPrefix.prefix = prefixes[i];
+		}
+		catch (ex) {};
+	}
+	throw new Error("Could not find an installed XML parser");
+}
+function getXmlHttpPrefix() {
+	if (getXmlHttpPrefix.prefix)
+		return getXmlHttpPrefix.prefix;
+	var prefixes = ["MSXML2", "Microsoft", "MSXML", "MSXML3"];
+	var o;
+	for (var i = 0; i < prefixes.length; i++) {
+		try {
+			// try to create the objects
+			o = new ActiveXObject(prefixes[i] + ".XmlHttp");
+			return getXmlHttpPrefix.prefix = prefixes[i];
+		}
+		catch (ex) {};
+	}
+	throw new Error("Could not find an installed XML parser");
+}
+//////////////////////////
+// Start the Real stuff //
+//////////////////////////
+// XmlHttp factory
+function XmlHttp() {}
+XmlHttp.create = function () {
+	try {
+		if (window.XMLHttpRequest) {
+			var req = new XMLHttpRequest();
+			// some versions of Moz do not support the readyState property
+			// and the onreadystate event so we patch it!
+			if (req.readyState == null) {
+				req.readyState = 1;
+				req.addEventListener("load", function () {
+					req.readyState = 4;
+					if (typeof req.onreadystatechange == "function")
+						req.onreadystatechange();
+				}, false);
+			}
+			return req;
+		}
+		if (window.ActiveXObject) {
+			return new ActiveXObject(getXmlHttpPrefix() + ".XmlHttp");
+		}
+	}
+	catch (ex) {}
+	// fell through
+	throw new Error("Your browser does not support XmlHttp objects");
+};
+// XmlDocument factory
+function XmlDocument() {}
+XmlDocument.create = function () {
+	try {
+		// DOM2
+		if (document.implementation && document.implementation.createDocument) {
+			var doc = document.implementation.createDocument("", "", null);
+			// some versions of Moz do not support the readyState property
+			// and the onreadystate event so we patch it!
+			if (doc.readyState == null) {
+				doc.readyState = 1;
+				doc.addEventListener("load", function () {
+					doc.readyState = 4;
+					if (typeof doc.onreadystatechange == "function")
+						doc.onreadystatechange();
+				}, false);
+			}
+			return doc;
+		}
+		if (window.ActiveXObject)
+			return new ActiveXObject(getDomDocumentPrefix() + ".DomDocument");
+	}
+	catch (ex) {}
+	throw new Error("Your browser does not support XmlDocument objects");
+};
+// Create the loadXML method and xml getter for Mozilla
+if (window.DOMParser &&
+	window.XMLSerializer &&
+	window.Node && Node.prototype && Node.prototype.__defineGetter__) {
+	// XMLDocument did not extend the Document interface in some versions
+	// of Mozilla. Extend both!
+	//XMLDocument.prototype.loadXML =
+	Document.prototype.loadXML = function (s) {
+		// parse the string to a new doc
+		var doc2 = (new DOMParser()).parseFromString(s, "text/xml");
+		// remove all initial children
+		while (this.hasChildNodes())
+			this.removeChild(this.lastChild);
+		// insert and import nodes
+		for (var i = 0; i < doc2.childNodes.length; i++) {
+			this.appendChild(this.importNode(doc2.childNodes[i], true));
+		}
+	};
+	/*
+	 * xml getter
+	 *
+	 * This serializes the DOM tree to an XML String
+	 *
+	 * Usage: var sXml = oNode.xml
+	 *
+	 */
+	// XMLDocument did not extend the Document interface in some versions
+	// of Mozilla. Extend both!
+	/*
+	XMLDocument.prototype.__defineGetter__("xml", function () {
+		return (new XMLSerializer()).serializeToString(this);
+	});
+	*/
+	Document.prototype.__defineGetter__("xml", function () {
+		return (new XMLSerializer()).serializeToString(this);
+	});
+}

data/vendor/selenium-0.6.0/selenium/xpath.js ADDED

@@ -0,0 +1,3910 @@
+/*
+ * 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 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
+ */
+// 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) {
+		return new NodeTest(NodeTest.NAMETESTPREFIXANY, rhs[0].substring(0, rhs[0].indexOf(":") - 1));
+	};
+	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(c) {
+	c.contextNode = c.expressionContextNode;
+	c.contextSize = 1;
+	c.contextPosition = 1;
+	c.caseInsensitive = false;
+	if (c.contextNode != null) {
+		var doc = c.contextNode;
+		if (doc.nodeType != 9 /*Node.DOCUMENT_NODE*/) {
+			doc = doc.ownerDocument;
+		}
+		c.caseInsensitive = doc.implementation == null
+			|| doc.implementation.hasFeature("HTML", "2.0");
+	}
+	return this.expression.evaluate(c);
+};
+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 nodset 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 {
+					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:
+						// 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:
+						// 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:
+						// 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:
+						// look at all child elements
+						for (var m = xpc.contextNode.firstChild; m != null; m = m.nextSibling) {
+							if (step.nodeTest.matches(m, xpc)) {
+								newNodes.push(m);
+							}
+						}
+						break;
+					case Step.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:
+						// 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:
+						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:
+						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:
+						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:
+						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:
+						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:
+						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:
+						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)
+	if (n.selectSingleNode) {
+		return n.selectSingleNode("..");
+	}
+	// 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.toString = function() {
+	switch (this.type) {
+		case NodeTest.NAMETESTANY:
+			return "*";
+		case NodeTest.NAMETESTPREFIXANY:
+			return this.value + ":*";
+		case NodeTest.NAMETESTQNAME:
+			return 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.prototype.matches = function(n, xpc) {
+	switch (this.type) {
+		case NodeTest.NAMETESTANY:
+			if (n.nodeType == 2 /*Node.ATTRIBUTE_NODE*/
+					|| n.nodeType == 1 /*Node.ELEMENT_NODE*/
+					|| n.nodeType == NodeTest.NAMESPACE_NODE) {
+				return true;
+			}
+			return false;
+		case NodeTest.NAMETESTPREFIXANY:
+			if ((n.nodeType == 2 /*Node.ATTRIBUTE_NODE*/ || n.nodeType == 1 /*Node.ELEMENT_NODE*/)
+					&& n.namespaceURI == xpc.namespaceResolver.getNamespace(this.value, xpc.expressionContextNode)) {
+				return true;
+			}
+			return false;
+		case NodeTest.NAMETESTQNAME:
+			if (n.nodeType == 2 /*Node.ATTRIBUTE_NODE*/
+					|| n.nodeType == 1 /*Node.ELEMENT_NODE*/
+					|| n.nodeType == NodeTest.NAMESPACE_NODE) {
+				var test = Utilities.resolveQName(this.value, xpc.namespaceResolver, xpc.expressionContextNode, false);
+				test[0] = String(test[0]);
+				if (test[0] == "") {
+					test[0] = null;
+				}
+				var node = Utilities.resolveQName(n.nodeName, xpc.namespaceResolver, xpc.contextNode, true);
+				node[0] = String(node[0]);
+				if (node[0] == "") {
+					node[0] = null;
+				}
+				if (xpc.caseInsensitive) {
+					return test[0] == node[0] && String(test[1]).toLowerCase() == String(node[1]).toLowerCase();
+				}
+				return test[0] == node[0] && test[1] == 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.NAMETESTANY = 0;
+NodeTest.NAMETESTPREFIXANY = 1;
+NodeTest.NAMETESTQNAME = 2;
+NodeTest.COMMENT = 3;
+NodeTest.TEXT = 4;
+NodeTest.PI = 5;
+NodeTest.NODE = 6;
+NodeTest.NAMESPACE_NODE = 1024;
+// 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());
+};
+// 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) {
+	if (this.tree == null) {
+		this.tree = new Object();
+		this.tree.node = n;
+		this.tree.left = null;
+		this.tree.right = null;
+		this.size = 1;
+		return;
+	}
+	var p = this.tree;
+	while (1) {
+		var o = this.order(n, p.node);
+		if (o == 0) {
+			return;
+		}
+		if (o > 0) {
+			if (p.right == null) {
+				p.right = new Object();
+				p.right.node = n;
+				p.right.left = null;
+				p.right.right = null;
+				this.size++;
+				return;
+			}
+			p = p.right;
+		} else {
+			if (p.left == null) {
+				p.left = new Object();
+				p.left.node = n;
+				p.left.left = null;
+				p.left.right = null;
+				this.size++;
+				return;
+			}
+			p = p.left;
+		}
+	}
+};
+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.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;
+};
+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;
+};
+// NamespaceNode /////////////////////////////////////////////////////////////
+NamespaceNode.prototype = new Object();
+NamespaceNode.prototype.constructor = NamespaceNode;
+NamespaceNode.superclass = Object.prototype;
+function NamespaceNode(pre, ns, p) {
+	this.isNamespaceNode = true;
+	this.prefix = pre;
+	this.namespace = ns;
+	this.parentNode = p;
+	this.localName = pre;
+	this.nodeType = NodeTest.NAMESPACE_NODE;
+}
+NamespaceNode.prototype.toString = function() {
+	return "{ \"" + this.prefix + "\", \"" + this.namespace + "\" }";
+};
+// 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);
+	}
+	return this.getVariableWithName(parts[0], parts[1], c.expressionContextNode);
+};
+VariableResolver.prototype.getVariableWithName = function(ns, ln, c) {
+	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.addStandardFunctions = function() {
+	this.functions["{}last"] = Functions.last;
+	this.functions["{}position"] = Functions.position;
+	this.functions["{}count"] = Functions.count;
+	this.functions["{}id"] = Functions.id;
+	this.functions["{}local-name"] = Functions.localName;
+	this.functions["{}namespace-uri"] = Functions.namespaceURI;
+	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;
+};
+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);
+	return this.getFunctionWithName(parts[0], parts[1], c.contextNode);
+};
+FunctionResolver.prototype.getFunctionWithName = function(ns, ln, c) {
+	return this.functions["{" + ns + "}" + ln];
+};
+// 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 != 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 a.nodeValue;
+			}
+		}
+		n = n.parentNode;
+	}
+	return null;
+};
+// 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.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.localName = 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 local-name expects (node-set?)");
+	}
+	if (n == null) {
+		return new XString("");
+	}
+	return new XString(n.localName ? n.localName : n.baseName);
+};
+Functions.namespaceURI = 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 namespace-uri expects (node-set?)");
+	}
+	if (n == null) {
+		return new XString("");
+	}
+	return new XString(n.namespaceURI);
+};
+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) == prefix);
+};
+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 == 2) {
+		s = XNodeSet.prototype.stringForNode(c.contextNode);
+	} else if (arguments.length == 3) {
+		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) {
+	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) {
+		parts[0] = nr.getNamespace(parts[0], n);
+	} 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.instance_of = function(o, c) {
+	while (o != null) {
+		if (o.constructor === 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;
+};