continuo/dist/js/continuo.js

Select notes on a rendered MEI music score and create permalinks using the Music Addressability URL scheme.

(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
"use strict";

/*
 * jQuery XPath plugin v0.3.1
 * https://github.com/ilinsky/jquery-xpath
 * Copyright 2015, Sergey Ilinsky
 * Dual licensed under the MIT and GPL licenses.
 *
 * Includes xpath.js - XPath 2.0 implementation in JavaScript
 * https://github.com/ilinsky/xpath.js
 * Copyright 2015, Sergey Ilinsky
 * Dual licensed under the MIT and GPL licenses.
 *
 */
(function () {

	var cString = window.String,
	    cBoolean = window.Boolean,
	    cNumber = window.Number,
	    cObject = window.Object,
	    cArray = window.Array,
	    cRegExp = window.RegExp,
	    cDate = window.Date,
	    cFunction = window.Function,
	    cMath = window.Math,
	    cError = window.Error,
	    cSyntaxError = window.SyntaxError,
	    cTypeError = window.TypeError,
	    fIsNaN = window.isNaN,
	    fIsFinite = window.isFinite,
	    nNaN = window.NaN,
	    nInfinity = window.Infinity,
	    fWindow_btoa = window.btoa,
	    fWindow_atob = window.atob,
	    fWindow_parseInt = window.parseInt,
	    fString_trim = function () {
		return cString.prototype.trim ? function (sValue) {
			return cString(sValue).trim();
		} : function (sValue) {
			return cString(sValue).replace(/^\s+|\s+$/g, '');
		};
	}(),
	    fArray_indexOf = function () {
		return cArray.prototype.indexOf ? function (aValue, vItem) {
			return aValue.indexOf(vItem);
		} : function (aValue, vItem) {
			for (var nIndex = 0, nLength = aValue.length; nIndex < nLength; nIndex++) {
				if (aValue[nIndex] === vItem) return nIndex;
			}return -1;
		};
	}();

	var sNS_XSD = "http://www.w3.org/2001/XMLSchema",
	    sNS_XPF = "http://www.w3.org/2005/xpath-functions",
	    sNS_XNS = "http://www.w3.org/2000/xmlns/",
	    sNS_XML = "http://www.w3.org/XML/1998/namespace";

	function cException(sCode, sMessage) {

		this.code = sCode;
		this.message = sMessage || oException_messages[sCode];
	};

	cException.prototype = new cError();

	var oException_messages = {};
	oException_messages["XPDY0002"] = "Evaluation of an expression relies on some part of the dynamic context that has not been assigned a value.";
	oException_messages["XPST0003"] = "Expression is not a valid instance of the grammar";
	oException_messages["XPTY0004"] = "Type is not appropriate for the context in which the expression occurs";
	oException_messages["XPST0008"] = "Expression refers to an element name, attribute name, schema type name, namespace prefix, or variable name that is not defined in the static context";
	oException_messages["XPST0010"] = "Axis not supported";
	oException_messages["XPST0017"] = "Expanded QName and number of arguments in a function call do not match the name and arity of a function signature";
	oException_messages["XPTY0018"] = "The result of the last step in a path expression contains both nodes and atomic values";
	oException_messages["XPTY0019"] = "The result of a step (other than the last step) in a path expression contains an atomic value.";
	oException_messages["XPTY0020"] = "In an axis step, the context item is not a node.";
	oException_messages["XPST0051"] = "It is a static error if a QName that is used as an AtomicType in a SequenceType is not defined in the in-scope schema types as an atomic type.";
	oException_messages["XPST0081"] = "A QName used in an expression contains a namespace prefix that cannot be expanded into a namespace URI by using the statically known namespaces.";
	oException_messages["FORG0001"] = "Invalid value for cast/constructor.";
	oException_messages["FORG0003"] = "fn:zero-or-one called with a sequence containing more than one item.";
	oException_messages["FORG0004"] = "fn:one-or-more called with a sequence containing no items.";
	oException_messages["FORG0005"] = "fn:exactly-one called with a sequence containing zero or more than one item.";
	oException_messages["FORG0006"] = "Invalid argument type.";
	oException_messages["FODC0001"] = "No context document.";
	oException_messages["FORX0001"] = "Invalid regular expression flags.";
	oException_messages["FOCA0002"] = "Invalid lexical value.";
	oException_messages["FOCH0002"] = "Unsupported collation.";

	oException_messages["FONS0004"] = "No namespace found for prefix.";

	function cLexer(sValue) {
		var aMatch = sValue.match(/\$?(?:(?![0-9-])(?:[\w-]+|\*):)?(?![0-9-])(?:[\w-]+|\*)|\(:|:\)|\/\/|\.\.|::|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?|\.\d+(?:[eE][+-]?\d+)?|"[^"]*(?:""[^"]*)*"|'[^']*(?:''[^']*)*'|<<|>>|[!<>]=|(?![0-9-])[\w-]+:\*|\s+|./g);
		if (aMatch) {
			var nStack = 0;
			for (var nIndex = 0, nLength = aMatch.length; nIndex < nLength; nIndex++) {
				if (aMatch[nIndex] == '(:') nStack++;else if (aMatch[nIndex] == ':)' && nStack) nStack--;else if (!nStack && !/^\s/.test(aMatch[nIndex])) this[this.length++] = aMatch[nIndex];
			}if (nStack) throw new cException("XPST0003", "Unclosed comment");
		}
	};

	cLexer.prototype.index = 0;
	cLexer.prototype.length = 0;

	cLexer.prototype.reset = function () {
		this.index = 0;
	};

	cLexer.prototype.peek = function (nOffset) {
		return this[this.index + (nOffset || 0)] || '';
	};

	cLexer.prototype.next = function (nOffset) {
		return (this.index += nOffset || 1) < this.length;
	};

	cLexer.prototype.back = function (nOffset) {
		return (this.index -= nOffset || 1) > 0;
	};

	cLexer.prototype.eof = function () {
		return this.index >= this.length;
	};

	function cDOMAdapter() {};

	cDOMAdapter.prototype.isNode = function (oNode) {
		return oNode && !!oNode.nodeType;
	};

	cDOMAdapter.prototype.getProperty = function (oNode, sName) {
		return oNode[sName];
	};

	cDOMAdapter.prototype.isSameNode = function (oNode, oNode2) {
		return oNode == oNode2;
	};

	cDOMAdapter.prototype.compareDocumentPosition = function (oNode, oNode2) {
		return oNode.compareDocumentPosition(oNode2);
	};

	cDOMAdapter.prototype.lookupNamespaceURI = function (oNode, sPrefix) {
		return oNode.lookupNamespaceURI(sPrefix);
	};

	cDOMAdapter.prototype.getElementById = function (oNode, sId) {
		return oNode.getElementById(sId);
	};

	cDOMAdapter.prototype.getElementsByTagNameNS = function (oNode, sNameSpaceURI, sLocalName) {
		return oNode.getElementsByTagNameNS(sNameSpaceURI, sLocalName);
	};

	function cDynamicContext(oStaticContext, vItem, oScope, oDOMAdapter) {
		this.staticContext = oStaticContext;
		this.item = vItem;
		this.scope = oScope || {};
		this.stack = {};
		this.DOMAdapter = oDOMAdapter || new cDOMAdapter();
		var oDate = new cDate(),
		    nOffset = oDate.getTimezoneOffset();
		this.dateTime = new cXSDateTime(oDate.getFullYear(), oDate.getMonth() + 1, oDate.getDate(), oDate.getHours(), oDate.getMinutes(), oDate.getSeconds() + oDate.getMilliseconds() / 1000, -nOffset);
		this.timezone = new cXSDayTimeDuration(0, cMath.abs(~~(nOffset / 60)), cMath.abs(nOffset % 60), 0, nOffset > 0);
	};

	cDynamicContext.prototype.item = null;
	cDynamicContext.prototype.position = 0;
	cDynamicContext.prototype.size = 0;
	cDynamicContext.prototype.scope = null;
	cDynamicContext.prototype.stack = null;cDynamicContext.prototype.dateTime = null;
	cDynamicContext.prototype.timezone = null;
	cDynamicContext.prototype.staticContext = null;

	cDynamicContext.prototype.pushVariable = function (sName, vValue) {
		if (!this.stack.hasOwnProperty(sName)) this.stack[sName] = [];
		this.stack[sName].push(this.scope[sName]);
		this.scope[sName] = vValue;
	};

	cDynamicContext.prototype.popVariable = function (sName) {
		if (this.stack.hasOwnProperty(sName)) {
			this.scope[sName] = this.stack[sName].pop();
			if (!this.stack[sName].length) {
				delete this.stack[sName];
				if (typeof this.scope[sName] == "undefined") delete this.scope[sName];
			}
		}
	};

	function cStaticContext() {
		this.dataTypes = {};
		this.documents = {};
		this.functions = {};
		this.collations = {};
		this.collections = {};
	};

	cStaticContext.prototype.baseURI = null;
	cStaticContext.prototype.dataTypes = null;
	cStaticContext.prototype.documents = null;
	cStaticContext.prototype.functions = null;
	cStaticContext.prototype.defaultFunctionNamespace = null;
	cStaticContext.prototype.collations = null;
	cStaticContext.prototype.defaultCollationName = sNS_XPF + "/collation/codepoint";
	cStaticContext.prototype.collections = null;
	cStaticContext.prototype.namespaceResolver = null;
	cStaticContext.prototype.defaultElementNamespace = null;

	var rStaticContext_uri = /^(?:\{([^\}]+)\})?(.+)$/;
	cStaticContext.prototype.setDataType = function (sUri, fFunction) {
		var aMatch = sUri.match(rStaticContext_uri);
		if (aMatch) if (aMatch[1] != sNS_XSD) this.dataTypes[sUri] = fFunction;
	};

	cStaticContext.prototype.getDataType = function (sUri) {
		var aMatch = sUri.match(rStaticContext_uri);
		if (aMatch) return aMatch[1] == sNS_XSD ? hStaticContext_dataTypes[cRegExp.$2] : this.dataTypes[sUri];
	};

	cStaticContext.prototype.setDocument = function (sUri, fFunction) {
		this.documents[sUri] = fFunction;
	};

	cStaticContext.prototype.setFunction = function (sUri, fFunction) {
		var aMatch = sUri.match(rStaticContext_uri);
		if (aMatch) if (aMatch[1] != sNS_XPF) this.functions[sUri] = fFunction;
	};

	cStaticContext.prototype.getFunction = function (sUri) {
		var aMatch = sUri.match(rStaticContext_uri);
		if (aMatch) return aMatch[1] == sNS_XPF ? hStaticContext_functions[cRegExp.$2] : this.functions[sUri];
	};

	cStaticContext.prototype.setCollation = function (sUri, fFunction) {
		this.collations[sUri] = fFunction;
	};

	cStaticContext.prototype.getCollation = function (sUri) {
		return this.collations[sUri];
	};

	cStaticContext.prototype.setCollection = function (sUri, fFunction) {
		this.collections[sUri] = fFunction;
	};

	cStaticContext.prototype.getURIForPrefix = function (sPrefix) {
		var oResolver = this.namespaceResolver,
		    fResolver = oResolver && oResolver.lookupNamespaceURI ? oResolver.lookupNamespaceURI : oResolver,
		    sNameSpaceURI;
		if (fResolver instanceof cFunction && (sNameSpaceURI = fResolver.call(oResolver, sPrefix))) return sNameSpaceURI;
		if (sPrefix == 'fn') return sNS_XPF;
		if (sPrefix == 'xs') return sNS_XSD;
		if (sPrefix == "xml") return sNS_XML;
		if (sPrefix == "xmlns") return sNS_XNS;
		throw new cException("XPST0081", "Prefix '" + sPrefix + "' has not been declared");
	};

	cStaticContext.js2xs = function (vItem) {
		if (typeof vItem == "boolean") vItem = new cXSBoolean(vItem);else if (typeof vItem == "number") vItem = fIsNaN(vItem) || !fIsFinite(vItem) ? new cXSDouble(vItem) : fNumericLiteral_parseValue(cString(vItem));else vItem = new cXSString(cString(vItem));
		return vItem;
	};

	cStaticContext.xs2js = function (vItem) {
		if (vItem instanceof cXSBoolean) vItem = vItem.valueOf();else if (fXSAnyAtomicType_isNumeric(vItem)) vItem = vItem.valueOf();else vItem = vItem.toString();
		return vItem;
	};

	var hStaticContext_functions = {},
	    hStaticContext_signatures = {},
	    hStaticContext_dataTypes = {},
	    hStaticContext_operators = {};

	function fStaticContext_defineSystemFunction(sName, aParameters, fFunction) {
		hStaticContext_functions[sName] = fFunction;
		hStaticContext_signatures[sName] = aParameters;
	};

	function fStaticContext_defineSystemDataType(sName, fFunction) {
		hStaticContext_dataTypes[sName] = fFunction;
	};

	function cExpression(sExpression, oStaticContext) {
		var oLexer = new cLexer(sExpression),
		    oExpr = fExpr_parse(oLexer, oStaticContext);
		if (!oLexer.eof()) throw new cException("XPST0003", "Unexpected token beyond end of query");
		if (!oExpr) throw new cException("XPST0003", "Expected expression");
		this.internalExpression = oExpr;
	};

	cExpression.prototype.internalExpression = null;

	cExpression.prototype.evaluate = function (oContext) {
		return this.internalExpression.evaluate(oContext);
	};

	function cStringCollator() {};

	cStringCollator.prototype.equals = function (sValue1, sValue2) {
		throw "Not implemented";
	};

	cStringCollator.prototype.compare = function (sValue1, sValue2) {
		throw "Not implemented";
	};

	function cXSConstants() {};

	cXSConstants.ANYSIMPLETYPE_DT = 1;
	cXSConstants.STRING_DT = 2;
	cXSConstants.BOOLEAN_DT = 3;
	cXSConstants.DECIMAL_DT = 4;
	cXSConstants.FLOAT_DT = 5;
	cXSConstants.DOUBLE_DT = 6;
	cXSConstants.DURATION_DT = 7;
	cXSConstants.DATETIME_DT = 8;
	cXSConstants.TIME_DT = 9;
	cXSConstants.DATE_DT = 10;
	cXSConstants.GYEARMONTH_DT = 11;
	cXSConstants.GYEAR_DT = 12;
	cXSConstants.GMONTHDAY_DT = 13;
	cXSConstants.GDAY_DT = 14;
	cXSConstants.GMONTH_DT = 15;
	cXSConstants.HEXBINARY_DT = 16;
	cXSConstants.BASE64BINARY_DT = 17;
	cXSConstants.ANYURI_DT = 18;
	cXSConstants.QNAME_DT = 19;
	cXSConstants.NOTATION_DT = 20;
	cXSConstants.NORMALIZEDSTRING_DT = 21;
	cXSConstants.TOKEN_DT = 22;
	cXSConstants.LANGUAGE_DT = 23;
	cXSConstants.NMTOKEN_DT = 24;
	cXSConstants.NAME_DT = 25;
	cXSConstants.NCNAME_DT = 26;
	cXSConstants.ID_DT = 27;
	cXSConstants.IDREF_DT = 28;
	cXSConstants.ENTITY_DT = 29;
	cXSConstants.INTEGER_DT = 30;
	cXSConstants.NONPOSITIVEINTEGER_DT = 31;
	cXSConstants.NEGATIVEINTEGER_DT = 32;
	cXSConstants.LONG_DT = 33;
	cXSConstants.INT_DT = 34;
	cXSConstants.SHORT_DT = 35;
	cXSConstants.BYTE_DT = 36;
	cXSConstants.NONNEGATIVEINTEGER_DT = 37;
	cXSConstants.UNSIGNEDLONG_DT = 38;
	cXSConstants.UNSIGNEDINT_DT = 39;
	cXSConstants.UNSIGNEDSHORT_DT = 40;
	cXSConstants.UNSIGNEDBYTE_DT = 41;
	cXSConstants.POSITIVEINTEGER_DT = 42;
	cXSConstants.LISTOFUNION_DT = 43;
	cXSConstants.LIST_DT = 44;
	cXSConstants.UNAVAILABLE_DT = 45;

	cXSConstants.DATETIMESTAMP_DT = 46;
	cXSConstants.DAYMONTHDURATION_DT = 47;
	cXSConstants.DAYTIMEDURATION_DT = 48;
	cXSConstants.PRECISIONDECIMAL_DT = 49;
	cXSConstants.ANYATOMICTYPE_DT = 50;
	cXSConstants.ANYTYPE_DT = 51;

	cXSConstants.XT_YEARMONTHDURATION_DT = -1;
	cXSConstants.XT_UNTYPEDATOMIC_DT = -2;

	function cExpr() {
		this.items = [];
	};

	cExpr.prototype.items = null;

	function fExpr_parse(oLexer, oStaticContext) {
		var oItem;
		if (oLexer.eof() || !(oItem = fExprSingle_parse(oLexer, oStaticContext))) return;

		var oExpr = new cExpr();
		oExpr.items.push(oItem);
		while (oLexer.peek() == ',') {
			oLexer.next();
			if (oLexer.eof() || !(oItem = fExprSingle_parse(oLexer, oStaticContext))) throw new cException("XPST0003", "Expected expression");
			oExpr.items.push(oItem);
		}
		return oExpr;
	};

	cExpr.prototype.evaluate = function (oContext) {
		var oSequence = [];
		for (var nIndex = 0, nLength = this.items.length; nIndex < nLength; nIndex++) {
			oSequence = hStaticContext_operators["concatenate"].call(oContext, oSequence, this.items[nIndex].evaluate(oContext));
		}return oSequence;
	};

	function cExprSingle() {};

	function fExprSingle_parse(oLexer, oStaticContext) {
		if (!oLexer.eof()) return fIfExpr_parse(oLexer, oStaticContext) || fForExpr_parse(oLexer, oStaticContext) || fQuantifiedExpr_parse(oLexer, oStaticContext) || fOrExpr_parse(oLexer, oStaticContext);
	};

	function cForExpr() {
		this.bindings = [];
		this.returnExpr = null;
	};

	cForExpr.prototype.bindings = null;
	cForExpr.prototype.returnExpr = null;

	function fForExpr_parse(oLexer, oStaticContext) {
		if (oLexer.peek() == "for" && oLexer.peek(1).substr(0, 1) == '$') {
			oLexer.next();

			var oForExpr = new cForExpr(),
			    oExpr;
			do {
				oForExpr.bindings.push(fSimpleForBinding_parse(oLexer, oStaticContext));
			} while (oLexer.peek() == ',' && oLexer.next());

			if (oLexer.peek() != "return") throw new cException("XPST0003", "Expected 'return' token in for expression");

			oLexer.next();
			if (oLexer.eof() || !(oExpr = fExprSingle_parse(oLexer, oStaticContext))) throw new cException("XPST0003", "Expected return statement operand in for expression");

			oForExpr.returnExpr = oExpr;
			return oForExpr;
		}
	};

	cForExpr.prototype.evaluate = function (oContext) {
		var oSequence = [];
		(function (oSelf, nBinding) {
			var oBinding = oSelf.bindings[nBinding++],
			    oSequence1 = oBinding.inExpr.evaluate(oContext),
			    sUri = (oBinding.namespaceURI ? '{' + oBinding.namespaceURI + '}' : '') + oBinding.localName;
			for (var nIndex = 0, nLength = oSequence1.length; nIndex < nLength; nIndex++) {
				oContext.pushVariable(sUri, oSequence1[nIndex]);
				if (nBinding < oSelf.bindings.length) arguments.callee(oSelf, nBinding);else oSequence = oSequence.concat(oSelf.returnExpr.evaluate(oContext));
				oContext.popVariable(sUri);
			}
		})(this, 0);

		return oSequence;
	};

	function cSimpleForBinding(sPrefix, sLocalName, sNameSpaceURI, oInExpr) {
		this.prefix = sPrefix;
		this.localName = sLocalName;
		this.namespaceURI = sNameSpaceURI;
		this.inExpr = oInExpr;
	};

	cSimpleForBinding.prototype.prefix = null;
	cSimpleForBinding.prototype.localName = null;
	cSimpleForBinding.prototype.namespaceURI = null;
	cSimpleForBinding.prototype.inExpr = null;

	function fSimpleForBinding_parse(oLexer, oStaticContext) {
		var aMatch = oLexer.peek().substr(1).match(rNameTest);
		if (!aMatch) throw new cException("XPST0003", "Expected binding in for expression");

		if (aMatch[1] == '*' || aMatch[2] == '*') throw new cException("XPST0003", "Illegal use of wildcard in for expression binding variable name");

		oLexer.next();
		if (oLexer.peek() != "in") throw new cException("XPST0003", "Expected 'in' token in for expression binding");

		oLexer.next();
		var oExpr;
		if (oLexer.eof() || !(oExpr = fExprSingle_parse(oLexer, oStaticContext))) throw new cException("XPST0003", "Expected in statement operand in for expression binding");

		return new cSimpleForBinding(aMatch[1] || null, aMatch[2], aMatch[1] ? oStaticContext.getURIForPrefix(aMatch[1]) : null, oExpr);
	};

	function cIfExpr(oCondExpr, oThenExpr, oElseExpr) {
		this.condExpr = oCondExpr;
		this.thenExpr = oThenExpr;
		this.elseExpr = oElseExpr;
	};

	cIfExpr.prototype.condExpr = null;
	cIfExpr.prototype.thenExpr = null;
	cIfExpr.prototype.elseExpr = null;

	function fIfExpr_parse(oLexer, oStaticContext) {
		var oCondExpr, oThenExpr, oElseExpr;
		if (oLexer.peek() == "if" && oLexer.peek(1) == '(') {
			oLexer.next(2);
			if (oLexer.eof() || !(oCondExpr = fExpr_parse(oLexer, oStaticContext))) throw new cException("XPST0003", "Expected if statement operand in conditional expression");
			if (oLexer.peek() != ')') throw new cException("XPST0003", "Expected ')' token in for expression");

			oLexer.next();
			if (oLexer.peek() != "then") throw new cException("XPST0003", "Expected 'then' token in conditional if expression");

			oLexer.next();
			if (oLexer.eof() || !(oThenExpr = fExprSingle_parse(oLexer, oStaticContext))) throw new cException("XPST0003", "Expected then statement operand in condional expression");

			if (oLexer.peek() != "else") throw new cException("XPST0003", "Expected 'else' token in conditional if expression");

			oLexer.next();
			if (oLexer.eof() || !(oElseExpr = fExprSingle_parse(oLexer, oStaticContext))) throw new cException("XPST0003", "Expected else statement operand in condional expression");
			return new cIfExpr(oCondExpr, oThenExpr, oElseExpr);
		}
	};

	cIfExpr.prototype.evaluate = function (oContext) {
		return this[fFunction_sequence_toEBV(this.condExpr.evaluate(oContext), oContext) ? "thenExpr" : "elseExpr"].evaluate(oContext);
	};

	function cQuantifiedExpr(sQuantifier) {
		this.quantifier = sQuantifier;
		this.bindings = [];
		this.satisfiesExpr = null;
	};

	cQuantifiedExpr.prototype.bindings = null;
	cQuantifiedExpr.prototype.quantifier = null;
	cQuantifiedExpr.prototype.satisfiesExpr = null;

	function fQuantifiedExpr_parse(oLexer, oStaticContext) {
		var sQuantifier = oLexer.peek();
		if ((sQuantifier == "some" || sQuantifier == "every") && oLexer.peek(1).substr(0, 1) == '$') {
			oLexer.next();

			var oQuantifiedExpr = new cQuantifiedExpr(sQuantifier),
			    oExpr;
			do {
				oQuantifiedExpr.bindings.push(fSimpleQuantifiedBinding_parse(oLexer, oStaticContext));
			} while (oLexer.peek() == ',' && oLexer.next());

			if (oLexer.peek() != "satisfies") throw new cException("XPST0003", "Expected 'satisfies' token in quantified expression");

			oLexer.next();
			if (oLexer.eof() || !(oExpr = fExprSingle_parse(oLexer, oStaticContext))) throw new cException("XPST0003", "Expected satisfies statement operand in quantified expression");

			oQuantifiedExpr.satisfiesExpr = oExpr;
			return oQuantifiedExpr;
		}
	};

	cQuantifiedExpr.prototype.evaluate = function (oContext) {
		var bEvery = this.quantifier == "every",
		    bResult = bEvery ? true : false;
		(function (oSelf, nBinding) {
			var oBinding = oSelf.bindings[nBinding++],
			    oSequence1 = oBinding.inExpr.evaluate(oContext),
			    sUri = (oBinding.namespaceURI ? '{' + oBinding.namespaceURI + '}' : '') + oBinding.localName;
			for (var nIndex = 0, nLength = oSequence1.length; nIndex < nLength && (bEvery ? bResult : !bResult); nIndex++) {
				oContext.pushVariable(sUri, oSequence1[nIndex]);
				if (nBinding < oSelf.bindings.length) arguments.callee(oSelf, nBinding);else bResult = fFunction_sequence_toEBV(oSelf.satisfiesExpr.evaluate(oContext), oContext);
				oContext.popVariable(sUri);
			}
		})(this, 0);

		return [new cXSBoolean(bResult)];
	};

	function cSimpleQuantifiedBinding(sPrefix, sLocalName, sNameSpaceURI, oInExpr) {
		this.prefix = sPrefix;
		this.localName = sLocalName;
		this.namespaceURI = sNameSpaceURI;
		this.inExpr = oInExpr;
	};

	cSimpleQuantifiedBinding.prototype.prefix = null;
	cSimpleQuantifiedBinding.prototype.localName = null;
	cSimpleQuantifiedBinding.prototype.namespaceURI = null;
	cSimpleQuantifiedBinding.prototype.inExpr = null;

	function fSimpleQuantifiedBinding_parse(oLexer, oStaticContext) {
		var aMatch = oLexer.peek().substr(1).match(rNameTest);
		if (!aMatch) throw new cException("XPST0003", "Expected binding in quantified expression");

		if (aMatch[1] == '*' || aMatch[2] == '*') throw new cException("XPST0003", "Illegal use of wildcard in quantified expression binding variable name");

		oLexer.next();
		if (oLexer.peek() != "in") throw new cException("XPST0003", "Expected 'in' token in quantified expression binding");

		oLexer.next();
		var oExpr;
		if (oLexer.eof() || !(oExpr = fExprSingle_parse(oLexer, oStaticContext))) throw new cException("XPST0003", "Expected in statement operand in quantified expression binding");

		return new cSimpleQuantifiedBinding(aMatch[1] || null, aMatch[2], aMatch[1] ? oStaticContext.getURIForPrefix(aMatch[1]) : null, oExpr);
	};

	function cComparisonExpr(oLeft, oRight, sOperator) {
		this.left = oLeft;
		this.right = oRight;
		this.operator = sOperator;
	};

	cComparisonExpr.prototype.left = null;
	cComparisonExpr.prototype.right = null;
	cComparisonExpr.prototype.operator = null;

	function fComparisonExpr_parse(oLexer, oStaticContext) {
		var oExpr, oRight;
		if (oLexer.eof() || !(oExpr = fRangeExpr_parse(oLexer, oStaticContext))) return;
		if (!(oLexer.peek() in hComparisonExpr_operators)) return oExpr;

		var sOperator = oLexer.peek();
		oLexer.next();
		if (oLexer.eof() || !(oRight = fRangeExpr_parse(oLexer, oStaticContext))) throw new cException("XPST0003", "Expected second operand in comparison expression");
		return new cComparisonExpr(oExpr, oRight, sOperator);
	};

	cComparisonExpr.prototype.evaluate = function (oContext) {
		var oResult = hComparisonExpr_operators[this.operator](this, oContext);
		return oResult == null ? [] : [oResult];
	};

	function fComparisonExpr_GeneralComp(oExpr, oContext) {
		var oLeft = fFunction_sequence_atomize(oExpr.left.evaluate(oContext), oContext);
		if (!oLeft.length) return new cXSBoolean(false);

		var oRight = fFunction_sequence_atomize(oExpr.right.evaluate(oContext), oContext);
		if (!oRight.length) return new cXSBoolean(false);

		var bResult = false;
		for (var nLeftIndex = 0, nLeftLength = oLeft.length, bLeft, vLeft; nLeftIndex < nLeftLength && !bResult; nLeftIndex++) {
			for (var nRightIndex = 0, nRightLength = oRight.length, bRight, vRight; nRightIndex < nRightLength && !bResult; nRightIndex++) {

				vLeft = oLeft[nLeftIndex];
				vRight = oRight[nRightIndex];

				bLeft = vLeft instanceof cXSUntypedAtomic;
				bRight = vRight instanceof cXSUntypedAtomic;

				if (bLeft && bRight) {
					vLeft = cXSString.cast(vLeft);
					vRight = cXSString.cast(vRight);
				} else {
					if (bLeft) {
						if (vRight instanceof cXSDayTimeDuration) vLeft = cXSDayTimeDuration.cast(vLeft);else if (vRight instanceof cXSYearMonthDuration) vLeft = cXSYearMonthDuration.cast(vLeft);else if (vRight.primitiveKind) vLeft = hStaticContext_dataTypes[vRight.primitiveKind].cast(vLeft);
					} else if (bRight) {
						if (vLeft instanceof cXSDayTimeDuration) vRight = cXSDayTimeDuration.cast(vRight);else if (vLeft instanceof cXSYearMonthDuration) vRight = cXSYearMonthDuration.cast(vRight);else if (vLeft.primitiveKind) vRight = hStaticContext_dataTypes[vLeft.primitiveKind].cast(vRight);
					}

					if (vLeft instanceof cXSAnyURI) vLeft = cXSString.cast(vLeft);
					if (vRight instanceof cXSAnyURI) vRight = cXSString.cast(vRight);
				}

				bResult = hComparisonExpr_ValueComp_operators[hComparisonExpr_GeneralComp_map[oExpr.operator]](vLeft, vRight, oContext).valueOf();
			}
		}
		return new cXSBoolean(bResult);
	};

	var hComparisonExpr_GeneralComp_map = {
		'=': 'eq',
		'!=': 'ne',
		'>': 'gt',
		'<': 'lt',
		'>=': 'ge',
		'<=': 'le'
	};

	function fComparisonExpr_ValueComp(oExpr, oContext) {
		var oLeft = fFunction_sequence_atomize(oExpr.left.evaluate(oContext), oContext);
		if (!oLeft.length) return null;
		fFunctionCall_assertSequenceCardinality(oContext, oLeft, '?', "first operand of '" + oExpr.operator + "'");

		var oRight = fFunction_sequence_atomize(oExpr.right.evaluate(oContext), oContext);
		if (!oRight.length) return null;
		fFunctionCall_assertSequenceCardinality(oContext, oRight, '?', "second operand of '" + oExpr.operator + "'");

		var vLeft = oLeft[0],
		    vRight = oRight[0];

		if (vLeft instanceof cXSUntypedAtomic) vLeft = cXSString.cast(vLeft);
		if (vRight instanceof cXSUntypedAtomic) vRight = cXSString.cast(vRight);

		if (vLeft instanceof cXSAnyURI) vLeft = cXSString.cast(vLeft);
		if (vRight instanceof cXSAnyURI) vRight = cXSString.cast(vRight);

		return hComparisonExpr_ValueComp_operators[oExpr.operator](vLeft, vRight, oContext);
	};

	var hComparisonExpr_ValueComp_operators = {};
	hComparisonExpr_ValueComp_operators['eq'] = function (oLeft, oRight, oContext) {
		var sOperator = '';

		if (fXSAnyAtomicType_isNumeric(oLeft)) {
			if (fXSAnyAtomicType_isNumeric(oRight)) sOperator = "numeric-equal";
		} else if (oLeft instanceof cXSBoolean) {
			if (oRight instanceof cXSBoolean) sOperator = "boolean-equal";
		} else if (oLeft instanceof cXSString) {
			if (oRight instanceof cXSString) return hStaticContext_operators["numeric-equal"].call(oContext, hStaticContext_functions["compare"].call(oContext, oLeft, oRight), new cXSInteger(0));
		} else if (oLeft instanceof cXSDate) {
			if (oRight instanceof cXSDate) sOperator = "date-equal";
		} else if (oLeft instanceof cXSTime) {
			if (oRight instanceof cXSTime) sOperator = "time-equal";
		} else if (oLeft instanceof cXSDateTime) {
			if (oRight instanceof cXSDateTime) sOperator = "dateTime-equal";
		} else if (oLeft instanceof cXSDuration) {
			if (oRight instanceof cXSDuration) sOperator = "duration-equal";
		} else if (oLeft instanceof cXSGYearMonth) {
			if (oRight instanceof cXSGYearMonth) sOperator = "gYearMonth-equal";
		} else if (oLeft instanceof cXSGYear) {
			if (oRight instanceof cXSGYear) sOperator = "gYear-equal";
		} else if (oLeft instanceof cXSGMonthDay) {
			if (oRight instanceof cXSGMonthDay) sOperator = "gMonthDay-equal";
		} else if (oLeft instanceof cXSGMonth) {
			if (oRight instanceof cXSGMonth) sOperator = "gMonth-equal";
		} else if (oLeft instanceof cXSGDay) {
			if (oRight instanceof cXSGDay) sOperator = "gDay-equal";
		} else if (oLeft instanceof cXSQName) {
			if (oRight instanceof cXSQName) sOperator = "QName-equal";
		} else if (oLeft instanceof cXSHexBinary) {
			if (oRight instanceof cXSHexBinary) sOperator = "hexBinary-equal";
		} else if (oLeft instanceof cXSBase64Binary) {
			if (oRight instanceof cXSBase64Binary) sOperator = "base64Binary-equal";
		}

		if (sOperator) return hStaticContext_operators[sOperator].call(oContext, oLeft, oRight);

		throw new cException("XPTY0004", "Cannot compare values of given types");
	};
	hComparisonExpr_ValueComp_operators['ne'] = function (oLeft, oRight, oContext) {
		return new cXSBoolean(!hComparisonExpr_ValueComp_operators['eq'](oLeft, oRight, oContext).valueOf());
	};
	hComparisonExpr_ValueComp_operators['gt'] = function (oLeft, oRight, oContext) {
		var sOperator = '';

		if (fXSAnyAtomicType_isNumeric(oLeft)) {
			if (fXSAnyAtomicType_isNumeric(oRight)) sOperator = "numeric-greater-than";
		} else if (oLeft instanceof cXSBoolean) {
			if (oRight instanceof cXSBoolean) sOperator = "boolean-greater-than";
		} else if (oLeft instanceof cXSString) {
			if (oRight instanceof cXSString) return hStaticContext_operators["numeric-greater-than"].call(oContext, hStaticContext_functions["compare"].call(oContext, oLeft, oRight), new cXSInteger(0));
		} else if (oLeft instanceof cXSDate) {
			if (oRight instanceof cXSDate) sOperator = "date-greater-than";
		} else if (oLeft instanceof cXSTime) {
			if (oRight instanceof cXSTime) sOperator = "time-greater-than";
		} else if (oLeft instanceof cXSDateTime) {
			if (oRight instanceof cXSDateTime) sOperator = "dateTime-greater-than";
		} else if (oLeft instanceof cXSYearMonthDuration) {
			if (oRight instanceof cXSYearMonthDuration) sOperator = "yearMonthDuration-greater-than";
		} else if (oLeft instanceof cXSDayTimeDuration) {
			if (oRight instanceof cXSDayTimeDuration) sOperator = "dayTimeDuration-greater-than";
		}

		if (sOperator) return hStaticContext_operators[sOperator].call(oContext, oLeft, oRight);

		throw new cException("XPTY0004", "Cannot compare values of given types");
	};
	hComparisonExpr_ValueComp_operators['lt'] = function (oLeft, oRight, oContext) {
		var sOperator = '';

		if (fXSAnyAtomicType_isNumeric(oLeft)) {
			if (fXSAnyAtomicType_isNumeric(oRight)) sOperator = "numeric-less-than";
		} else if (oLeft instanceof cXSBoolean) {
			if (oRight instanceof cXSBoolean) sOperator = "boolean-less-than";
		} else if (oLeft instanceof cXSString) {
			if (oRight instanceof cXSString) return hStaticContext_operators["numeric-less-than"].call(oContext, hStaticContext_functions["compare"].call(oContext, oLeft, oRight), new cXSInteger(0));
		} else if (oLeft instanceof cXSDate) {
			if (oRight instanceof cXSDate) sOperator = "date-less-than";
		} else if (oLeft instanceof cXSTime) {
			if (oRight instanceof cXSTime) sOperator = "time-less-than";
		} else if (oLeft instanceof cXSDateTime) {
			if (oRight instanceof cXSDateTime) sOperator = "dateTime-less-than";
		} else if (oLeft instanceof cXSYearMonthDuration) {
			if (oRight instanceof cXSYearMonthDuration) sOperator = "yearMonthDuration-less-than";
		} else if (oLeft instanceof cXSDayTimeDuration) {
			if (oRight instanceof cXSDayTimeDuration) sOperator = "dayTimeDuration-less-than";
		}

		if (sOperator) return hStaticContext_operators[sOperator].call(oContext, oLeft, oRight);

		throw new cException("XPTY0004", "Cannot compare values of given types");
	};
	hComparisonExpr_ValueComp_operators['ge'] = function (oLeft, oRight, oContext) {
		var sOperator = '';

		if (fXSAnyAtomicType_isNumeric(oLeft)) {
			if (fXSAnyAtomicType_isNumeric(oRight)) sOperator = "numeric-less-than";
		} else if (oLeft instanceof cXSBoolean) {
			if (oRight instanceof cXSBoolean) sOperator = "boolean-less-than";
		} else if (oLeft instanceof cXSString) {
			if (oRight instanceof cXSString) return hStaticContext_operators["numeric-greater-than"].call(oContext, hStaticContext_functions["compare"].call(oContext, oLeft, oRight), new cXSInteger(-1));
		} else if (oLeft instanceof cXSDate) {
			if (oRight instanceof cXSDate) sOperator = "date-less-than";
		} else if (oLeft instanceof cXSTime) {
			if (oRight instanceof cXSTime) sOperator = "time-less-than";
		} else if (oLeft instanceof cXSDateTime) {
			if (oRight instanceof cXSDateTime) sOperator = "dateTime-less-than";
		} else if (oLeft instanceof cXSYearMonthDuration) {
			if (oRight instanceof cXSYearMonthDuration) sOperator = "yearMonthDuration-less-than";
		} else if (oLeft instanceof cXSDayTimeDuration) {
			if (oRight instanceof cXSDayTimeDuration) sOperator = "dayTimeDuration-less-than";
		}

		if (sOperator) return new cXSBoolean(!hStaticContext_operators[sOperator].call(oContext, oLeft, oRight).valueOf());

		throw new cException("XPTY0004", "Cannot compare values of given types");
	};
	hComparisonExpr_ValueComp_operators['le'] = function (oLeft, oRight, oContext) {
		var sOperator = '';

		if (fXSAnyAtomicType_isNumeric(oLeft)) {
			if (fXSAnyAtomicType_isNumeric(oRight)) sOperator = "numeric-greater-than";
		} else if (oLeft instanceof cXSBoolean) {
			if (oRight instanceof cXSBoolean) sOperator = "boolean-greater-than";
		} else if (oLeft instanceof cXSString) {
			if (oRight instanceof cXSString) return hStaticContext_operators["numeric-less-than"].call(oContext, hStaticContext_functions["compare"].call(oContext, oLeft, oRight), new cXSInteger(1));
		} else if (oLeft instanceof cXSDate) {
			if (oRight instanceof cXSDate) sOperator = "date-greater-than";
		} else if (oLeft instanceof cXSTime) {
			if (oRight instanceof cXSTime) sOperator = "time-greater-than";
		} else if (oLeft instanceof cXSDateTime) {
			if (oRight instanceof cXSDateTime) sOperator = "dateTime-greater-than";
		} else if (oLeft instanceof cXSYearMonthDuration) {
			if (oRight instanceof cXSYearMonthDuration) sOperator = "yearMonthDuration-greater-than";
		} else if (oLeft instanceof cXSDayTimeDuration) {
			if (oRight instanceof cXSDayTimeDuration) sOperator = "dayTimeDuration-greater-than";
		}

		if (sOperator) return new cXSBoolean(!hStaticContext_operators[sOperator].call(oContext, oLeft, oRight).valueOf());

		throw new cException("XPTY0004", "Cannot compare values of given types");
	};

	function fComparisonExpr_NodeComp(oExpr, oContext) {
		var oLeft = oExpr.left.evaluate(oContext);
		if (!oLeft.length) return null;
		fFunctionCall_assertSequenceCardinality(oContext, oLeft, '?', "first operand of '" + oExpr.operator + "'");
		fFunctionCall_assertSequenceItemType(oContext, oLeft, cXTNode, "first operand of '" + oExpr.operator + "'");

		var oRight = oExpr.right.evaluate(oContext);
		if (!oRight.length) return null;
		fFunctionCall_assertSequenceCardinality(oContext, oRight, '?', "second operand of '" + oExpr.operator + "'");
		fFunctionCall_assertSequenceItemType(oContext, oRight, cXTNode, "second operand of '" + oExpr.operator + "'");

		return hComparisonExpr_NodeComp_operators[oExpr.operator](oLeft[0], oRight[0], oContext);
	};

	var hComparisonExpr_NodeComp_operators = {};
	hComparisonExpr_NodeComp_operators['is'] = function (oLeft, oRight, oContext) {
		return hStaticContext_operators["is-same-node"].call(oContext, oLeft, oRight);
	};
	hComparisonExpr_NodeComp_operators['>>'] = function (oLeft, oRight, oContext) {
		return hStaticContext_operators["node-after"].call(oContext, oLeft, oRight);
	};
	hComparisonExpr_NodeComp_operators['<<'] = function (oLeft, oRight, oContext) {
		return hStaticContext_operators["node-before"].call(oContext, oLeft, oRight);
	};

	var hComparisonExpr_operators = {
		'=': fComparisonExpr_GeneralComp,
		'!=': fComparisonExpr_GeneralComp,
		'<': fComparisonExpr_GeneralComp,
		'<=': fComparisonExpr_GeneralComp,
		'>': fComparisonExpr_GeneralComp,
		'>=': fComparisonExpr_GeneralComp,
		'eq': fComparisonExpr_ValueComp,
		'ne': fComparisonExpr_ValueComp,
		'lt': fComparisonExpr_ValueComp,
		'le': fComparisonExpr_ValueComp,
		'gt': fComparisonExpr_ValueComp,
		'ge': fComparisonExpr_ValueComp,
		'is': fComparisonExpr_NodeComp,
		'>>': fComparisonExpr_NodeComp,
		'<<': fComparisonExpr_NodeComp
	};

	function cAdditiveExpr(oExpr) {
		this.left = oExpr;
		this.items = [];
	};

	cAdditiveExpr.prototype.left = null;
	cAdditiveExpr.prototype.items = null;

	var hAdditiveExpr_operators = {};
	hAdditiveExpr_operators['+'] = function (oLeft, oRight, oContext) {
		var sOperator = '',
		    bReverse = false;

		if (fXSAnyAtomicType_isNumeric(oLeft)) {
			if (fXSAnyAtomicType_isNumeric(oRight)) sOperator = "numeric-add";
		} else if (oLeft instanceof cXSDate) {
			if (oRight instanceof cXSYearMonthDuration) sOperator = "add-yearMonthDuration-to-date";else if (oRight instanceof cXSDayTimeDuration) sOperator = "add-dayTimeDuration-to-date";
		} else if (oLeft instanceof cXSYearMonthDuration) {
			if (oRight instanceof cXSDate) {
				sOperator = "add-yearMonthDuration-to-date";
				bReverse = true;
			} else if (oRight instanceof cXSDateTime) {
				sOperator = "add-yearMonthDuration-to-dateTime";
				bReverse = true;
			} else if (oRight instanceof cXSYearMonthDuration) sOperator = "add-yearMonthDurations";
		} else if (oLeft instanceof cXSDayTimeDuration) {
			if (oRight instanceof cXSDate) {
				sOperator = "add-dayTimeDuration-to-date";
				bReverse = true;
			} else if (oRight instanceof cXSTime) {
				sOperator = "add-dayTimeDuration-to-time";
				bReverse = true;
			} else if (oRight instanceof cXSDateTime) {
				sOperator = "add-dayTimeDuration-to-dateTime";
				bReverse = true;
			} else if (oRight instanceof cXSDayTimeDuration) sOperator = "add-dayTimeDurations";
		} else if (oLeft instanceof cXSTime) {
			if (oRight instanceof cXSDayTimeDuration) sOperator = "add-dayTimeDuration-to-time";
		} else if (oLeft instanceof cXSDateTime) {
			if (oRight instanceof cXSYearMonthDuration) sOperator = "add-yearMonthDuration-to-dateTime";else if (oRight instanceof cXSDayTimeDuration) sOperator = "add-dayTimeDuration-to-dateTime";
		}

		if (sOperator) return hStaticContext_operators[sOperator].call(oContext, bReverse ? oRight : oLeft, bReverse ? oLeft : oRight);

		throw new cException("XPTY0004", "Arithmetic operator is not defined for provided arguments");
	};
	hAdditiveExpr_operators['-'] = function (oLeft, oRight, oContext) {
		var sOperator = '';

		if (fXSAnyAtomicType_isNumeric(oLeft)) {
			if (fXSAnyAtomicType_isNumeric(oRight)) sOperator = "numeric-subtract";
		} else if (oLeft instanceof cXSDate) {
			if (oRight instanceof cXSDate) sOperator = "subtract-dates";else if (oRight instanceof cXSYearMonthDuration) sOperator = "subtract-yearMonthDuration-from-date";else if (oRight instanceof cXSDayTimeDuration) sOperator = "subtract-dayTimeDuration-from-date";
		} else if (oLeft instanceof cXSTime) {
			if (oRight instanceof cXSTime) sOperator = "subtract-times";else if (oRight instanceof cXSDayTimeDuration) sOperator = "subtract-dayTimeDuration-from-time";
		} else if (oLeft instanceof cXSDateTime) {
			if (oRight instanceof cXSDateTime) sOperator = "subtract-dateTimes";else if (oRight instanceof cXSYearMonthDuration) sOperator = "subtract-yearMonthDuration-from-dateTime";else if (oRight instanceof cXSDayTimeDuration) sOperator = "subtract-dayTimeDuration-from-dateTime";
		} else if (oLeft instanceof cXSYearMonthDuration) {
			if (oRight instanceof cXSYearMonthDuration) sOperator = "subtract-yearMonthDurations";
		} else if (oLeft instanceof cXSDayTimeDuration) {
			if (oRight instanceof cXSDayTimeDuration) sOperator = "subtract-dayTimeDurations";
		}

		if (sOperator) return hStaticContext_operators[sOperator].call(oContext, oLeft, oRight);

		throw new cException("XPTY0004", "Arithmetic operator is not defined for provided arguments");
	};

	function fAdditiveExpr_parse(oLexer, oStaticContext) {
		var oExpr;
		if (oLexer.eof() || !(oExpr = fMultiplicativeExpr_parse(oLexer, oStaticContext))) return;
		if (!(oLexer.peek() in hAdditiveExpr_operators)) return oExpr;

		var oAdditiveExpr = new cAdditiveExpr(oExpr),
		    sOperator;
		while ((sOperator = oLexer.peek()) in hAdditiveExpr_operators) {
			oLexer.next();
			if (oLexer.eof() || !(oExpr = fMultiplicativeExpr_parse(oLexer, oStaticContext))) throw new cException("XPST0003", "Expected second operand in additive expression");
			oAdditiveExpr.items.push([sOperator, oExpr]);
		}
		return oAdditiveExpr;
	};

	cAdditiveExpr.prototype.evaluate = function (oContext) {
		var oLeft = fFunction_sequence_atomize(this.left.evaluate(oContext), oContext);

		if (!oLeft.length) return [];
		fFunctionCall_assertSequenceCardinality(oContext, oLeft, '?', "first operand of '" + this.items[0][0] + "'");

		var vLeft = oLeft[0];
		if (vLeft instanceof cXSUntypedAtomic) vLeft = cXSDouble.cast(vLeft);
		for (var nIndex = 0, nLength = this.items.length, oRight, vRight; nIndex < nLength; nIndex++) {
			oRight = fFunction_sequence_atomize(this.items[nIndex][1].evaluate(oContext), oContext);

			if (!oRight.length) return [];
			fFunctionCall_assertSequenceCardinality(oContext, oRight, '?', "first operand of '" + this.items[nIndex][0] + "'");

			vRight = oRight[0];
			if (vRight instanceof cXSUntypedAtomic) vRight = cXSDouble.cast(vRight);
			vLeft = hAdditiveExpr_operators[this.items[nIndex][0]](vLeft, vRight, oContext);
		}
		return [vLeft];
	};

	function cMultiplicativeExpr(oExpr) {
		this.left = oExpr;
		this.items = [];
	};

	cMultiplicativeExpr.prototype.left = null;
	cMultiplicativeExpr.prototype.items = null;

	var hMultiplicativeExpr_operators = {};
	hMultiplicativeExpr_operators['*'] = function (oLeft, oRight, oContext) {
		var sOperator = '',
		    bReverse = false;

		if (fXSAnyAtomicType_isNumeric(oLeft)) {
			if (fXSAnyAtomicType_isNumeric(oRight)) sOperator = "numeric-multiply";else if (oRight instanceof cXSYearMonthDuration) {
				sOperator = "multiply-yearMonthDuration";
				bReverse = true;
			} else if (oRight instanceof cXSDayTimeDuration) {
				sOperator = "multiply-dayTimeDuration";
				bReverse = true;
			}
		} else {
			if (oLeft instanceof cXSYearMonthDuration) {
				if (fXSAnyAtomicType_isNumeric(oRight)) sOperator = "multiply-yearMonthDuration";
			} else if (oLeft instanceof cXSDayTimeDuration) {
				if (fXSAnyAtomicType_isNumeric(oRight)) sOperator = "multiply-dayTimeDuration";
			}
		}

		if (sOperator) return hStaticContext_operators[sOperator].call(oContext, bReverse ? oRight : oLeft, bReverse ? oLeft : oRight);

		throw new cException("XPTY0004", "Arithmetic operator is not defined for provided arguments");
	};
	hMultiplicativeExpr_operators['div'] = function (oLeft, oRight, oContext) {
		var sOperator = '';

		if (fXSAnyAtomicType_isNumeric(oLeft)) {
			if (fXSAnyAtomicType_isNumeric(oRight)) sOperator = "numeric-divide";
		} else if (oLeft instanceof cXSYearMonthDuration) {
			if (fXSAnyAtomicType_isNumeric(oRight)) sOperator = "divide-yearMonthDuration";else if (oRight instanceof cXSYearMonthDuration) sOperator = "divide-yearMonthDuration-by-yearMonthDuration";
		} else if (oLeft instanceof cXSDayTimeDuration) {
			if (fXSAnyAtomicType_isNumeric(oRight)) sOperator = "divide-dayTimeDuration";else if (oRight instanceof cXSDayTimeDuration) sOperator = "divide-dayTimeDuration-by-dayTimeDuration";
		}
		if (sOperator) return hStaticContext_operators[sOperator].call(oContext, oLeft, oRight);

		throw new cException("XPTY0004", "Arithmetic operator is not defined for provided arguments");
	};
	hMultiplicativeExpr_operators['idiv'] = function (oLeft, oRight, oContext) {
		if (fXSAnyAtomicType_isNumeric(oLeft) && fXSAnyAtomicType_isNumeric(oRight)) return hStaticContext_operators["numeric-integer-divide"].call(oContext, oLeft, oRight);
		throw new cException("XPTY0004", "Arithmetic operator is not defined for provided arguments");
	};
	hMultiplicativeExpr_operators['mod'] = function (oLeft, oRight, oContext) {
		if (fXSAnyAtomicType_isNumeric(oLeft) && fXSAnyAtomicType_isNumeric(oRight)) return hStaticContext_operators["numeric-mod"].call(oContext, oLeft, oRight);
		throw new cException("XPTY0004", "Arithmetic operator is not defined for provided arguments");
	};

	function fMultiplicativeExpr_parse(oLexer, oStaticContext) {
		var oExpr;
		if (oLexer.eof() || !(oExpr = fUnionExpr_parse(oLexer, oStaticContext))) return;
		if (!(oLexer.peek() in hMultiplicativeExpr_operators)) return oExpr;

		var oMultiplicativeExpr = new cMultiplicativeExpr(oExpr),
		    sOperator;
		while ((sOperator = oLexer.peek()) in hMultiplicativeExpr_operators) {
			oLexer.next();
			if (oLexer.eof() || !(oExpr = fUnionExpr_parse(oLexer, oStaticContext))) throw new cException("XPST0003", "Expected second operand in multiplicative expression");
			oMultiplicativeExpr.items.push([sOperator, oExpr]);
		}
		return oMultiplicativeExpr;
	};

	cMultiplicativeExpr.prototype.evaluate = function (oContext) {
		var oLeft = fFunction_sequence_atomize(this.left.evaluate(oContext), oContext);

		if (!oLeft.length) return [];
		fFunctionCall_assertSequenceCardinality(oContext, oLeft, '?', "first operand of '" + this.items[0][0] + "'");

		var vLeft = oLeft[0];
		if (vLeft instanceof cXSUntypedAtomic) vLeft = cXSDouble.cast(vLeft);
		for (var nIndex = 0, nLength = this.items.length, oRight, vRight; nIndex < nLength; nIndex++) {
			oRight = fFunction_sequence_atomize(this.items[nIndex][1].evaluate(oContext), oContext);

			if (!oRight.length) return [];
			fFunctionCall_assertSequenceCardinality(oContext, oRight, '?', "second operand of '" + this.items[nIndex][0] + "'");

			vRight = oRight[0];
			if (vRight instanceof cXSUntypedAtomic) vRight = cXSDouble.cast(vRight);
			vLeft = hMultiplicativeExpr_operators[this.items[nIndex][0]](vLeft, vRight, oContext);
		}
		return [vLeft];
	};

	function cUnaryExpr(sOperator, oExpr) {
		this.operator = sOperator;
		this.expression = oExpr;
	};

	cUnaryExpr.prototype.operator = null;
	cUnaryExpr.prototype.expression = null;

	var hUnaryExpr_operators = {};
	hUnaryExpr_operators['-'] = function (oRight, oContext) {
		if (fXSAnyAtomicType_isNumeric(oRight)) return hStaticContext_operators["numeric-unary-minus"].call(oContext, oRight);
		throw new cException("XPTY0004", "Arithmetic operator is not defined for provided arguments");
	};
	hUnaryExpr_operators['+'] = function (oRight, oContext) {
		if (fXSAnyAtomicType_isNumeric(oRight)) return hStaticContext_operators["numeric-unary-plus"].call(oContext, oRight);
		throw new cException("XPTY0004", "Arithmetic operator is not defined for provided arguments");
	};

	function fUnaryExpr_parse(oLexer, oStaticContext) {
		if (oLexer.eof()) return;
		if (!(oLexer.peek() in hUnaryExpr_operators)) return fValueExpr_parse(oLexer, oStaticContext);

		var sOperator = '+',
		    oExpr;
		while (oLexer.peek() in hUnaryExpr_operators) {
			if (oLexer.peek() == '-') sOperator = sOperator == '-' ? '+' : '-';
			oLexer.next();
		}
		if (oLexer.eof() || !(oExpr = fValueExpr_parse(oLexer, oStaticContext))) throw new cException("XPST0003", "Expected operand in unary expression");
		return new cUnaryExpr(sOperator, oExpr);
	};

	cUnaryExpr.prototype.evaluate = function (oContext) {
		var oRight = fFunction_sequence_atomize(this.expression.evaluate(oContext), oContext);

		if (!oRight.length) return [];
		fFunctionCall_assertSequenceCardinality(oContext, oRight, '?', "second operand of '" + this.operator + "'");

		var vRight = oRight[0];
		if (vRight instanceof cXSUntypedAtomic) vRight = cXSDouble.cast(vRight);
		return [hUnaryExpr_operators[this.operator](vRight, oContext)];
	};

	function cValueExpr() {};

	function fValueExpr_parse(oLexer, oStaticContext) {
		return fPathExpr_parse(oLexer, oStaticContext);
	};

	function cOrExpr(oExpr) {
		this.left = oExpr;
		this.items = [];
	};

	cOrExpr.prototype.left = null;
	cOrExpr.prototype.items = null;

	function fOrExpr_parse(oLexer, oStaticContext) {
		var oExpr;
		if (oLexer.eof() || !(oExpr = fAndExpr_parse(oLexer, oStaticContext))) return;
		if (oLexer.peek() != "or") return oExpr;

		var oOrExpr = new cOrExpr(oExpr);
		while (oLexer.peek() == "or") {
			oLexer.next();
			if (oLexer.eof() || !(oExpr = fAndExpr_parse(oLexer, oStaticContext))) throw new cException("XPST0003", "Expected second operand in logical expression");
			oOrExpr.items.push(oExpr);
		}
		return oOrExpr;
	};

	cOrExpr.prototype.evaluate = function (oContext) {
		var bValue = fFunction_sequence_toEBV(this.left.evaluate(oContext), oContext);
		for (var nIndex = 0, nLength = this.items.length; nIndex < nLength && !bValue; nIndex++) {
			bValue = fFunction_sequence_toEBV(this.items[nIndex].evaluate(oContext), oContext);
		}return [new cXSBoolean(bValue)];
	};

	function cAndExpr(oExpr) {
		this.left = oExpr;
		this.items = [];
	};

	cAndExpr.prototype.left = null;
	cAndExpr.prototype.items = null;

	function fAndExpr_parse(oLexer, oStaticContext) {
		var oExpr;
		if (oLexer.eof() || !(oExpr = fComparisonExpr_parse(oLexer, oStaticContext))) return;
		if (oLexer.peek() != "and") return oExpr;

		var oAndExpr = new cAndExpr(oExpr);
		while (oLexer.peek() == "and") {
			oLexer.next();
			if (oLexer.eof() || !(oExpr = fComparisonExpr_parse(oLexer, oStaticContext))) throw new cException("XPST0003", "Expected second operand in logical expression");
			oAndExpr.items.push(oExpr);
		}
		return oAndExpr;
	};

	cAndExpr.prototype.evaluate = function (oContext) {
		var bValue = fFunction_sequence_toEBV(this.left.evaluate(oContext), oContext);
		for (var nIndex = 0, nLength = this.items.length; nIndex < nLength && bValue; nIndex++) {
			bValue = fFunction_sequence_toEBV(this.items[nIndex].evaluate(oContext), oContext);
		}return [new cXSBoolean(bValue)];
	};

	function cStepExpr() {};

	cStepExpr.prototype.predicates = null;

	function fStepExpr_parse(oLexer, oStaticContext) {
		if (!oLexer.eof()) return fFilterExpr_parse(oLexer, oStaticContext) || fAxisStep_parse