Merge remote-tracking branch 'upstream/master' into feature_filter

.gitignore

@@ -4,3 +4,4 @@ build/dev
 docs/*
 !docs/*.conf.json
 !docs/*.ico
+.vscode

Gruntfile.js

@@ -28,7 +28,7 @@ module.exports = function(grunt) {
 
     grunt.registerTask("default",
         "Lints the code base and shows stats",
-        ["jshint", "exec:stats", "exec:display_stats"]);
+        ["eslint", "exec:stats", "exec:display_stats"]);
 
     grunt.registerTask("doc", "docs");
     grunt.registerTask("lint", "eslint");
@@ -130,7 +130,8 @@ module.exports = function(grunt) {
         "src/js/lib/vkbeautify.js",
         "src/js/lib/Sortable.js",
         "src/js/lib/bootstrap-colorpicker.js",
-
+        "src/js/lib/xpath.js",
+        
         // Custom libraries
         "src/js/lib/canvas_components.js",
 

package.json

@@ -21,27 +21,24 @@
     "format",
     "cybersecurity"
   ],
-  "bugs": {
-    "email": ""
-  },
   "repository": {
     "type": "git",
-    "url": ""
+    "url": "https://github.com/gchq/CyberChef/"
   },
   "devDependencies": {
-    "grunt": "~0.4.5",
+    "grunt": "~1.0.1",
     "grunt-chmod": "~1.1.1",
     "grunt-contrib-clean": "~1.0.0",
     "grunt-contrib-concat": "~1.0.0",
-    "grunt-contrib-copy": "~0.8.2",
-    "grunt-contrib-cssmin": "~0.14.0",
-    "grunt-contrib-htmlmin": "~0.6.0",
-    "grunt-contrib-uglify": "~0.11.1",
-    "grunt-contrib-watch": "~0.6.1",
+    "grunt-contrib-copy": "~1.0.0",
+    "grunt-contrib-cssmin": "~1.0.2",
+    "grunt-contrib-htmlmin": "~2.0.0",
+    "grunt-contrib-uglify": "~2.0.0",
+    "grunt-contrib-watch": "~1.0.0",
     "grunt-eslint": "^19.0.0",
-    "grunt-exec": "~0.4.6",
+    "grunt-exec": "~1.0.1",
     "grunt-inline-alt": "~0.3.10",
-    "grunt-jsdoc": "^1.1.0",
+    "grunt-jsdoc": "^2.1.0",
     "ink-docstrap": "^1.1.4"
   }
 }

src/html/index.html

@@ -114,9 +114,10 @@
                         <div class="title no-select">
                             Output
                             <div class="btn-group io-btn-group">
-                                <button type="button" class="btn btn-default btn-sm" id="save-to-file"><img src="images/save_as-16x16.png" /> Save to file</button>
-                                <button type="button" class="btn btn-default btn-sm" id="switch"><img src="images/switch-16x16.png" /> Move output to input</button>
-                                <button type="button" class="btn btn-default btn-sm" id="undo-switch" disabled="disabled"><img src="images/undo-16x16.png" /> Undo</button>
+                                <button type="button" class="btn btn-default btn-sm" id="save-to-file" title="Save to file"><img src="images/save_as-16x16.png" /> Save to file</button>
+                                <button type="button" class="btn btn-default btn-sm" id="switch" title="Move output to input"><img src="images/switch-16x16.png" /> Move output to input</button>
+                                <button type="button" class="btn btn-default btn-sm" id="undo-switch" title="Undo move" disabled="disabled"><img src="images/undo-16x16.png" /> Undo</button>
+                                <button type="button" class="btn btn-default btn-sm" id="maximise-output" title="Maximise"><img src="images/maximise-16x16.png" /> Max</button>
                             </div>
                             <div class="io-info" id="output-info"></div>
                             <div class="io-info" id="output-selection-info"></div>

src/js/config/Categories.js

@@ -82,6 +82,7 @@ const Categories = [
             "XOR Brute Force",
             "Vigenère Encode",
             "Vigenère Decode",
+            "Substitute",
             "Derive PBKDF2 key",
             "Derive EVP key",
         ]
@@ -190,6 +191,8 @@ const Categories = [
             "Extract file paths",
             "Extract dates",
             "Regular expression",
+            "XPath expression",
+            "CSS selector",
         ]
     },
     {
@@ -242,6 +245,8 @@ const Categories = [
             "SQL Minify",
             "CSS Beautify",
             "CSS Minify",
+            "XPath expression",
+            "CSS selector",
             "Strip HTML tags",
             "Diff",
         ]

src/js/config/OperationConfig.js

@@ -1961,6 +1961,42 @@ const OperationConfig = {
             },
         ]
     },
+    "XPath expression": {
+        description: "Extract information from an XML document with an XPath query",
+        run: Code.run_xpath,
+        input_type: "string",
+        output_type: "string",
+        args: [
+            {
+                name: "XPath",
+                type: "string",
+                value: Code.XPATH_INITIAL
+            },
+            {
+                name: "Result delimiter",
+                type: "binary_short_string",
+                value: Code.XPATH_DELIMITER
+            }
+        ]
+    },
+    "CSS selector": {
+        description: "Extract information from an HTML document with a CSS selector",
+        run: Code.run_css_query,
+        input_type: "string",
+        output_type: "string",
+        args: [
+            {
+                name: "CSS selector",
+                type: "string",
+                value: Code.CSS_SELECTOR_INITIAL
+            },
+            {
+                name: "Delimiter",
+                type: "binary_short_string",
+                value: Code.CSS_QUERY_DELIMITER
+            },
+        ]
+    },
     "From UNIX Timestamp": {
         description: "Converts a UNIX timestamp to a datetime string.<br><br>e.g. <code>978346800</code> becomes <code>Mon 1 January 2001 11:00:00 UTC</code>",
         run: DateTime.run_from_unix_timestamp,
@@ -2850,5 +2886,23 @@ const OperationConfig = {
         input_type: "string",
         output_type: "string",
         args: []
+    },
+    "Substitute": {
+        description: "A substitution cipher allowing you to specify bytes to replace with other byte values. This can be used to create Caesar ciphers but is more powerful as any byte value can be substituted, not just letters, and the substitution values need not be in order.<br><br>Enter the bytes you want to replace in the Plaintext field and the bytes to replace them with in the Ciphertext field.<br><br>Non-printable bytes can be specified using string escape notation. For example, a line feed character can be written as either <code>\\n</code> or <code>\\x0a</code>.<br><br>Byte ranges can be specified using a hyphen. For example, the sequence <code>0123456789</code> can be written as <code>0-9</code>.",
+        run: Cipher.run_substitute,
+        input_type: "byte_array",
+        output_type: "byte_array",
+        args: [
+            {
+                name: "Plaintext",
+                type: "binary_string",
+                value: Cipher.SUBS_PLAINTEXT
+            },
+            {
+                name: "Ciphertext",
+                type: "binary_string",
+                value: Cipher.SUBS_CIPHERTEXT
+            }
+        ]
     }
 };

src/js/lib/split.js

@@ -1,6 +1,6 @@
 /** @license
 ========================================================================
-  Split.js v1.0.7
+  Split.js v1.1.1
   Copyright (c) 2015 Nathan Cahill
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -22,17 +22,43 @@
   THE SOFTWARE.
 */
 
+
+// The programming goals of Split.js are to deliver readable, understandable and
+// maintainable code, while at the same time manually optimizing for tiny minified file size,
+// browser compatibility without additional requirements, graceful fallback (IE8 is supported)
+// and very few assumptions about the user's page layout.
+//
+// Make sure all browsers handle this JS library correctly with ES5.
+// More information here: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode
 'use strict';
 
+// A wrapper function that does a couple things:
+//
+// 1. Doesn't pollute the global namespace. This is important for a library.
+// 2. Allows us to mount the library in different module systems, as well as
+//    directly in the browser.
 (function() {
 
+// Save the global `this` for use later. In this case, since the library only
+// runs in the browser, it will refer to `window`. Also, figure out if we're in IE8
+// or not. IE8 will still render correctly, but will be static instead of draggable.
+//
+// Save a couple long function names that are used frequently.
+// This optimization saves around 400 bytes.
 var global = this
+  , isIE8 = global.attachEvent && !global[addEventListener]
+  , document = global.document
   , addEventListener = 'addEventListener'
   , removeEventListener = 'removeEventListener'
   , getBoundingClientRect = 'getBoundingClientRect'
-  , isIE8 = global.attachEvent && !global[addEventListener]
-  , document = global.document
 
+  // This library only needs two helper functions:
+  //
+  // The first determines which prefixes of CSS calc we need.
+  // We only need to do this once on startup, when this anonymous function is called.
+  // 
+  // Tests -webkit, -moz and -o prefixes. Modified from StackOverflow:
+  // http://stackoverflow.com/questions/16625140/js-feature-detection-to-detect-the-usage-of-webkit-calc-over-calc/16625167#16625167
   , calc = (function () {
         var el
           , prefixes = ["", "-webkit-", "-moz-", "-o-"]
@@ -46,6 +72,10 @@ var global = this
             }
         }
     })()
+
+  // The second helper function allows elements and string selectors to be used
+  // interchangeably. In either case an element is returned. This allows us to
+  // do `Split(elem1, elem2)` as well as `Split('#id1', '#id2')`.
   , elementOrSelector = function (el) {
         if (typeof el === 'string' || el instanceof String) {
             return document.querySelector(el)
@@ -54,6 +84,38 @@ var global = this
         }
     }
 
+  // The main function to initialize a split. Split.js thinks about each pair
+  // of elements as an independant pair. Dragging the gutter between two elements
+  // only changes the dimensions of elements in that pair. This is key to understanding
+  // how the following functions operate, since each function is bound to a pair.
+  // 
+  // A pair object is shaped like this:
+  // 
+  // {
+  //     a: DOM element,
+  //     b: DOM element,
+  //     aMin: Number,
+  //     bMin: Number,
+  //     dragging: Boolean,
+  //     parent: DOM element,
+  //     isFirst: Boolean,
+  //     isLast: Boolean,
+  //     direction: 'horizontal' | 'vertical'
+  // }
+  //
+  // The basic sequence:
+  // 
+  // 1. Set defaults to something sane. `options` doesn't have to be passed at all.
+  // 2. Initialize a bunch of strings based on the direction we're splitting.
+  //    A lot of the behavior in the rest of the library is paramatized down to
+  //    rely on CSS strings and classes.
+  // 3. Define the dragging helper functions, and a few helpers to go with them.
+  // 4. Define a few more functions that "balance" the entire split instance.
+  //    Split.js tries it's best to cope with min sizes that don't add up.
+  // 5. Loop through the elements while pairing them off. Every pair gets an
+  //    `pair` object, a gutter, and special isFirst/isLast properties.
+  // 6. Actually size the pair elements, insert gutters and attach event listeners.
+  // 7. Balance all of the pairs to accomodate min sizes as best as possible.
   , Split = function (ids, options) {
     var dimension
       , i
@@ -65,8 +127,9 @@ var global = this
       , paddingB
       , pairs = []
 
-    // Set defaults
-
+    // 1. Set defaults to something sane. `options` doesn't have to be passed at all,
+    // so create an options object if none exists. Pixel values 10, 100 and 30 are
+    // arbitrary but feel natural.
     options = typeof options !== 'undefined' ?  options : {}
 
     if (typeof options.gutterSize === 'undefined') options.gutterSize = 10
@@ -74,6 +137,9 @@ var global = this
     if (typeof options.snapOffset === 'undefined') options.snapOffset = 30
     if (typeof options.direction === 'undefined') options.direction = 'horizontal'
 
+    // 2. Initialize a bunch of strings based on the direction we're splitting.
+    // A lot of the behavior in the rest of the library is paramatized down to
+    // rely on CSS strings and classes.
     if (options.direction == 'horizontal') {
         dimension = 'width'
         clientDimension = 'clientWidth'
@@ -94,25 +160,43 @@ var global = this
         if (!options.cursor) options.cursor = 'ns-resize'
     }
 
-    // Event listeners for drag events, bound to a pair object.
-    // Calculate the pair's position and size when dragging starts.
-    // Prevent selection on start and re-enable it when done.
-
+    // 3. Define the dragging helper functions, and a few helpers to go with them.
+    // Each helper is bound to a pair object that contains it's metadata. This
+    // also makes it easy to store references to listeners that that will be
+    // added and removed.
+    // 
+    // Even though there are no other functions contained in them, aliasing
+    // this to self saves 50 bytes or so since it's used so frequently.
+    //
+    // The pair object saves metadata like dragging state, position and
+    // event listener references.
+    //
+    // startDragging calls `calculateSizes` to store the inital size in the pair object.
+    // It also adds event listeners for mouse/touch events,
+    // and prevents selection while dragging so avoid the selecting text.
     var startDragging = function (e) {
+            // Alias frequently used variables to save space. 200 bytes.
             var self = this
               , a = self.a
               , b = self.b
 
+            // Call the onDragStart callback.
             if (!self.dragging && options.onDragStart) {
                 options.onDragStart()
             }
 
+            // Don't actually drag the element. We emulate that in the drag function.
             e.preventDefault()
 
+            // Set the dragging property of the pair object.
             self.dragging = true
+
+            // Create two event listeners bound to the same pair object and store
+            // them in the pair object.
             self.move = drag.bind(self)
             self.stop = stopDragging.bind(self)
 
+            // All the binding. `window` gets the stop events in case we drag out of the elements.
             global[addEventListener]('mouseup', self.stop)
             global[addEventListener]('touchend', self.stop)
             global[addEventListener]('touchcancel', self.stop)
@@ -120,10 +204,11 @@ var global = this
             self.parent[addEventListener]('mousemove', self.move)
             self.parent[addEventListener]('touchmove', self.move)
 
-            a[addEventListener]('selectstart', preventSelection)
-            a[addEventListener]('dragstart', preventSelection)
-            b[addEventListener]('selectstart', preventSelection)
-            b[addEventListener]('dragstart', preventSelection)
+            // Disable selection. Disable!
+            a[addEventListener]('selectstart', noop)
+            a[addEventListener]('dragstart', noop)
+            b[addEventListener]('selectstart', noop)
+            b[addEventListener]('dragstart', noop)
 
             a.style.userSelect = 'none'
             a.style.webkitUserSelect = 'none'
@@ -135,11 +220,16 @@ var global = this
             b.style.MozUserSelect = 'none'
             b.style.pointerEvents = 'none'
 
+            // Set the cursor, both on the gutter and the parent element.
+            // Doing only a, b and gutter causes flickering.
             self.gutter.style.cursor = options.cursor
             self.parent.style.cursor = options.cursor
 
+            // Cache the initial sizes of the pair.
             calculateSizes.call(self)
         }
+
+      // stopDragging is very similar to startDragging in reverse.
       , stopDragging = function () {
             var self = this
               , a = self.a
@@ -151,6 +241,7 @@ var global = this
 
             self.dragging = false
 
+            // Remove the stored event listeners. This is why we store them.
             global[removeEventListener]('mouseup', self.stop)
             global[removeEventListener]('touchend', self.stop)
             global[removeEventListener]('touchcancel', self.stop)
@@ -158,13 +249,15 @@ var global = this
             self.parent[removeEventListener]('mousemove', self.move)
             self.parent[removeEventListener]('touchmove', self.move)
 
+            // Delete them once they are removed. I think this makes a difference
+            // in memory usage with a lot of splits on one page. But I don't know for sure.
             delete self.stop
             delete self.move
 
-            a[removeEventListener]('selectstart', preventSelection)
-            a[removeEventListener]('dragstart', preventSelection)
-            b[removeEventListener]('selectstart', preventSelection)
-            b[removeEventListener]('dragstart', preventSelection)
+            a[removeEventListener]('selectstart', noop)
+            a[removeEventListener]('dragstart', noop)
+            b[removeEventListener]('selectstart', noop)
+            b[removeEventListener]('dragstart', noop)
 
             a.style.userSelect = ''
             a.style.webkitUserSelect = ''
@@ -179,36 +272,70 @@ var global = this
             self.gutter.style.cursor = ''
             self.parent.style.cursor = ''
         }
+
+      // drag, where all the magic happens. The logic is really quite simple:
+      // 
+      // 1. Ignore if the pair is not dragging.
+      // 2. Get the offset of the event.
+      // 3. Snap offset to min if within snappable range (within min + snapOffset).
+      // 4. Actually adjust each element in the pair to offset.
+      // 
+      // ---------------------------------------------------------------------
+      // |    | <- this.aMin               ||              this.bMin -> |    |
+      // |    |  | <- this.snapOffset      ||     this.snapOffset -> |  |    |
+      // |    |  |                         ||                        |  |    |
+      // |    |  |                         ||                        |  |    |
+      // ---------------------------------------------------------------------
+      // | <- this.start                                        this.size -> |
       , drag = function (e) {
             var offset
 
             if (!this.dragging) return
 
-            // Get the relative position of the event from the first side of the
-            // pair.
-
+            // Get the offset of the event from the first side of the
+            // pair `this.start`. Supports touch events, but not multitouch, so only the first
+            // finger `touches[0]` is counted.
             if ('touches' in e) {
                 offset = e.touches[0][clientAxis] - this.start
             } else {
                 offset = e[clientAxis] - this.start
             }
 
-            // If within snapOffset of min or max, set offset to min or max
-
-            if (offset <=  this.aMin + options.snapOffset) {
-                offset = this.aMin
-            } else if (offset >= this.size - this.bMin - options.snapOffset) {
-                offset = this.size - this.bMin
+            // If within snapOffset of min or max, set offset to min or max.
+            // snapOffset buffers aMin and bMin, so logic is opposite for both.
+            // Include the appropriate gutter sizes to prevent overflows.
+            if (offset <= this.aMin + options.snapOffset + this.aGutterSize) {
+                offset = this.aMin + this.aGutterSize
+            } else if (offset >= this.size - (this.bMin + options.snapOffset + this.bGutterSize)) {
+                offset = this.size - (this.bMin + this.bGutterSize)
             }
 
+            // Actually adjust the size.
             adjust.call(this, offset)
 
+            // Call the drag callback continously. Don't do anything too intensive
+            // in this callback.
             if (options.onDrag) {
                 options.onDrag()
             }
         }
+
+      // Cache some important sizes when drag starts, so we don't have to do that
+      // continously:
+      // 
+      // `size`: The total size of the pair. First element + second element + first gutter + second gutter.
+      // `percentage`: The percentage between 0-100 that the pair occupies in the parent.
+      // `start`: The leading side of the first element.
+      //
+      // ------------------------------------------------ - - - - - - - - - - -
+      // |      aGutterSize -> |||                      |                     |
+      // |                     |||                      |                     |
+      // |                     |||                      |                     |
+      // |                     ||| <- bGutterSize       |                     |
+      // ------------------------------------------------ - - - - - - - - - - -
+      // | <- start                             size -> |       parentSize -> |
       , calculateSizes = function () {
-            // Calculate the pairs size, and percentage of the parent size
+            // Figure out the parent size minus padding.
             var computedStyle = global.getComputedStyle(this.parent)
               , parentSize = this.parent[clientDimension] - parseFloat(computedStyle[paddingA]) - parseFloat(computedStyle[paddingB])
 
@@ -216,13 +343,21 @@ var global = this
             this.percentage = Math.min(this.size / parentSize * 100, 100)
             this.start = this.a[getBoundingClientRect]()[position]
         }
-      , adjust = function (offset) {
-            // A size is the same as offset. B size is total size - A size.
-            // Both sizes are calculated from the initial parent percentage.
 
+      // Actually adjust the size of elements `a` and `b` to `offset` while dragging.
+      // calc is used to allow calc(percentage + gutterpx) on the whole split instance,
+      // which allows the viewport to be resized without additional logic.
+      // Element a's size is the same as offset. b's size is total size - a size.
+      // Both sizes are calculated from the initial parent percentage, then the gutter size is subtracted.
+      , adjust = function (offset) {
             this.a.style[dimension] = calc + '(' + (offset / this.size * this.percentage) + '% - ' + this.aGutterSize + 'px)'
             this.b.style[dimension] = calc + '(' + (this.percentage - (offset / this.size * this.percentage)) + '% - ' + this.bGutterSize + 'px)'
         }
+
+      // 4. Define a few more functions that "balance" the entire split instance.
+      // Split.js tries it's best to cope with min sizes that don't add up.
+      // At some point this should go away since it breaks out of the calc(% - px) model.
+      // Maybe it's a user error if you pass uncomputable minSizes.
       , fitMin = function () {
             var self = this
               , a = self.a
@@ -260,9 +395,31 @@ var global = this
                 fitMinReverse.call(pairs[i])
             }
         }
-      , preventSelection = function () { return false }
+      , setElementSize = function (el, size, gutterSize) {
+            // Split.js allows setting sizes via numbers (ideally), or if you must,
+            // by string, like '300px'. This is less than ideal, because it breaks
+            // the fluid layout that `calc(% - px)` provides. You're on your own if you do that,
+            // make sure you calculate the gutter size by hand.
+            if (typeof size !== 'string' && !(size instanceof String)) {
+                if (!isIE8) {
+                    size = calc + '(' + size + '% - ' + gutterSize + 'px)'
+                } else {
+                    size = options.sizes[i] + '%'
+                }
+            }
+
+            el.style[dimension] = size
+        }
+
+      // No-op function to prevent default. Used to prevent selection.
+      , noop = function () { return false }
+
+      // All DOM elements in the split should have a common parent. We can grab
+      // the first elements parent and hope users read the docs because the
+      // behavior will be whacky otherwise.
       , parent = elementOrSelector(ids[0]).parentNode
 
+    // Set default options.sizes to equal percentages of the parent element.
     if (!options.sizes) {
         var percent = 100 / ids.length
 
@@ -273,6 +430,8 @@ var global = this
         }
     }
 
+    // Standardize minSize to an array if it isn't already. This allows minSize
+    // to be passed as a number.
     if (!Array.isArray(options.minSize)) {
         var minSizes = []
 
@@ -283,15 +442,34 @@ var global = this
         options.minSize = minSizes
     }
 
+    // 5. Loop through the elements while pairing them off. Every pair gets a
+    // `pair` object, a gutter, and isFirst/isLast properties.
+    //
+    // Basic logic:
+    //
+    // - Starting with the second element `i > 0`, create `pair` objects with
+    //   `a = ids[i - 1]` and `b = ids[i]`
+    // - Set gutter sizes based on the _pair_ being first/last. The first and last
+    //   pair have gutterSize / 2, since they only have one half gutter, and not two.
+    // - Create gutter elements and add event listeners.
+    // - Set the size of the elements, minus the gutter sizes.
+    //
+    // -----------------------------------------------------------------------
+    // |     i=0     |         i=1         |        i=2       |      i=3     |
+    // |             |       isFirst       |                  |     isLast   |
+    // |           pair 0                pair 1             pair 2           |
+    // |             |                     |                  |              |
+    // -----------------------------------------------------------------------
     for (i = 0; i < ids.length; i++) {
         var el = elementOrSelector(ids[i])
-          , isFirst = (i == 1)
-          , isLast = (i == ids.length - 1)
-          , size
+          , isFirstPair = (i == 1)
+          , isLastPair = (i == ids.length - 1)
+          , size = options.sizes[i]
           , gutterSize = options.gutterSize
           , pair
 
         if (i > 0) {
+            // Create the pair object with it's metadata.
             pair = {
                 a: elementOrSelector(ids[i - 1]),
                 b: el,
@@ -299,27 +477,31 @@ var global = this
                 bMin: options.minSize[i],
                 dragging: false,
                 parent: parent,
-                isFirst: isFirst,
-                isLast: isLast,
+                isFirst: isFirstPair,
+                isLast: isLastPair,
                 direction: options.direction
             }
 
             // For first and last pairs, first and last gutter width is half.
-
             pair.aGutterSize = options.gutterSize
             pair.bGutterSize = options.gutterSize
 
-            if (isFirst) {
+            if (isFirstPair) {
                 pair.aGutterSize = options.gutterSize / 2
             }
 
-            if (isLast) {
+            if (isLastPair) {
                 pair.bGutterSize = options.gutterSize / 2
             }
         }
 
+        // Determine the size of the current element. IE8 is supported by
+        // staticly assigning sizes without draggable gutters. Assigns a string
+        // to `size`.
+        // 
         // IE9 and above
         if (!isIE8) {
+            // Create gutter elements for each pair.
             if (i > 0) {
                 var gutter = document.createElement('div')
 
@@ -334,35 +516,62 @@ var global = this
                 pair.gutter = gutter
             }
 
+            // Half-size gutters for first and last elements.
             if (i === 0 || i == ids.length - 1) {
                 gutterSize = options.gutterSize / 2
             }
-
-            if (typeof options.sizes[i] === 'string' || options.sizes[i] instanceof String) {
-                size = options.sizes[i]
-            } else {
-                size = calc + '(' + options.sizes[i] + '% - ' + gutterSize + 'px)'
-            }
-
-        // IE8 and below
-        } else {
-            if (typeof options.sizes[i] === 'string' || options.sizes[i] instanceof String) {
-                size = options.sizes[i]
-            } else {
-                size = options.sizes[i] + '%'
-            }
         }
 
-        el.style[dimension] = size
+        // Set the element size to our determined size.
+        setElementSize(el, size, gutterSize)
 
+        // After the first iteration, and we have a pair object, append it to the
+        // list of pairs.
         if (i > 0) {
             pairs.push(pair)
         }
     }
 
+    // Balance the pairs to try to accomodate min sizes.
     balancePairs(pairs)
+
+    return {
+        setSizes: function (sizes) {
+            for (var i = 0; i < sizes.length; i++) {
+                if (i > 0) {
+                    var pair = pairs[i - 1]
+
+                    setElementSize(pair.a, sizes[i - 1], pair.aGutterSize)
+                    setElementSize(pair.b, sizes[i], pair.bGutterSize)
+                }
+            }
+        },
+        collapse: function (i) {
+            var pair
+
+            if (i === pairs.length) {
+                pair = pairs[i - 1]
+
+                calculateSizes.call(pair)
+                adjust.call(pair, pair.size - pair.bGutterSize)
+            } else {
+                pair = pairs[i]
+
+                calculateSizes.call(pair)
+                adjust.call(pair, pair.aGutterSize)
+            }
+        },
+        destroy: function () {
+            for (var i = 0; i < pairs.length; i++) {
+                pairs[i].parent.removeChild(pairs[i].gutter)
+                pairs[i].a.style[dimension] = ''
+                pairs[i].b.style[dimension] = ''
+            }
+        }
+    }
 }
 
+// Play nicely with module systems, and the browser too if you include it raw.
 if (typeof exports !== 'undefined') {
     if (typeof module !== 'undefined' && module.exports) {
         exports = module.exports = Split
@@ -372,4 +581,5 @@ if (typeof exports !== 'undefined') {
     global.Split = Split
 }
 
+// Call our wrapper function with the current global. In this case, `window`.
 }).call(window);

src/js/lib/xpath.js

@@ -0,0 +1,8466 @@
+/** @license
+========================================================================
+  XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ 
+  Copyright (c) 2012 Sergey Ilinsky
+  Dual licensed under the MIT and GPL licenses.
+*/
+(function(){
+
+//	Javascript objects
+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,
+// Error Objects
+	cError		= window.Error,
+	cSyntaxError= window.SyntaxError,
+	cTypeError	= window.TypeError,
+//	misc
+	fIsNaN		= window.isNaN,
+	fIsFinite	= window.isFinite,
+	nNaN		= window.NaN,
+	nInfinity	= window.Infinity,
+	// Functions
+	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";
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cException(sCode
+
+	) {
+
+	this.code		= sCode;
+	this.message	=
+
+					  oException_messages[sCode];
+};
+
+cException.prototype	= new cError;
+
+// "http://www.w3.org/2005/xqt-errors"
+
+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.";
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cLexer(sValue) {
+	var aMatch	= sValue.match(/\$?(?:(?![0-9-])(?:\w[\w.-]*|\*):)?(?![0-9-])(?:\w[\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"
+
+			);
+	}
+};
+
+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;
+};
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cDOMAdapter() {
+
+};
+
+// Custom members
+cDOMAdapter.prototype.isNode		= function(oNode) {
+	return oNode &&!!oNode.nodeType;
+};
+
+cDOMAdapter.prototype.getProperty	= function(oNode, sName) {
+	return oNode[sName];
+};
+
+// Standard members
+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);
+};
+
+// Document object members
+cDOMAdapter.prototype.getElementById	= function(oNode, sId) {
+	return oNode.getElementById(sId);
+};
+
+// Element/Document object members
+cDOMAdapter.prototype.getElementsByTagNameNS	= function(oNode, sNameSpaceURI, sLocalName) {
+	return oNode.getElementsByTagNameNS(sNameSpaceURI, sLocalName);
+};
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+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;	// Variables stack
+//
+cDynamicContext.prototype.dateTime	= null;
+cDynamicContext.prototype.timezone	= null;
+//
+cDynamicContext.prototype.staticContext	= null;
+
+// Stack management
+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];
+		}
+	}
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+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[aMatch[2]] : this.dataTypes[sUri];
+};
+
+cStaticContext.prototype.setDocument		= function(sUri, fFunction) {
+	this.documents[sUri]	= fFunction;
+};
+
+cStaticContext.prototype.getDocument		= function(sUri) {
+	return this.documents[sUri];
+};
+
+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[aMatch[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.getCollection	= function(sUri) {
+	return this.collections[sUri];
+};
+
+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"
+
+	);
+};
+
+// Static members
+//Converts non-null JavaScript object to XML Schema object
+cStaticContext.js2xs	= function(vItem) {
+	// Convert types from JavaScript to XPath 2.0
+	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;
+};
+
+// Converts non-null XML Schema object to JavaScript object
+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;
+};
+
+// System functions with signatures, operators and types
+var hStaticContext_functions	= {},
+	hStaticContext_signatures	= {},
+	hStaticContext_dataTypes	= {},
+	hStaticContext_operators	= {};
+
+function fStaticContext_defineSystemFunction(sName, aParameters, fFunction) {
+	// Register function
+	hStaticContext_functions[sName]	= fFunction;
+	// Register signature
+	hStaticContext_signatures[sName]	= aParameters;
+};
+
+function fStaticContext_defineSystemDataType(sName, fFunction) {
+	// Register dataType
+	hStaticContext_dataTypes[sName]	= fFunction;
+};
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cExpression(sExpression, oStaticContext) {
+	var oLexer	= new cLexer(sExpression),
+		oExpr	= fExpr_parse(oLexer, oStaticContext);
+	//
+	if (!oLexer.eof())
+		throw new cException("XPST0003"
+
+		);
+	//
+	if (!oExpr)
+		throw new cException("XPST0003"
+
+		);
+	this.internalExpression	= oExpr;
+};
+
+cExpression.prototype.internalExpression	= null;
+
+// Public methods
+cExpression.prototype.evaluate	= function(oContext) {
+	return this.internalExpression.evaluate(oContext);
+};
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cStringCollator() {
+
+};
+
+cStringCollator.prototype.equals	= function(sValue1, sValue2) {
+	throw "Not implemented";
+};
+
+cStringCollator.prototype.compare	= function(sValue1, sValue2) {
+	throw "Not implemented";
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSConstants(){};
+
+// XML Schema 1.0 Datatypes
+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;
+
+// XML Schema 1.1 Datatypes
+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;
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cExpr() {
+	this.items	= [];
+};
+
+cExpr.prototype.items	= null;
+
+// Static members
+function fExpr_parse (oLexer, oStaticContext) {
+	var oItem;
+	if (oLexer.eof() ||!(oItem = fExprSingle_parse(oLexer, oStaticContext)))
+		return;
+
+	// Create expression
+	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"
+
+			);
+		oExpr.items.push(oItem);
+	}
+	return oExpr;
+};
+
+// Public members
+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;
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cExprSingle() {
+
+};
+
+// Static members
+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);
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cForExpr() {
+	this.bindings	= [];
+	this.returnExpr	= null;
+};
+
+cForExpr.prototype.bindings		= null;
+cForExpr.prototype.returnExpr	= null;
+
+// Static members
+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"
+
+			);
+
+		oLexer.next();
+		if (oLexer.eof() ||!(oExpr = fExprSingle_parse(oLexer, oStaticContext)))
+			throw new cException("XPST0003"
+
+			);
+
+		oForExpr.returnExpr	= oExpr;
+		return oForExpr;
+	}
+};
+
+// Public members
+// for $x in X, $y in Y, $z in Z return $x + $y + $z
+// for $x in X return for $y in Y return for $z in Z return $x + $y + $z
+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"
+
+		);
+
+	if (aMatch[1] == '*' || aMatch[2] == '*')
+		throw new cException("XPST0003"
+
+		);
+
+	oLexer.next();
+	if (oLexer.peek() != "in")
+		throw new cException("XPST0003"
+
+		);
+
+	oLexer.next();
+	var oExpr;
+	if (oLexer.eof() ||!(oExpr = fExprSingle_parse(oLexer, oStaticContext)))
+		throw new cException("XPST0003"
+
+		);
+
+	return new cSimpleForBinding(aMatch[1] || null, aMatch[2], aMatch[1] ? oStaticContext.getURIForPrefix(aMatch[1]) : null, oExpr);
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+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;
+
+// Static members
+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"
+
+			);
+		//
+		if (oLexer.peek() != ')')
+			throw new cException("XPST0003"
+
+			);
+
+		oLexer.next();
+		if (oLexer.peek() != "then")
+			throw new cException("XPST0003"
+
+			);
+
+		oLexer.next();
+		if (oLexer.eof() ||!(oThenExpr = fExprSingle_parse(oLexer, oStaticContext)))
+			throw new cException("XPST0003"
+
+			);
+
+		if (oLexer.peek() != "else")
+			throw new cException("XPST0003"
+
+			);
+
+		oLexer.next();
+		if (oLexer.eof() ||!(oElseExpr = fExprSingle_parse(oLexer, oStaticContext)))
+			throw new cException("XPST0003"
+
+			);
+		//
+		return new cIfExpr(oCondExpr, oThenExpr, oElseExpr);
+	}
+};
+
+// Public members
+cIfExpr.prototype.evaluate	= function (oContext) {
+	return this[fFunction_sequence_toEBV(this.condExpr.evaluate(oContext), oContext) ? "thenExpr" : "elseExpr"].evaluate(oContext);
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cQuantifiedExpr(sQuantifier) {
+	this.quantifier		= sQuantifier;
+	this.bindings		= [];
+	this.satisfiesExpr	= null;
+};
+
+cQuantifiedExpr.prototype.bindings		= null;
+cQuantifiedExpr.prototype.quantifier	= null;
+cQuantifiedExpr.prototype.satisfiesExpr	= null;
+
+// Static members
+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"
+
+			);
+
+		oLexer.next();
+		if (oLexer.eof() ||!(oExpr = fExprSingle_parse(oLexer, oStaticContext)))
+			throw new cException("XPST0003"
+
+			);
+
+		oQuantifiedExpr.satisfiesExpr	= oExpr;
+		return oQuantifiedExpr;
+	}
+};
+
+// Public members
+cQuantifiedExpr.prototype.evaluate	= function (oContext) {
+	// TODO: re-factor
+	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"
+
+		);
+
+	if (aMatch[1] == '*' || aMatch[2] == '*')
+		throw new cException("XPST0003"
+
+		);
+
+	oLexer.next();
+	if (oLexer.peek() != "in")
+		throw new cException("XPST0003"
+
+		);
+
+	oLexer.next();
+	var oExpr;
+	if (oLexer.eof() ||!(oExpr = fExprSingle_parse(oLexer, oStaticContext)))
+		throw new cException("XPST0003"
+
+		);
+
+	return new cSimpleQuantifiedBinding(aMatch[1] || null, aMatch[2], aMatch[1] ? oStaticContext.getURIForPrefix(aMatch[1]) : null, oExpr);
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+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;
+
+// Static members
+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;
+
+	// Comparison expression
+	var sOperator	= oLexer.peek();
+	oLexer.next();
+	if (oLexer.eof() ||!(oRight = fRangeExpr_parse(oLexer, oStaticContext)))
+		throw new cException("XPST0003"
+
+		);
+	return new cComparisonExpr(oExpr, oRight, sOperator);
+};
+
+// Public members
+cComparisonExpr.prototype.evaluate	= function (oContext) {
+	var oResult	= hComparisonExpr_operators[this.operator](this, oContext);
+	return oResult == null ? [] : [oResult];
+};
+
+// General comparison
+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) {
+				// cast xs:untypedAtomic to xs:string
+				vLeft	= cXSString.cast(vLeft);
+				vRight	= cXSString.cast(vRight);
+			}
+			else {
+				//
+				if (bLeft) {
+					// Special: durations
+					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) {
+					// Special: durations
+					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);
+				}
+
+				// cast xs:anyURI to xs:string
+				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'
+};
+
+// Value comparison
+function fComparisonExpr_ValueComp(oExpr, oContext) {
+	var oLeft	= fFunction_sequence_atomize(oExpr.left.evaluate(oContext), oContext);
+	if (!oLeft.length)
+		return null;
+	// Assert cardinality
+	fFunctionCall_assertSequenceCardinality(oContext, oLeft, '?'
+
+	);
+
+	var oRight	= fFunction_sequence_atomize(oExpr.right.evaluate(oContext), oContext);
+	if (!oRight.length)
+		return null;
+	// Assert cardinality
+	fFunctionCall_assertSequenceCardinality(oContext, oRight, '?'
+
+	);
+
+	var vLeft	= oLeft[0],
+		vRight	= oRight[0];
+
+	// cast xs:untypedAtomic to xs:string
+	if (vLeft instanceof cXSUntypedAtomic)
+		vLeft	= cXSString.cast(vLeft);
+	if (vRight instanceof cXSUntypedAtomic)
+		vRight	= cXSString.cast(vRight);
+
+	// cast xs:anyURI to xs:string
+	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";
+	}
+	// skipped: xs:anyURI (covered by xs:string)
+	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";
+	}
+
+	// Call operator function
+	if (sOperator)
+		return hStaticContext_operators[sOperator].call(oContext, oLeft, oRight);
+
+	// skipped: xs:NOTATION
+	throw new cException("XPTY0004"
+
+	);	// Cannot compare {type1} to {type2}
+};
+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";
+	}
+
+	// Call operator function
+	if (sOperator)
+		return hStaticContext_operators[sOperator].call(oContext, oLeft, oRight);
+
+	// skipped: xs:anyURI (covered by xs:string)
+	throw new cException("XPTY0004"
+
+	);	// Cannot compare {type1} to {type2}
+};
+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";
+	}
+
+	// Call operator function
+	if (sOperator)
+		return hStaticContext_operators[sOperator].call(oContext, oLeft, oRight);
+
+	// skipped: xs:anyURI (covered by xs:string)
+	throw new cException("XPTY0004"
+
+	);	// Cannot compare {type1} to {type2}
+};
+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";
+	}
+
+	// Call operator function
+	if (sOperator)
+		return new cXSBoolean(!hStaticContext_operators[sOperator].call(oContext, oLeft, oRight).valueOf());
+
+	// skipped: xs:anyURI (covered by xs:string)
+	throw new cException("XPTY0004"
+
+	);	// Cannot compare {type1} to {type2}
+};
+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";
+	}
+
+	// Call operator function
+	if (sOperator)
+		return new cXSBoolean(!hStaticContext_operators[sOperator].call(oContext, oLeft, oRight).valueOf());
+
+	// skipped: xs:anyURI (covered by xs:string)
+	throw new cException("XPTY0004"
+
+	);	// Cannot compare {type1} to {type2}
+};
+
+// Node comparison
+function fComparisonExpr_NodeComp(oExpr, oContext) {
+	var oLeft	= oExpr.left.evaluate(oContext);
+	if (!oLeft.length)
+		return null;
+	// Assert cardinality
+	fFunctionCall_assertSequenceCardinality(oContext, oLeft, '?'
+
+	);
+	// Assert item type
+	fFunctionCall_assertSequenceItemType(oContext, oLeft, cXTNode
+
+	);
+
+	var oRight	= oExpr.right.evaluate(oContext);
+	if (!oRight.length)
+		return null;
+	// Assert cardinality
+	fFunctionCall_assertSequenceCardinality(oContext, oRight, '?'
+
+	);
+	// Assert item type
+	fFunctionCall_assertSequenceItemType(oContext, oRight, cXTNode
+
+	);
+
+	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);
+};
+
+// Operators
+var hComparisonExpr_operators	= {
+	// GeneralComp
+	'=':	fComparisonExpr_GeneralComp,
+	'!=':	fComparisonExpr_GeneralComp,
+	'<':	fComparisonExpr_GeneralComp,
+	'<=':	fComparisonExpr_GeneralComp,
+	'>':	fComparisonExpr_GeneralComp,
+	'>=':	fComparisonExpr_GeneralComp,
+	// ValueComp
+	'eq':	fComparisonExpr_ValueComp,
+	'ne':	fComparisonExpr_ValueComp,
+	'lt':	fComparisonExpr_ValueComp,
+	'le':	fComparisonExpr_ValueComp,
+	'gt':	fComparisonExpr_ValueComp,
+	'ge':	fComparisonExpr_ValueComp,
+	// NodeComp
+	'is':	fComparisonExpr_NodeComp,
+	'>>':	fComparisonExpr_NodeComp,
+	'<<':	fComparisonExpr_NodeComp
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+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";
+	}
+
+	// Call operator function
+	if (sOperator)
+		return hStaticContext_operators[sOperator].call(oContext, bReverse ? oRight : oLeft, bReverse ? oLeft : oRight);
+
+	//
+	throw new cException("XPTY0004"
+
+	);	// Arithmetic operator is not defined for arguments of types ({type1}, {type2})
+};
+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";
+	}
+
+	// Call operator function
+	if (sOperator)
+		return hStaticContext_operators[sOperator].call(oContext, oLeft, oRight);
+
+	//
+	throw new cException("XPTY0004"
+
+	);	// Arithmetic operator is not defined for arguments of types ({type1}, {type2})
+};
+
+// Static members
+function fAdditiveExpr_parse (oLexer, oStaticContext) {
+	var oExpr;
+	if (oLexer.eof() ||!(oExpr = fMultiplicativeExpr_parse(oLexer, oStaticContext)))
+		return;
+	if (!(oLexer.peek() in hAdditiveExpr_operators))
+		return oExpr;
+
+	// Additive expression
+	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"
+
+			);
+		oAdditiveExpr.items.push([sOperator, oExpr]);
+	}
+	return oAdditiveExpr;
+};
+
+// Public members
+cAdditiveExpr.prototype.evaluate	= function (oContext) {
+	var oLeft	= fFunction_sequence_atomize(this.left.evaluate(oContext), oContext);
+
+	if (!oLeft.length)
+		return [];
+	// Assert cardinality
+	fFunctionCall_assertSequenceCardinality(oContext, oLeft, '?'
+
+	);
+
+	var vLeft	= oLeft[0];
+	if (vLeft instanceof cXSUntypedAtomic)
+		vLeft	= cXSDouble.cast(vLeft);	// cast to xs:double
+
+	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 [];
+		// Assert cardinality
+		fFunctionCall_assertSequenceCardinality(oContext, oRight, '?'
+
+		);
+
+		vRight	= oRight[0];
+		if (vRight instanceof cXSUntypedAtomic)
+			vRight	= cXSDouble.cast(vRight);	// cast to xs:double
+
+		vLeft	= hAdditiveExpr_operators[this.items[nIndex][0]](vLeft, vRight, oContext);
+	}
+	return [vLeft];
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+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";
+		}
+	}
+
+	// Call operator function
+	if (sOperator)
+		return hStaticContext_operators[sOperator].call(oContext, bReverse ? oRight : oLeft, bReverse ? oLeft : oRight);
+
+	//
+	throw new cException("XPTY0004"
+
+	);	// Arithmetic operator is not defined for arguments of types ({type1}, {type2})
+};
+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";
+	}
+	// Call operator function
+	if (sOperator)
+		return hStaticContext_operators[sOperator].call(oContext, oLeft, oRight);
+
+	//
+	throw new cException("XPTY0004"
+
+	);	// Arithmetic operator is not defined for arguments of types ({type1}, {type2})
+};
+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 arguments of types ({type1}, {type2})
+};
+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 arguments of types ({type1}, {type2})
+};
+
+// Static members
+function fMultiplicativeExpr_parse (oLexer, oStaticContext) {
+	var oExpr;
+	if (oLexer.eof() ||!(oExpr = fUnionExpr_parse(oLexer, oStaticContext)))
+		return;
+	if (!(oLexer.peek() in hMultiplicativeExpr_operators))
+		return oExpr;
+
+	// Additive expression
+	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"
+
+			);
+		oMultiplicativeExpr.items.push([sOperator, oExpr]);
+	}
+	return oMultiplicativeExpr;
+};
+
+// Public members
+cMultiplicativeExpr.prototype.evaluate	= function (oContext) {
+	var oLeft	= fFunction_sequence_atomize(this.left.evaluate(oContext), oContext);
+
+	//
+	if (!oLeft.length)
+		return [];
+	// Assert cardinality
+	fFunctionCall_assertSequenceCardinality(oContext, oLeft, '?'
+
+	);
+
+	var vLeft	= oLeft[0];
+	if (vLeft instanceof cXSUntypedAtomic)
+		vLeft	= cXSDouble.cast(vLeft);	// cast to xs:double
+
+	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 [];
+		// Assert cardinality
+		fFunctionCall_assertSequenceCardinality(oContext, oRight, '?'
+
+		);
+
+		vRight	= oRight[0];
+		if (vRight instanceof cXSUntypedAtomic)
+			vRight	= cXSDouble.cast(vRight);	// cast to xs:double
+
+		vLeft	= hMultiplicativeExpr_operators[this.items[nIndex][0]](vLeft, vRight, oContext);
+	}
+	return [vLeft];
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+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 arguments of types ({type1}, {type2})
+};
+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 arguments of types ({type1}, {type2})
+};
+
+// Static members
+// UnaryExpr	:= ("-" | "+")* ValueExpr
+function fUnaryExpr_parse (oLexer, oStaticContext) {
+	if (oLexer.eof())
+		return;
+	if (!(oLexer.peek() in hUnaryExpr_operators))
+		return fValueExpr_parse(oLexer, oStaticContext);
+
+	// Unary expression
+	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"
+
+		);
+	return new cUnaryExpr(sOperator, oExpr);
+};
+
+cUnaryExpr.prototype.evaluate	= function (oContext) {
+	var oRight	= fFunction_sequence_atomize(this.expression.evaluate(oContext), oContext);
+
+	//
+	if (!oRight.length)
+		return [];
+	// Assert cardinality
+	fFunctionCall_assertSequenceCardinality(oContext, oRight, '?'
+
+	);
+
+	var vRight	= oRight[0];
+	if (vRight instanceof cXSUntypedAtomic)
+		vRight	= cXSDouble.cast(vRight);	// cast to xs:double
+
+	return [hUnaryExpr_operators[this.operator](vRight, oContext)];
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cValueExpr() {
+
+};
+
+// Static members
+function fValueExpr_parse (oLexer, oStaticContext) {
+	return fPathExpr_parse(oLexer, oStaticContext);
+};
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cOrExpr(oExpr) {
+	this.left	= oExpr;
+	this.items	= [];
+};
+
+cOrExpr.prototype.left	= null;
+cOrExpr.prototype.items	= null;
+
+// Static members
+function fOrExpr_parse (oLexer, oStaticContext) {
+	var oExpr;
+	if (oLexer.eof() ||!(oExpr = fAndExpr_parse(oLexer, oStaticContext)))
+		return;
+	if (oLexer.peek() != "or")
+		return oExpr;
+
+	// Or expression
+	var oOrExpr	= new cOrExpr(oExpr);
+	while (oLexer.peek() == "or") {
+		oLexer.next();
+		if (oLexer.eof() ||!(oExpr = fAndExpr_parse(oLexer, oStaticContext)))
+			throw new cException("XPST0003"
+
+			);
+		oOrExpr.items.push(oExpr);
+	}
+	return oOrExpr;
+};
+
+// Public members
+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)];
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cAndExpr(oExpr) {
+	this.left	= oExpr;
+	this.items	= [];
+};
+
+cAndExpr.prototype.left		= null;
+cAndExpr.prototype.items	= null;
+
+// Static members
+function fAndExpr_parse (oLexer, oStaticContext) {
+	var oExpr;
+	if (oLexer.eof() ||!(oExpr = fComparisonExpr_parse(oLexer, oStaticContext)))
+		return;
+	if (oLexer.peek() != "and")
+		return oExpr;
+
+	// And expression
+	var oAndExpr	= new cAndExpr(oExpr);
+	while (oLexer.peek() == "and") {
+		oLexer.next();
+		if (oLexer.eof() ||!(oExpr = fComparisonExpr_parse(oLexer, oStaticContext)))
+			throw new cException("XPST0003"
+
+			);
+		oAndExpr.items.push(oExpr);
+	}
+	return oAndExpr;
+};
+
+// Public members
+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)];
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cStepExpr() {
+
+};
+
+cStepExpr.prototype.predicates	= null;
+
+// Static members
+function fStepExpr_parse (oLexer, oStaticContext) {
+	if (!oLexer.eof())
+		return fFilterExpr_parse(oLexer, oStaticContext)
+			|| fAxisStep_parse(oLexer, oStaticContext);
+};
+
+function fStepExpr_parsePredicates (oLexer, oStaticContext, oStep) {
+	var oExpr;
+	// Parse predicates
+	while (oLexer.peek() == '[') {
+		oLexer.next();
+
+		if (oLexer.eof() ||!(oExpr = fExpr_parse(oLexer, oStaticContext)))
+			throw new cException("XPST0003"
+
+			);
+
+		oStep.predicates.push(oExpr);
+
+		if (oLexer.peek() != ']')
+			throw new cException("XPST0003"
+
+			);
+
+		oLexer.next();
+	}
+};
+
+// Public members
+cStepExpr.prototype.applyPredicates	= function(oSequence, oContext) {
+	var vContextItem	= oContext.item,
+		nContextPosition= oContext.position,
+		nContextSize	= oContext.size;
+	//
+	for (var nPredicateIndex = 0, oSequence1, nPredicateLength = this.predicates.length; nPredicateIndex < nPredicateLength; nPredicateIndex++) {
+		oSequence1	= oSequence;
+		oSequence	= [];
+		for (var nIndex = 0, oSequence2, nLength = oSequence1.length; nIndex < nLength; nIndex++) {
+			// Set new context
+			oContext.item		= oSequence1[nIndex];
+			oContext.position	= nIndex + 1;
+			oContext.size		= nLength;
+			//
+			oSequence2	= this.predicates[nPredicateIndex].evaluate(oContext);
+			//
+			if (oSequence2.length == 1 && fXSAnyAtomicType_isNumeric(oSequence2[0])) {
+				if (oSequence2[0].valueOf() == nIndex + 1)
+					oSequence.push(oSequence1[nIndex]);
+			}
+			else
+			if (fFunction_sequence_toEBV(oSequence2, oContext))
+				oSequence.push(oSequence1[nIndex]);
+		}
+	}
+	// Restore context
+	oContext.item		= vContextItem;
+	oContext.position	= nContextPosition;
+	oContext.size		= nContextSize;
+	//
+	return oSequence;
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cAxisStep(sAxis, oTest) {
+	this.axis	= sAxis;
+	this.test	= oTest;
+	this.predicates	= [];
+};
+
+cAxisStep.prototype	= new cStepExpr;
+
+cAxisStep.prototype.axis		= null;
+cAxisStep.prototype.test		= null;
+
+//
+var hAxisStep_axises	= {};
+// Forward axis
+hAxisStep_axises["attribute"]			= {};
+hAxisStep_axises["child"]				= {};
+hAxisStep_axises["descendant"]			= {};
+hAxisStep_axises["descendant-or-self"]	= {};
+hAxisStep_axises["following"]			= {};
+hAxisStep_axises["following-sibling"]	= {};
+hAxisStep_axises["self"]				= {};
+// hAxisStep_axises["namespace"]			= {};	// deprecated in 2.0
+// Reverse axis
+hAxisStep_axises["ancestor"]			= {};
+hAxisStep_axises["ancestor-or-self"]	= {};
+hAxisStep_axises["parent"]				= {};
+hAxisStep_axises["preceding"]			= {};
+hAxisStep_axises["preceding-sibling"]	= {};
+
+// Static members
+function fAxisStep_parse (oLexer, oStaticContext) {
+	var sAxis	= oLexer.peek(),
+		oExpr,
+		oStep;
+	if (oLexer.peek(1) == '::') {
+		if (!(sAxis in hAxisStep_axises))
+			throw new cException("XPST0003"
+
+			);
+
+		oLexer.next(2);
+		if (oLexer.eof() ||!(oExpr = fNodeTest_parse(oLexer, oStaticContext)))
+			throw new cException("XPST0003"
+
+			);
+		//
+		oStep	= new cAxisStep(sAxis, oExpr);
+	}
+	else
+	if (sAxis == '..') {
+		oLexer.next();
+		oStep	= new cAxisStep("parent", new cKindTest("node"));
+	}
+	else
+	if (sAxis == '@') {
+		oLexer.next();
+		if (oLexer.eof() ||!(oExpr = fNodeTest_parse(oLexer, oStaticContext)))
+			throw new cException("XPST0003"
+
+			);
+		//
+		oStep	= new cAxisStep("attribute", oExpr);
+	}
+	else {
+		if (oLexer.eof() ||!(oExpr = fNodeTest_parse(oLexer, oStaticContext)))
+			return;
+		oStep	= new cAxisStep(oExpr instanceof cKindTest && oExpr.name == "attribute" ? "attribute" : "child", oExpr);
+	}
+	//
+	fStepExpr_parsePredicates(oLexer, oStaticContext, oStep);
+
+	return oStep;
+};
+
+// Public members
+cAxisStep.prototype.evaluate	= function (oContext) {
+	var oItem	= oContext.item;
+
+	if (!oContext.DOMAdapter.isNode(oItem))
+		throw new cException("XPTY0020");
+
+	var oSequence	= [],
+		fGetProperty= oContext.DOMAdapter.getProperty,
+		nType		= fGetProperty(oItem, "nodeType");
+
+	switch (this.axis) {
+		// Forward axis
+		case "attribute":
+			if (nType == 1)
+				for (var aAttributes = fGetProperty(oItem, "attributes"), nIndex = 0, nLength = aAttributes.length; nIndex < nLength; nIndex++)
+					oSequence.push(aAttributes[nIndex]);
+			break;
+
+		case "child":
+			for (var oNode = fGetProperty(oItem, "firstChild"); oNode; oNode = fGetProperty(oNode, "nextSibling"))
+				oSequence.push(oNode);
+			break;
+
+		case "descendant-or-self":
+			oSequence.push(oItem);
+			// No break left intentionally
+		case "descendant":
+			fAxisStep_getChildrenForward(fGetProperty(oItem, "firstChild"), oSequence, fGetProperty);
+			break;
+
+		case "following":
+			// TODO: Attribute node context
+			for (var oParent = oItem, oSibling; oParent; oParent = fGetProperty(oParent, "parentNode"))
+				if (oSibling = fGetProperty(oParent, "nextSibling"))
+					fAxisStep_getChildrenForward(oSibling, oSequence, fGetProperty);
+			break;
+
+		case "following-sibling":
+			for (var oNode = oItem; oNode = fGetProperty(oNode, "nextSibling");)
+				oSequence.push(oNode);
+			break;
+
+		case "self":
+			oSequence.push(oItem);
+			break;
+
+		// Reverse axis
+		case "ancestor-or-self":
+			oSequence.push(oItem);
+			// No break left intentionally
+		case "ancestor":
+			for (var oNode = nType == 2 ? fGetProperty(oItem, "ownerElement") : oItem; oNode = fGetProperty(oNode, "parentNode");)
+				oSequence.push(oNode);
+			break;
+
+		case "parent":
+			var oParent	= nType == 2 ? fGetProperty(oItem, "ownerElement") : fGetProperty(oItem, "parentNode");
+			if (oParent)
+				oSequence.push(oParent);
+			break;
+
+		case "preceding":
+			// TODO: Attribute node context
+			for (var oParent = oItem, oSibling; oParent; oParent = fGetProperty(oParent, "parentNode"))
+				if (oSibling = fGetProperty(oParent, "previousSibling"))
+					fAxisStep_getChildrenBackward(oSibling, oSequence, fGetProperty);
+			break;
+
+		case "preceding-sibling":
+			for (var oNode = oItem; oNode = fGetProperty(oNode, "previousSibling");)
+				oSequence.push(oNode);
+			break;
+	}
+
+	// Apply test
+	if (oSequence.length && !(this.test instanceof cKindTest && this.test.name == "node")) {
+		var oSequence1	= oSequence;
+		oSequence	= [];
+		for (var nIndex = 0, nLength = oSequence1.length; nIndex < nLength; nIndex++) {
+			if (this.test.test(oSequence1[nIndex], oContext))
+				oSequence.push(oSequence1[nIndex]);
+		}
+	}
+
+	// Apply predicates
+	if (oSequence.length && this.predicates.length)
+		oSequence	= this.applyPredicates(oSequence, oContext);
+
+	// Reverse results if reverse axis
+	switch (this.axis) {
+		case "ancestor":
+		case "ancestor-or-self":
+		case "parent":
+		case "preceding":
+		case "preceding-sibling":
+			oSequence.reverse();
+	}
+
+	return oSequence;
+};
+
+//
+function fAxisStep_getChildrenForward(oNode, oSequence, fGetProperty) {
+	for (var oChild; oNode; oNode = fGetProperty(oNode, "nextSibling")) {
+		oSequence.push(oNode);
+		if (oChild = fGetProperty(oNode, "firstChild"))
+			fAxisStep_getChildrenForward(oChild, oSequence, fGetProperty);
+	}
+};
+
+function fAxisStep_getChildrenBackward(oNode, oSequence, fGetProperty) {
+	for (var oChild; oNode; oNode = fGetProperty(oNode, "previousSibling")) {
+		if (oChild = fGetProperty(oNode, "lastChild"))
+			fAxisStep_getChildrenBackward(oChild, oSequence, fGetProperty);
+		oSequence.push(oNode);
+	}
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cPathExpr() {
+	this.items	= [];
+};
+
+cPathExpr.prototype.items	= null;
+
+// Static members
+function fPathExpr_parse (oLexer, oStaticContext) {
+	if (oLexer.eof())
+		return;
+	var sSingleSlash	= '/',
+		sDoubleSlash	= '/' + '/';
+
+	var oPathExpr	= new cPathExpr(),
+		sSlash	= oLexer.peek(),
+		oExpr;
+	// Parse first step
+	if (sSlash == sDoubleSlash || sSlash == sSingleSlash) {
+		oLexer.next();
+		oPathExpr.items.push(new cFunctionCall(null, "root", sNS_XPF));
+		//
+		if (sSlash == sDoubleSlash)
+			oPathExpr.items.push(new cAxisStep("descendant-or-self", new cKindTest("node")));
+	}
+
+	//
+	if (oLexer.eof() ||!(oExpr = fStepExpr_parse(oLexer, oStaticContext))) {
+		if (sSlash == sSingleSlash)
+			return oPathExpr.items[0];	// '/' expression
+		if (sSlash == sDoubleSlash)
+			throw new cException("XPST0003"
+
+			);
+		return;
+	}
+	oPathExpr.items.push(oExpr);
+
+	// Parse other steps
+	while ((sSlash = oLexer.peek()) == sSingleSlash || sSlash == sDoubleSlash) {
+		if (sSlash == sDoubleSlash)
+			oPathExpr.items.push(new cAxisStep("descendant-or-self", new cKindTest("node")));
+		//
+		oLexer.next();
+		if (oLexer.eof() ||!(oExpr = fStepExpr_parse(oLexer, oStaticContext)))
+			throw new cException("XPST0003"
+
+			);
+		//
+		oPathExpr.items.push(oExpr);
+	}
+
+	if (oPathExpr.items.length == 1)
+		return oPathExpr.items[0];
+
+	//
+	return oPathExpr;
+};
+
+// Public members
+cPathExpr.prototype.evaluate	= function (oContext) {
+	var vContextItem	= oContext.item;
+	//
+	var oSequence	= [vContextItem];
+	for (var nItemIndex = 0, nItemLength = this.items.length, oSequence1; nItemIndex < nItemLength; nItemIndex++) {
+		oSequence1	= [];
+		for (var nIndex = 0, nLength = oSequence.length; nIndex < nLength; nIndex++) {
+			// Set new context item
+			oContext.item	= oSequence[nIndex];
+			//
+			for (var nRightIndex = 0, oSequence2 = this.items[nItemIndex].evaluate(oContext), nRightLength = oSequence2.length; nRightIndex < nRightLength; nRightIndex++)
+				if ((nItemIndex < nItemLength - 1) && !oContext.DOMAdapter.isNode(oSequence2[nRightIndex]))
+					throw new cException("XPTY0019");
+				else
+				if (fArray_indexOf(oSequence1, oSequence2[nRightIndex]) ==-1)
+					oSequence1.push(oSequence2[nRightIndex]);
+		}
+		oSequence	= oSequence1;
+	};
+	// Restore context item
+	oContext.item	= vContextItem;
+	//
+	return fFunction_sequence_order(oSequence, oContext);
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cNodeTest() {
+
+};
+
+// Static members
+function fNodeTest_parse (oLexer, oStaticContext) {
+	if (!oLexer.eof())
+		return fKindTest_parse(oLexer, oStaticContext)
+			|| fNameTest_parse(oLexer, oStaticContext);
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cKindTest(sName) {
+	this.name	= sName;
+	this.args	= [];
+};
+
+cKindTest.prototype	= new cNodeTest;
+
+cKindTest.prototype.name	= null;
+cKindTest.prototype.args	= null;
+
+var hKindTest_names	= {};
+//
+hKindTest_names["document-node"]	= {};
+hKindTest_names["element"]			= {};
+hKindTest_names["attribute"]		= {};
+hKindTest_names["processing-instruction"]	= {};
+hKindTest_names["comment"]			= {};
+hKindTest_names["text"]				= {};
+hKindTest_names["node"]				= {};
+//
+hKindTest_names["schema-element"]	= {};
+hKindTest_names["schema-attribute"]	= {};
+
+// Static members
+function fKindTest_parse (oLexer, oStaticContext) {
+	var sName	= oLexer.peek(),
+		oValue;
+	if (oLexer.peek(1) == '(') {
+		//
+		if (!(sName in hKindTest_names))
+			throw new cException("XPST0003"
+
+			);
+
+		//
+		oLexer.next(2);
+		//
+		var oTest	= new cKindTest(sName);
+		if (oLexer.peek() != ')') {
+			if (sName == "document-node") {
+				// TODO: parse test further
+			}
+			else
+			if (sName == "element") {
+				// TODO: parse test further
+			}
+			else
+			if (sName == "attribute") {
+				// TODO: parse test further
+			}
+			else
+			if (sName == "processing-instruction") {
+				oValue = fStringLiteral_parse(oLexer, oStaticContext);
+				if (!oValue) {
+					oValue = new cStringLiteral(new cXSString(oLexer.peek()));
+					oLexer.next();
+				}
+				oTest.args.push(oValue);
+			}
+			else
+			if (sName == "schema-attribute") {
+				// TODO: parse test further
+			}
+			else
+			if (sName == "schema-element") {
+				// TODO: parse test further
+			}
+		}
+		else {
+			if (sName == "schema-attribute")
+				throw new cException("XPST0003"
+
+				);
+			else
+			if (sName == "schema-element")
+				throw new cException("XPST0003"
+
+				);
+		}
+
+		if (oLexer.peek() != ')')
+			throw new cException("XPST0003"
+
+			);
+		oLexer.next();
+
+		return oTest;
+	}
+};
+
+// Public members
+cKindTest.prototype.test	= function (oNode, oContext) {
+	var fGetProperty	= oContext.DOMAdapter.getProperty,
+		nType	= oContext.DOMAdapter.isNode(oNode) ? fGetProperty(oNode, "nodeType") : 0,
+		sTarget;
+	switch (this.name) {
+		// Node type test
+		case "node":			return !!nType;
+		case "attribute":				if (nType != 2)	return false;	break;
+		case "document-node":	return nType == 9;
+		case "element":			return nType == 1;
+		case "processing-instruction":	if (nType != 7)	return false;	break;
+		case "comment":			return nType == 8;
+		case "text":			return nType == 3 || nType == 4;
+
+		// Schema tests
+		case "schema-attribute":
+			throw "KindTest '" + "schema-attribute" + "' not implemented";
+
+		case "schema-element":
+			throw "KindTest '" + "schema-element" + "' not implemented";
+	}
+
+	// Additional tests
+	if (nType == 2)
+		return fGetProperty(oNode, "prefix") != "xmlns" && fGetProperty(oNode, "localName") != "xmlns";
+	if (nType == 7) {
+		sTarget = fGetProperty(oNode, "target");
+		return this.args.length ? sTarget == this.args[0].value : sTarget != "xml";
+	}
+
+	return true;
+};
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cNameTest(sPrefix, sLocalName, sNameSpaceURI) {
+	this.prefix			= sPrefix;
+	this.localName		= sLocalName;
+	this.namespaceURI	= sNameSpaceURI;
+};
+
+cNameTest.prototype	= new cNodeTest;
+
+cNameTest.prototype.prefix			= null;
+cNameTest.prototype.localName		= null;
+cNameTest.prototype.namespaceURI	= null;
+
+// Static members
+var rNameTest	= /^(?:(?![0-9-])(\w[\w.-]*|\*)\:)?(?![0-9-])(\w[\w.-]*|\*)$/;
+function fNameTest_parse (oLexer, oStaticContext) {
+	var aMatch	= oLexer.peek().match(rNameTest);
+	if (aMatch) {
+		if (aMatch[1] == '*' && aMatch[2] == '*')
+			throw new cException("XPST0003"
+
+			);
+		oLexer.next();
+		return new cNameTest(aMatch[1] || null, aMatch[2], aMatch[1] ? aMatch[1] == '*' ? '*' : oStaticContext.getURIForPrefix(aMatch[1]) || null : oStaticContext.defaultElementNamespace);
+	}
+};
+
+// Public members
+cNameTest.prototype.test	= function (oNode, oContext) {
+	var fGetProperty	= oContext.DOMAdapter.getProperty,
+		nType	= fGetProperty(oNode, "nodeType");
+	if (nType == 1 || nType == 2) {
+		if (this.localName == '*')
+			return (nType == 1 || (fGetProperty(oNode, "prefix") != "xmlns" && fGetProperty(oNode, "localName") != "xmlns")) && (!this.prefix || fGetProperty(oNode, "namespaceURI") == this.namespaceURI);
+		if (this.localName == fGetProperty(oNode, "localName"))
+			return this.namespaceURI == '*' || (nType == 2 && !this.prefix && !fGetProperty(oNode, "prefix")) || fGetProperty(oNode, "namespaceURI") == this.namespaceURI;
+	}
+	//
+	return false;
+};
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cPrimaryExpr() {
+
+};
+
+// Static members
+function fPrimaryExpr_parse (oLexer, oStaticContext) {
+	if (!oLexer.eof())
+		return fContextItemExpr_parse(oLexer, oStaticContext)
+			|| fParenthesizedExpr_parse(oLexer, oStaticContext)
+			|| fFunctionCall_parse(oLexer, oStaticContext)
+			|| fVarRef_parse(oLexer, oStaticContext)
+			|| fLiteral_parse(oLexer, oStaticContext);
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cParenthesizedExpr(oExpr) {
+	this.expression	= oExpr;
+};
+
+// Static members
+function fParenthesizedExpr_parse (oLexer, oStaticContext) {
+	if (oLexer.peek() == '(') {
+		oLexer.next();
+		// Check if not empty (allowed)
+		var oExpr	= null;
+		if (oLexer.peek() != ')')
+			oExpr	= fExpr_parse(oLexer, oStaticContext);
+
+		//
+		if (oLexer.peek() != ')')
+			throw new cException("XPST0003"
+
+			);
+
+		oLexer.next();
+
+		//
+		return new cParenthesizedExpr(oExpr);
+	}
+};
+
+// Public members
+cParenthesizedExpr.prototype.evaluate	= function (oContext) {
+	return this.expression ? this.expression.evaluate(oContext) : [];
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cContextItemExpr() {
+
+};
+
+// Static members
+function fContextItemExpr_parse (oLexer, oStaticContext) {
+	if (oLexer.peek() == '.') {
+		oLexer.next();
+		return new cContextItemExpr;
+	}
+};
+
+// Public members
+cContextItemExpr.prototype.evaluate	= function (oContext) {
+	if (oContext.item == null)
+		throw new cException("XPDY0002"
+
+		);
+	//
+	return [oContext.item];
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cLiteral() {
+
+};
+
+cLiteral.prototype.value	= null;
+
+// Static members
+function fLiteral_parse (oLexer, oStaticContext) {
+	if (!oLexer.eof())
+		return fNumericLiteral_parse(oLexer, oStaticContext)
+			|| fStringLiteral_parse(oLexer, oStaticContext);
+};
+
+// Public members
+cLiteral.prototype.evaluate	= function (oContext) {
+	return [this.value];
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cNumericLiteral(oValue) {
+	this.value	= oValue;
+};
+
+cNumericLiteral.prototype	= new cLiteral;
+
+// Integer | Decimal | Double
+var rNumericLiteral	= /^[+\-]?(?:(?:(\d+)(?:\.(\d*))?)|(?:\.(\d+)))(?:[eE]([+-])?(\d+))?$/;
+function fNumericLiteral_parse (oLexer, oStaticContext) {
+	var sValue	= oLexer.peek(),
+		vValue	= fNumericLiteral_parseValue(sValue);
+	if (vValue) {
+		oLexer.next();
+		return new cNumericLiteral(vValue);
+	}
+};
+
+function fNumericLiteral_parseValue(sValue) {
+	var aMatch	= sValue.match(rNumericLiteral);
+	if (aMatch) {
+		var cType	= cXSInteger;
+		if (aMatch[5])
+			cType	= cXSDouble;
+		else
+		if (aMatch[2] || aMatch[3])
+			cType	= cXSDecimal;
+		return new cType(+sValue);
+	}
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cStringLiteral(oValue) {
+	this.value	= oValue;
+};
+
+cStringLiteral.prototype	= new cLiteral;
+
+var rStringLiteral	= /^'([^']*(?:''[^']*)*)'|"([^"]*(?:""[^"]*)*)"$/;
+function fStringLiteral_parse (oLexer, oStaticContext) {
+	var aMatch	= oLexer.peek().match(rStringLiteral);
+	if (aMatch) {
+		oLexer.next();
+		return new cStringLiteral(new cXSString(aMatch[1] ? aMatch[1].replace("''", "'") : aMatch[2] ? aMatch[2].replace('""', '"') : ''));
+	}
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cFilterExpr(oPrimary) {
+	this.expression	= oPrimary;
+	this.predicates	= [];
+};
+
+cFilterExpr.prototype	= new cStepExpr;
+
+cFilterExpr.prototype.expression	= null;
+
+// Static members
+function fFilterExpr_parse (oLexer, oStaticContext) {
+	var oExpr;
+	if (oLexer.eof() ||!(oExpr = fPrimaryExpr_parse(oLexer, oStaticContext)))
+		return;
+
+	var oFilterExpr	= new cFilterExpr(oExpr);
+	// Parse predicates
+	fStepExpr_parsePredicates(oLexer, oStaticContext, oFilterExpr);
+
+	// If no predicates found
+	if (oFilterExpr.predicates.length == 0)
+		return oFilterExpr.expression;
+
+	return oFilterExpr;
+};
+
+// Public members
+cFilterExpr.prototype.evaluate	= function (oContext) {
+	var oSequence	= this.expression.evaluate(oContext);
+	if (this.predicates.length && oSequence.length)
+		oSequence	= this.applyPredicates(oSequence, oContext);
+	return oSequence;
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cVarRef(sPrefix, sLocalName, sNameSpaceURI) {
+	this.prefix			= sPrefix;
+	this.localName		= sLocalName;
+	this.namespaceURI	= sNameSpaceURI;
+};
+
+cVarRef.prototype.prefix		= null;
+cVarRef.prototype.localName		= null;
+cVarRef.prototype.namespaceURI	= null;
+
+// Static members
+function fVarRef_parse (oLexer, oStaticContext) {
+	if (oLexer.peek().substr(0, 1) == '$') {
+		var aMatch	= oLexer.peek().substr(1).match(rNameTest);
+		if (aMatch) {
+			if (aMatch[1] == '*' || aMatch[2] == '*')
+				throw new cException("XPST0003"
+	
+				);
+
+			var oVarRef	= new cVarRef(aMatch[1] || null, aMatch[2], aMatch[1] ? oStaticContext.getURIForPrefix(aMatch[1]) : null);
+			oLexer.next();
+			return oVarRef;
+		}
+	}
+};
+
+// Public members
+cVarRef.prototype.evaluate	= function (oContext) {
+	var sUri	= (this.namespaceURI ? '{' + this.namespaceURI + '}' : '') + this.localName;
+	if (oContext.scope.hasOwnProperty(sUri))
+		return [oContext.scope[sUri]];
+	//
+	throw new cException("XPST0008"
+
+	);
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cFunctionCall(sPrefix, sLocalName, sNameSpaceURI) {
+	this.prefix			= sPrefix;
+	this.localName		= sLocalName;
+	this.namespaceURI	= sNameSpaceURI;
+	this.args	= [];
+};
+
+cFunctionCall.prototype.prefix			= null;
+cFunctionCall.prototype.localName		= null;
+cFunctionCall.prototype.namespaceURI	= null;
+cFunctionCall.prototype.args	= null;
+
+// Static members
+function fFunctionCall_parse (oLexer, oStaticContext) {
+	var aMatch	= oLexer.peek().match(rNameTest);
+	if (aMatch && oLexer.peek(1) == '(') {
+		// Reserved "functions"
+		if (!aMatch[1] && (aMatch[2] in hKindTest_names))
+			return fAxisStep_parse(oLexer, oStaticContext);
+		// Other functions
+		if (aMatch[1] == '*' || aMatch[2] == '*')
+			throw new cException("XPST0003"
+
+			);
+		var oFunctionCallExpr	= new cFunctionCall(aMatch[1] || null, aMatch[2], aMatch[1] ? oStaticContext.getURIForPrefix(aMatch[1]) || null : oStaticContext.defaultFunctionNamespace),
+			oExpr;
+		oLexer.next(2);
+		//
+		if (oLexer.peek() != ')') {
+			do {
+				if (oLexer.eof() ||!(oExpr = fExprSingle_parse(oLexer, oStaticContext)))
+					throw new cException("XPST0003"
+
+					);
+				//
+				oFunctionCallExpr.args.push(oExpr);
+			}
+			while (oLexer.peek() == ',' && oLexer.next());
+			//
+			if (oLexer.peek() != ')')
+				throw new cException("XPST0003"
+
+				);
+		}
+		oLexer.next();
+		return oFunctionCallExpr;
+	}
+};
+
+// Public members
+cFunctionCall.prototype.evaluate	= function (oContext) {
+	var aArguments	= [],
+		aParameters,
+		fFunction;
+
+	// Evaluate arguments
+	for (var nIndex = 0, nLength = this.args.length; nIndex < nLength; nIndex++)
+		aArguments.push(this.args[nIndex].evaluate(oContext));
+
+	var sUri	= (this.namespaceURI ? '{' + this.namespaceURI + '}' : '') + this.localName;
+	// Call function
+	if (this.namespaceURI == sNS_XPF) {
+		if (fFunction = hStaticContext_functions[this.localName]) {
+			// Validate/Cast arguments
+			if (aParameters = hStaticContext_signatures[this.localName])
+				fFunctionCall_prepare(this.localName, aParameters, fFunction, aArguments, oContext);
+			//
+			var vResult	= fFunction.apply(oContext, aArguments);
+			//
+			return vResult == null ? [] : vResult instanceof cArray ? vResult : [vResult];
+		}
+		throw new cException("XPST0017"
+
+		);
+	}
+	else
+	if (this.namespaceURI == sNS_XSD) {
+		if ((fFunction = hStaticContext_dataTypes[this.localName]) && this.localName != "NOTATION" && this.localName != "anyAtomicType") {
+			//
+			fFunctionCall_prepare(this.localName, [[cXSAnyAtomicType, '?']], fFunction, aArguments, oContext);
+			//
+			return aArguments[0] === null ? [] : [fFunction.cast(aArguments[0])];
+		}
+		throw new cException("XPST0017"
+
+		);
+	}
+	else
+	if (fFunction = oContext.staticContext.getFunction(sUri)) {
+		//
+		var vResult	= fFunction.apply(oContext, aArguments);
+		//
+		return vResult == null ? [] : vResult instanceof cArray ? vResult : [vResult];
+	}
+	//
+	throw new cException("XPST0017"
+
+	);
+};
+
+var aFunctionCall_numbers	= ["first", "second", "third", "fourth", "fifth"];
+function fFunctionCall_prepare(sName, aParameters, fFunction, aArguments, oContext) {
+	var oArgument,
+		nArgumentsLength	= aArguments.length,
+		oParameter,
+		nParametersLength	= aParameters.length,
+		nParametersRequired	= 0;
+
+	// Determine amount of parameters required
+	while ((nParametersRequired < aParameters.length) && !aParameters[nParametersRequired][2])
+		nParametersRequired++;
+
+	// Validate arguments length
+	if (nArgumentsLength > nParametersLength)
+		throw new cException("XPST0017"
+
+		);
+	else
+	if (nArgumentsLength < nParametersRequired)
+		throw new cException("XPST0017"
+
+		);
+
+	for (var nIndex = 0; nIndex < nArgumentsLength; nIndex++) {
+		oParameter	= aParameters[nIndex];
+		oArgument	= aArguments[nIndex];
+		// Check sequence cardinality
+		fFunctionCall_assertSequenceCardinality(oContext, oArgument, oParameter[1]
+
+		);
+		// Check sequence items data types consistency
+		fFunctionCall_assertSequenceItemType(oContext, oArgument, oParameter[0]
+
+		);
+		if (oParameter[1] != '+' && oParameter[1] != '*')
+			aArguments[nIndex]	= oArgument.length ? oArgument[0] : null;
+	}
+};
+
+function fFunctionCall_assertSequenceItemType(oContext, oSequence, cItemType
+
+	) {
+	//
+	for (var nIndex = 0, nLength = oSequence.length, nNodeType, vItem; nIndex < nLength; nIndex++) {
+		vItem	= oSequence[nIndex];
+		// Node types
+		if (cItemType == cXTNode || cItemType.prototype instanceof cXTNode) {
+			// Check if is node
+			if (!oContext.DOMAdapter.isNode(vItem))
+				throw new cException("XPTY0004"
+
+				);
+
+			// Check node type
+			if (cItemType != cXTNode) {
+				nNodeType	= oContext.DOMAdapter.getProperty(vItem, "nodeType");
+				if ([null, cXTElement, cXTAttribute, cXTText, cXTText, null, null, cXTProcessingInstruction, cXTComment, cXTDocument, null, null, null][nNodeType] != cItemType)
+					throw new cException("XPTY0004"
+
+					);
+			}
+		}
+		else
+		// Atomic types
+		if (cItemType == cXSAnyAtomicType || cItemType.prototype instanceof cXSAnyAtomicType) {
+			// Atomize item
+			vItem	= fFunction_sequence_atomize([vItem], oContext)[0];
+			// Convert type if necessary
+			if (cItemType != cXSAnyAtomicType) {
+				// Cast item to expected type if it's type is xs:untypedAtomic
+				if (vItem instanceof cXSUntypedAtomic)
+					vItem	= cItemType.cast(vItem);
+				// Cast item to xs:string if it's type is xs:anyURI
+				else
+				if (cItemType == cXSString/* || cItemType.prototype instanceof cXSString*/) {
+					if (vItem instanceof cXSAnyURI)
+						vItem	= cXSString.cast(vItem);
+				}
+				else
+				if (cItemType == cXSDouble/* || cItemType.prototype instanceof cXSDouble*/) {
+					if (fXSAnyAtomicType_isNumeric(vItem))
+						vItem	= cItemType.cast(vItem);
+				}
+			}
+			// Check type
+			if (!(vItem instanceof cItemType))
+				throw new cException("XPTY0004"
+
+				);
+			// Write value back to sequence
+			oSequence[nIndex]	= vItem;
+		}
+	}
+};
+
+function fFunctionCall_assertSequenceCardinality(oContext, oSequence, sCardinality
+
+	) {
+	var nLength	= oSequence.length;
+	// Check cardinality
+	if (sCardinality == '?') {	// =0 or 1
+		if (nLength > 1)
+			throw new cException("XPTY0004"
+
+			);
+	}
+	else
+	if (sCardinality == '+') {	// =1+
+		if (nLength < 1)
+			throw new cException("XPTY0004"
+
+			);
+	}
+	else
+	if (sCardinality != '*') {	// =1 ('*' =0+)
+		if (nLength != 1)
+			throw new cException("XPTY0004"
+
+			);
+	}
+};
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cIntersectExceptExpr(oExpr) {
+	this.left	= oExpr;
+	this.items	= [];
+};
+
+cIntersectExceptExpr.prototype.left		= null;
+cIntersectExceptExpr.prototype.items	= null;
+
+// Static members
+function fIntersectExceptExpr_parse (oLexer, oStaticContext) {
+	var oExpr,
+		sOperator;
+	if (oLexer.eof() ||!(oExpr = fInstanceofExpr_parse(oLexer, oStaticContext)))
+		return;
+	if (!((sOperator = oLexer.peek()) == "intersect" || sOperator == "except"))
+		return oExpr;
+
+	// IntersectExcept expression
+	var oIntersectExceptExpr	= new cIntersectExceptExpr(oExpr);
+	while ((sOperator = oLexer.peek()) == "intersect" || sOperator == "except") {
+		oLexer.next();
+		if (oLexer.eof() ||!(oExpr = fInstanceofExpr_parse(oLexer, oStaticContext)))
+			throw new cException("XPST0003"
+
+			);
+		oIntersectExceptExpr.items.push([sOperator, oExpr]);
+	}
+	return oIntersectExceptExpr;
+};
+
+// Public members
+cIntersectExceptExpr.prototype.evaluate	= function (oContext) {
+	var oSequence	= this.left.evaluate(oContext);
+	for (var nIndex = 0, nLength = this.items.length, oItem; nIndex < nLength; nIndex++)
+		oSequence	= hStaticContext_operators[(oItem = this.items[nIndex])[0]].call(oContext, oSequence, oItem[1].evaluate(oContext));
+	return oSequence;
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cRangeExpr(oLeft, oRight) {
+	this.left	= oLeft;
+	this.right	= oRight;
+};
+
+cRangeExpr.prototype.left	= null;
+cRangeExpr.prototype.right	= null;
+
+// Static members
+function fRangeExpr_parse (oLexer, oStaticContext) {
+	var oExpr,
+		oRight;
+	if (oLexer.eof() ||!(oExpr = fAdditiveExpr_parse(oLexer, oStaticContext)))
+		return;
+	if (oLexer.peek() != "to")
+		return oExpr;
+
+	// Range expression
+	oLexer.next();
+	if (oLexer.eof() ||!(oRight = fAdditiveExpr_parse(oLexer, oStaticContext)))
+		throw new cException("XPST0003"
+
+		);
+	return new cRangeExpr(oExpr, oRight);
+};
+
+// Public members
+cRangeExpr.prototype.evaluate	= function (oContext) {
+	//
+	var oLeft	= this.left.evaluate(oContext);
+	if (!oLeft.length)
+		return [];
+	//
+
+
+	fFunctionCall_assertSequenceCardinality(oContext, oLeft, '?'
+
+	);
+	fFunctionCall_assertSequenceItemType(oContext, oLeft, cXSInteger
+
+	);
+
+	var oRight	= this.right.evaluate(oContext);
+	if (!oRight.length)
+		return [];
+
+
+
+	fFunctionCall_assertSequenceCardinality(oContext, oRight, '?'
+
+	);
+	fFunctionCall_assertSequenceItemType(oContext, oRight, cXSInteger
+
+	);
+
+	return hStaticContext_operators["to"].call(oContext, oLeft[0], oRight[0]);
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cUnionExpr(oExpr) {
+	this.left	= oExpr;
+	this.items	= [];
+};
+
+cUnionExpr.prototype.left	= null;
+cUnionExpr.prototype.items	= null;
+
+// Static members
+function fUnionExpr_parse (oLexer, oStaticContext) {
+	var oExpr,
+		sOperator;
+	if (oLexer.eof() ||!(oExpr = fIntersectExceptExpr_parse(oLexer, oStaticContext)))
+		return;
+	if (!((sOperator = oLexer.peek()) == '|' || sOperator == "union"))
+		return oExpr;
+
+	// Union expression
+	var oUnionExpr	= new cUnionExpr(oExpr);
+	while ((sOperator = oLexer.peek()) == '|' || sOperator == "union") {
+		oLexer.next();
+		if (oLexer.eof() ||!(oExpr = fIntersectExceptExpr_parse(oLexer, oStaticContext)))
+			throw new cException("XPST0003"
+
+			);
+		oUnionExpr.items.push(oExpr);
+	}
+	return oUnionExpr;
+};
+
+// Public members
+cUnionExpr.prototype.evaluate	= function (oContext) {
+	var oSequence	= this.left.evaluate(oContext);
+	for (var nIndex = 0, nLength = this.items.length; nIndex < nLength; nIndex++)
+		oSequence	= hStaticContext_operators["union"].call(oContext, oSequence, this.items[nIndex].evaluate(oContext));
+	return oSequence;
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cInstanceofExpr(oExpr, oType) {
+	this.expression	= oExpr;
+	this.type		= oType;
+};
+
+cInstanceofExpr.prototype.expression	= null;
+cInstanceofExpr.prototype.type			= null;
+
+function fInstanceofExpr_parse (oLexer, oStaticContext) {
+	var oExpr,
+		oType;
+	if (oLexer.eof() ||!(oExpr = fTreatExpr_parse(oLexer, oStaticContext)))
+		return;
+
+	if (!(oLexer.peek() == "instance" && oLexer.peek(1) == "of"))
+		return oExpr;
+
+	oLexer.next(2);
+	if (oLexer.eof() ||!(oType = fSequenceType_parse(oLexer, oStaticContext)))
+		throw new cException("XPST0003"
+
+		);
+
+	return new cInstanceofExpr(oExpr, oType);
+};
+
+cInstanceofExpr.prototype.evaluate	= function(oContext) {
+	var oSequence1	= this.expression.evaluate(oContext),
+		oItemType	= this.type.itemType,
+		sOccurence	= this.type.occurence;
+	// Validate empty-sequence()
+	if (!oItemType)
+		return [new cXSBoolean(!oSequence1.length)];
+	// Validate cardinality
+	if (!oSequence1.length)
+		return [new cXSBoolean(sOccurence == '?' || sOccurence == '*')];
+	if (oSequence1.length != 1)
+		if (!(sOccurence == '+' || sOccurence == '*'))
+			return [new cXSBoolean(false)];
+
+	// Validate type
+	if (!oItemType.test)	// item()
+		return [new cXSBoolean(true)];
+
+	var bValue	= true;
+	for (var nIndex = 0, nLength = oSequence1.length; (nIndex < nLength) && bValue; nIndex++)
+		bValue	= oItemType.test.test(oSequence1[nIndex], oContext);
+	//
+	return [new cXSBoolean(bValue)];
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cTreatExpr(oExpr, oType) {
+	this.expression	= oExpr;
+	this.type		= oType;
+};
+
+cTreatExpr.prototype.expression	= null;
+cTreatExpr.prototype.type		= null;
+
+function fTreatExpr_parse (oLexer, oStaticContext) {
+	var oExpr,
+		oType;
+	if (oLexer.eof() ||!(oExpr = fCastableExpr_parse(oLexer, oStaticContext)))
+		return;
+
+	if (!(oLexer.peek() == "treat" && oLexer.peek(1) == "as"))
+		return oExpr;
+
+	oLexer.next(2);
+	if (oLexer.eof() ||!(oType = fSequenceType_parse(oLexer, oStaticContext)))
+		throw new cException("XPST0003"
+
+		);
+
+	return new cTreatExpr(oExpr, oType);
+};
+
+cTreatExpr.prototype.evaluate	= function(oContext) {
+	var oSequence1	= this.expression.evaluate(oContext),
+		oItemType	= this.type.itemType,
+		sOccurence	= this.type.occurence;
+	// Validate empty-sequence()
+	if (!oItemType) {
+		if (oSequence1.length)
+			throw new cException("XPDY0050"
+
+			);
+		return oSequence1;
+	}
+
+	// Validate cardinality
+	if (!(sOccurence == '?' || sOccurence == '*'))
+		if (!oSequence1.length)
+			throw new cException("XPDY0050"
+
+			);
+
+	if (!(sOccurence == '+' || sOccurence == '*'))
+		if (oSequence1.length != 1)
+			throw new cException("XPDY0050"
+
+			);
+
+	// Validate type
+	if (!oItemType.test)	// item()
+		return oSequence1;
+
+	for (var nIndex = 0, nLength = oSequence1.length; nIndex < nLength; nIndex++)
+		if (!oItemType.test.test(oSequence1[nIndex], oContext))
+			throw new cException("XPDY0050"
+
+			);
+
+	//
+	return oSequence1;
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cCastableExpr(oExpr, oType) {
+	this.expression	= oExpr;
+	this.type		= oType;
+};
+
+cCastableExpr.prototype.expression	= null;
+cCastableExpr.prototype.type		= null;
+
+function fCastableExpr_parse (oLexer, oStaticContext) {
+	var oExpr,
+		oType;
+	if (oLexer.eof() ||!(oExpr = fCastExpr_parse(oLexer, oStaticContext)))
+		return;
+
+	if (!(oLexer.peek() == "castable" && oLexer.peek(1) == "as"))
+		return oExpr;
+
+	oLexer.next(2);
+	if (oLexer.eof() ||!(oType = fSingleType_parse(oLexer, oStaticContext)))
+		throw new cException("XPST0003"
+
+		);
+
+	return new cCastableExpr(oExpr, oType);
+};
+
+cCastableExpr.prototype.evaluate	= function(oContext) {
+	var oSequence1	= this.expression.evaluate(oContext),
+		oItemType	= this.type.itemType,
+		sOccurence	= this.type.occurence;
+
+	if (oSequence1.length > 1)
+		return [new cXSBoolean(false)];
+	else
+	if (!oSequence1.length)
+		return [new cXSBoolean(sOccurence == '?')];
+
+	// Try casting
+	try {
+		oItemType.cast(fFunction_sequence_atomize(oSequence1, oContext)[0]);
+	}
+	catch (e) {
+		if (e.code == "XPST0051")
+			throw e;
+		if (e.code == "XPST0017")
+			throw new cException("XPST0080"
+
+			);
+		//
+		return [new cXSBoolean(false)];
+	}
+
+	return [new cXSBoolean(true)];
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cCastExpr(oExpr, oType) {
+	this.expression	= oExpr;
+	this.type		= oType;
+};
+
+cCastExpr.prototype.expression	= null;
+cCastExpr.prototype.type		= null;
+
+function fCastExpr_parse (oLexer, oStaticContext) {
+	var oExpr,
+		oType;
+	if (oLexer.eof() ||!(oExpr = fUnaryExpr_parse(oLexer, oStaticContext)))
+		return;
+
+	if (!(oLexer.peek() == "cast" && oLexer.peek(1) == "as"))
+		return oExpr;
+
+	oLexer.next(2);
+	if (oLexer.eof() ||!(oType = fSingleType_parse(oLexer, oStaticContext)))
+		throw new cException("XPST0003"
+
+		);
+
+	return new cCastExpr(oExpr, oType);
+};
+
+cCastExpr.prototype.evaluate	= function(oContext) {
+	var oSequence1	= this.expression.evaluate(oContext);
+	// Validate cardinality
+	fFunctionCall_assertSequenceCardinality(oContext, oSequence1, this.type.occurence
+
+	);
+	//
+	if (!oSequence1.length)
+		return [];
+	//
+	return [this.type.itemType.cast(fFunction_sequence_atomize(oSequence1, oContext)[0], oContext)];
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cAtomicType(sPrefix, sLocalName, sNameSpaceURI) {
+	this.prefix			= sPrefix;
+	this.localName		= sLocalName;
+	this.namespaceURI	= sNameSpaceURI;
+};
+
+cAtomicType.prototype.prefix		= null;
+cAtomicType.prototype.localName		= null;
+cAtomicType.prototype.namespaceURI	= null;
+
+function fAtomicType_parse (oLexer, oStaticContext) {
+	var aMatch	= oLexer.peek().match(rNameTest);
+	if (aMatch) {
+		if (aMatch[1] == '*' || aMatch[2] == '*')
+			throw new cException("XPST0003"
+
+			);
+		oLexer.next();
+		return new cAtomicType(aMatch[1] || null, aMatch[2], aMatch[1] ? oStaticContext.getURIForPrefix(aMatch[1]) : null);
+	}
+};
+
+cAtomicType.prototype.test	= function(vItem, oContext) {
+	// Test
+	var sUri	= (this.namespaceURI ? '{' + this.namespaceURI + '}' : '') + this.localName,
+		cType	= this.namespaceURI == sNS_XSD ? hStaticContext_dataTypes[this.localName] : oContext.staticContext.getDataType(sUri);
+	if (cType)
+		return vItem instanceof cType;
+	//
+	throw new cException("XPST0051"
+
+	);
+};
+
+cAtomicType.prototype.cast	= function(vItem, oContext) {
+	// Cast
+	var sUri	= (this.namespaceURI ? '{' + this.namespaceURI + '}' : '') + this.localName,
+		cType	= this.namespaceURI == sNS_XSD ? hStaticContext_dataTypes[this.localName] : oContext.staticContext.getDataType(sUri);
+	if (cType)
+		return cType.cast(vItem);
+	//
+	throw new cException("XPST0051"
+
+	);
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cItemType(oTest) {
+	this.test	= oTest;
+};
+
+cItemType.prototype.test	= null;
+
+function fItemType_parse (oLexer, oStaticContext) {
+	if (oLexer.eof())
+		return;
+
+	var oExpr;
+	if (oLexer.peek() == "item" && oLexer.peek(1) == '(') {
+		oLexer.next(2);
+		if (oLexer.peek() != ')')
+			throw new cException("XPST0003"
+
+			);
+		oLexer.next();
+		return new cItemType;
+	}
+	// Note! Following step should have been before previous as per spec
+	if (oExpr = fKindTest_parse(oLexer, oStaticContext))
+		return new cItemType(oExpr);
+	if (oExpr = fAtomicType_parse(oLexer, oStaticContext))
+		return new cItemType(oExpr);
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cSequenceType(oItemType, sOccurence) {
+	this.itemType	= oItemType	|| null;
+	this.occurence	= sOccurence|| null;
+};
+
+cSequenceType.prototype.itemType	= null;
+cSequenceType.prototype.occurence	= null;
+
+function fSequenceType_parse (oLexer, oStaticContext) {
+	if (oLexer.eof())
+		return;
+
+	if (oLexer.peek() == "empty-sequence" && oLexer.peek(1) == '(') {
+		oLexer.next(2);
+		if (oLexer.peek() != ')')
+			throw new cException("XPST0003"
+
+			);
+		oLexer.next();
+		return new cSequenceType;	// empty sequence
+	}
+
+	var oExpr,
+		sOccurence;
+	if (!oLexer.eof() && (oExpr = fItemType_parse(oLexer, oStaticContext))) {
+		sOccurence	= oLexer.peek();
+		if (sOccurence == '?' || sOccurence == '*' || sOccurence == '+')
+			oLexer.next();
+		else
+			sOccurence	= null;
+
+		return new cSequenceType(oExpr, sOccurence);
+	}
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cSingleType(oItemType, sOccurence) {
+	this.itemType	= oItemType	|| null;
+	this.occurence	= sOccurence|| null;
+};
+
+cSingleType.prototype.itemType	= null;
+cSingleType.prototype.occurence	= null;
+
+function fSingleType_parse (oLexer, oStaticContext) {
+	var oExpr,
+		sOccurence;
+	if (!oLexer.eof() && (oExpr = fAtomicType_parse(oLexer, oStaticContext))) {
+		sOccurence	= oLexer.peek();
+		if (sOccurence == '?')
+			oLexer.next();
+		else
+			sOccurence	= null;
+
+		return new cSingleType(oExpr, sOccurence);
+	}
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSAnyType() {
+
+};
+
+cXSAnyType.prototype.builtInKind	= cXSConstants.ANYTYPE_DT;
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSAnySimpleType() {
+
+};
+
+cXSAnySimpleType.prototype	= new cXSAnyType;
+
+cXSAnySimpleType.prototype.builtInKind	= cXSConstants.ANYSIMPLETYPE_DT;
+cXSAnySimpleType.prototype.primitiveKind= null;
+
+cXSAnySimpleType.PRIMITIVE_ANYURI		= "anyURI";		//18;
+cXSAnySimpleType.PRIMITIVE_BASE64BINARY	= "base64Binary";	// 17;
+cXSAnySimpleType.PRIMITIVE_BOOLEAN		= "boolean";	// 3;
+cXSAnySimpleType.PRIMITIVE_DATE			= "date";		// 10;
+cXSAnySimpleType.PRIMITIVE_DATETIME		= "dateTime";	// 8;
+cXSAnySimpleType.PRIMITIVE_DECIMAL		= "decimal";	// 4;
+cXSAnySimpleType.PRIMITIVE_DOUBLE		= "double";		// 6;
+cXSAnySimpleType.PRIMITIVE_DURATION		= "duration";	// 7;
+cXSAnySimpleType.PRIMITIVE_FLOAT		= "float";		// 5;
+cXSAnySimpleType.PRIMITIVE_GDAY			= "gDay";		// 14;
+cXSAnySimpleType.PRIMITIVE_GMONTH		= "gMonth";		// 15;
+cXSAnySimpleType.PRIMITIVE_GMONTHDAY	= "gMonthDay";	// 13;
+cXSAnySimpleType.PRIMITIVE_GYEAR		= "gYear";		// 12;
+cXSAnySimpleType.PRIMITIVE_GYEARMONTH	= "gYearMonth";	// 11;
+cXSAnySimpleType.PRIMITIVE_HEXBINARY	= "hexBinary";	// 16;
+cXSAnySimpleType.PRIMITIVE_NOTATION		= "NOTATION";	// 20;
+cXSAnySimpleType.PRIMITIVE_QNAME		= "QName";		// 19;
+cXSAnySimpleType.PRIMITIVE_STRING		= "string";		// 2;
+cXSAnySimpleType.PRIMITIVE_TIME			= "time";		// 9;
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSAnyAtomicType() {
+
+};
+
+cXSAnyAtomicType.prototype	= new cXSAnySimpleType;
+cXSAnyAtomicType.prototype.builtInKind	= cXSConstants.ANYATOMICTYPE_DT;
+
+cXSAnyAtomicType.cast	= function(vValue) {
+	throw new cException("XPST0017"
+
+	);	//  {http://www.w3.org/2001/XMLSchema}anyAtomicType
+};
+
+function fXSAnyAtomicType_isNumeric(vItem) {
+	return vItem instanceof cXSFloat || vItem instanceof cXSDouble || vItem instanceof cXSDecimal;
+};
+
+//
+fStaticContext_defineSystemDataType("anyAtomicType",	cXSAnyAtomicType);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSAnyURI(sScheme, sAuthority, sPath, sQuery, sFragment) {
+	this.scheme		= sScheme;
+	this.authority	= sAuthority;
+	this.path		= sPath;
+	this.query		= sQuery;
+	this.fragment	= sFragment;
+};
+
+cXSAnyURI.prototype	= new cXSAnyAtomicType;
+cXSAnyURI.prototype.builtInKind		= cXSConstants.ANYURI_DT;
+cXSAnyURI.prototype.primitiveKind	= cXSAnySimpleType.PRIMITIVE_ANYURI;
+
+cXSAnyURI.prototype.scheme		= null;
+cXSAnyURI.prototype.authority	= null;
+cXSAnyURI.prototype.path		= null;
+cXSAnyURI.prototype.query		= null;
+cXSAnyURI.prototype.fragment	= null;
+
+cXSAnyURI.prototype.toString	= function() {
+	return (this.scheme ? this.scheme + ':' : '')
+			+ (this.authority ? '/' + '/' + this.authority : '')
+			+ (this.path ? this.path : '')
+			+ (this.query ? '?' + this.query : '')
+			+ (this.fragment ? '#' + this.fragment : '');
+};
+
+var rXSAnyURI	= /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;	// http://tools.ietf.org/html/rfc3986
+cXSAnyURI.cast	= function(vValue) {
+	if (vValue instanceof cXSAnyURI)
+		return vValue;
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch;
+		if (aMatch = fString_trim(vValue).match(rXSAnyURI))
+			return new cXSAnyURI(aMatch[2], aMatch[4], aMatch[5], aMatch[7], aMatch[9]);
+		throw new cException("FORG0001");
+	}
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+//
+fStaticContext_defineSystemDataType("anyURI",	cXSAnyURI);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSBase64Binary(sValue) {
+	this.value	= sValue;
+};
+
+cXSBase64Binary.prototype	= new cXSAnyAtomicType;
+cXSBase64Binary.prototype.builtInKind	= cXSConstants.BASE64BINARY_DT;
+cXSBase64Binary.prototype.primitiveKind	= cXSAnySimpleType.PRIMITIVE_BASE64BINARY;
+
+cXSBase64Binary.prototype.value	= null;
+
+cXSBase64Binary.prototype.valueOf	= function() {
+	return this.value;
+};
+
+cXSBase64Binary.prototype.toString	= function() {
+	return this.value;
+};
+
+var rXSBase64Binary		= /^((([A-Za-z0-9+\/]\s*){4})*(([A-Za-z0-9+\/]\s*){3}[A-Za-z0-9+\/]|([A-Za-z0-9+\/]\s*){2}[AEIMQUYcgkosw048]\s*=|[A-Za-z0-9+\/]\s*[AQgw]\s*=\s*=))?$/;
+cXSBase64Binary.cast	= function(vValue) {
+	if (vValue instanceof cXSBase64Binary)
+		return vValue;
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch	= fString_trim(vValue).match(rXSBase64Binary);
+		if (aMatch)
+			return new cXSBase64Binary(aMatch[0]);
+		throw new cException("FORG0001");
+	}
+	if (vValue instanceof cXSHexBinary) {
+		var aMatch	= vValue.valueOf().match(/.{2}/g),
+			aValue	= [];
+		for (var nIndex = 0, nLength = aMatch.length; nIndex < nLength; nIndex++)
+			aValue.push(cString.fromCharCode(fWindow_parseInt(aMatch[nIndex], 16)));
+		return new cXSBase64Binary(fWindow_btoa(aValue.join('')));
+	}
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+//
+fStaticContext_defineSystemDataType("base64Binary",	cXSBase64Binary);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSBoolean(bValue) {
+	this.value	= bValue;
+};
+
+cXSBoolean.prototype	= new cXSAnyAtomicType;
+cXSBoolean.prototype.builtInKind	= cXSConstants.BOOLEAN_DT;
+cXSBoolean.prototype.primitiveKind	= cXSAnySimpleType.PRIMITIVE_BOOLEAN;
+
+cXSBoolean.prototype.value	= null;
+
+cXSBoolean.prototype.valueOf	= function() {
+	return this.value;
+};
+
+cXSBoolean.prototype.toString	= function() {
+	return cString(this.value);
+};
+
+var rXSBoolean	= /^(0|1|true|false)$/;
+cXSBoolean.cast	= function(vValue) {
+	if (vValue instanceof cXSBoolean)
+		return vValue;
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch;
+		if (aMatch = fString_trim(vValue).match(rXSBoolean))
+			return new cXSBoolean(aMatch[1] == '1' || aMatch[1] == "true");
+		throw new cException("FORG0001");
+	}
+	if (fXSAnyAtomicType_isNumeric(vValue))
+		return new cXSBoolean(vValue != 0);
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+//
+fStaticContext_defineSystemDataType("boolean",	cXSBoolean);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSDate(nYear, nMonth, nDay, nTimezone, bNegative) {
+	this.year		= nYear;
+	this.month		= nMonth;
+	this.day		= nDay;
+	this.timezone	= nTimezone;
+	this.negative	= bNegative;
+};
+
+cXSDate.prototype	= new cXSAnyAtomicType;
+cXSDate.prototype.builtInKind	= cXSConstants.DATE_DT;
+cXSDate.prototype.primitiveKind	= cXSAnySimpleType.PRIMITIVE_DATE;
+
+cXSDate.prototype.year		= null;
+cXSDate.prototype.month		= null;
+cXSDate.prototype.day		= null;
+cXSDate.prototype.timezone	= null;
+cXSDate.prototype.negative	= null;
+
+cXSDate.prototype.toString	= function() {
+	return fXSDateTime_getDateComponent(this)
+			+ fXSDateTime_getTZComponent(this);
+};
+
+var rXSDate		= /^(-?)([1-9]\d\d\d+|0\d\d\d)-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])(Z|([+\-])(0\d|1[0-4]):([0-5]\d))?$/;
+cXSDate.cast	= function(vValue) {
+	if (vValue instanceof cXSDate)
+		return vValue;
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch	= fString_trim(vValue).match(rXSDate);
+		if (aMatch) {
+			var nYear	= +aMatch[2],
+				nMonth	= +aMatch[3],
+				nDay	= +aMatch[4];
+			if (nDay - 1 < fXSDate_getDaysForYearMonth(nYear, nMonth))
+				return new cXSDate( nYear,
+									nMonth,
+									nDay,
+									aMatch[5] ? aMatch[5] == 'Z' ? 0 : (aMatch[6] == '-' ? -1 : 1) * (aMatch[7] * 60 + aMatch[8] * 1) : null,
+									aMatch[1] == '-'
+				);
+			//
+			throw new cException("FORG0001"
+
+			);
+		}
+		throw new cException("FORG0001");
+	}
+	if (vValue instanceof cXSDateTime)
+		return new cXSDate(vValue.year, vValue.month, vValue.day, vValue.timezone, vValue.negative);
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+// Utilities
+var aXSDate_days	= [31,28,31,30,31,30,31,31,30,31,30,31];
+function fXSDate_getDaysForYearMonth(nYear, nMonth) {
+	return nMonth == 2 && (nYear % 400 == 0 || nYear % 100 != 0 && nYear % 4 == 0) ? 29 : aXSDate_days[nMonth - 1];
+};
+
+function fXSDate_normalize(oValue, bDay) {
+	// Adjust day for month/year
+	if (!bDay) {
+		var nDay	= fXSDate_getDaysForYearMonth(oValue.year, oValue.month);
+		if (oValue.day > nDay) {
+			while (oValue.day > nDay) {
+				oValue.month	+= 1;
+				if (oValue.month > 12) {
+					oValue.year		+= 1;
+					if (oValue.year == 0)
+						oValue.year	= 1;
+					oValue.month	= 1;
+				}
+				oValue.day	-= nDay;
+				nDay = fXSDate_getDaysForYearMonth(oValue.year, oValue.month);
+			}
+		}
+		else
+		if (oValue.day < 1) {
+			while (oValue.day < 1) {
+				oValue.month	-= 1;
+				if (oValue.month < 1) {
+					oValue.year		-= 1;
+					if (oValue.year == 0)
+						oValue.year	=-1;
+					oValue.month	= 12;
+				}
+				nDay = fXSDate_getDaysForYearMonth(oValue.year, oValue.month);
+				oValue.day	+= nDay;
+			}
+		}
+	}
+//?	else
+	// Adjust month
+	if (oValue.month > 12) {
+		oValue.year		+= ~~(oValue.month / 12);
+		if (oValue.year == 0)
+			oValue.year	= 1;
+		oValue.month	= oValue.month % 12;
+	}
+	else
+	if (oValue.month < 1) {
+		oValue.year		+= ~~(oValue.month / 12) - 1;
+		if (oValue.year == 0)
+			oValue.year	=-1;
+		oValue.month	= oValue.month % 12 + 12;
+	}
+
+	return oValue;
+};
+
+//
+fStaticContext_defineSystemDataType("date",	cXSDate);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSDateTime(nYear, nMonth, nDay, nHours, nMinutes, nSeconds, nTimezone, bNegative) {
+	this.year	= nYear;
+	this.month	= nMonth;
+	this.day	= nDay;
+	this.hours	= nHours;
+	this.minutes	= nMinutes;
+	this.seconds	= nSeconds;
+	this.timezone	= nTimezone;
+	this.negative	= bNegative;
+};
+
+cXSDateTime.prototype	= new cXSAnyAtomicType;
+cXSDateTime.prototype.builtInKind	= cXSConstants.DATETIME_DT;
+cXSDateTime.prototype.primitiveKind	= cXSAnySimpleType.PRIMITIVE_DATETIME;
+
+cXSDateTime.prototype.year		= null;
+cXSDateTime.prototype.month		= null;
+cXSDateTime.prototype.day		= null;
+cXSDateTime.prototype.hours		= null;
+cXSDateTime.prototype.minutes	= null;
+cXSDateTime.prototype.seconds	= null;
+cXSDateTime.prototype.timezone	= null;
+cXSDateTime.prototype.negative	= null;
+
+cXSDateTime.prototype.toString	= function() {
+	return fXSDateTime_getDateComponent(this)
+			+ 'T'
+			+ fXSDateTime_getTimeComponent(this)
+			+ fXSDateTime_getTZComponent(this);
+};
+
+var rXSDateTime		= /^(-?)([1-9]\d\d\d+|0\d\d\d)-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])T(([01]\d|2[0-3]):([0-5]\d):([0-5]\d)(?:\.(\d+))?|(24:00:00)(?:\.(0+))?)(Z|([+\-])(0\d|1[0-4]):([0-5]\d))?$/;
+cXSDateTime.cast	= function(vValue) {
+	if (vValue instanceof cXSDateTime)
+		return vValue;
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch	= fString_trim(vValue).match(rXSDateTime);
+		if (aMatch) {
+			var nYear	= +aMatch[2],
+				nMonth	= +aMatch[3],
+				nDay	= +aMatch[4],
+				bValue	= !!aMatch[10];
+			if (nDay - 1 < fXSDate_getDaysForYearMonth(nYear, nMonth))
+				return fXSDateTime_normalize(new cXSDateTime( nYear,
+										nMonth,
+										nDay,
+										bValue ? 24 : +aMatch[6],
+										bValue ? 0 : +aMatch[7],
+										cNumber((bValue ? 0 : aMatch[8]) + '.' + (bValue ? 0 : aMatch[9] || 0)),
+										aMatch[12] ? aMatch[12] == 'Z' ? 0 : (aMatch[13] == '-' ? -1 : 1) * (aMatch[14] * 60 + aMatch[15] * 1) : null,
+										aMatch[1] == '-'
+				));
+			//
+			throw new cException("FORG0001"
+
+			);
+		}
+		throw new cException("FORG0001");
+	}
+	if (vValue instanceof cXSDate)
+		return new cXSDateTime(vValue.year, vValue.month, vValue.day, 0, 0, 0, vValue.timezone, vValue.negative);
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+// Utilities
+function fXSDateTime_pad(vValue, nLength) {
+	var sValue	= cString(vValue);
+	if (arguments.length < 2)
+		nLength	= 2;
+	return (sValue.length < nLength + 1 ? new cArray(nLength + 1 - sValue.length).join('0') : '') + sValue;
+};
+
+function fXSDateTime_getTZComponent(oDateTime) {
+	var nTimezone	= oDateTime.timezone;
+	return nTimezone == null
+			? ''
+			: nTimezone
+				? (nTimezone > 0 ? '+' : '-')
+					+ fXSDateTime_pad(cMath.abs(~~(nTimezone / 60)))
+					+ ':'
+					+ fXSDateTime_pad(cMath.abs(nTimezone % 60))
+				: 'Z';
+};
+
+function fXSDateTime_getDateComponent(oDateTime) {
+	return (oDateTime.negative ? '-' : '')
+			+ fXSDateTime_pad(oDateTime.year, 4)
+			+ '-' + fXSDateTime_pad(oDateTime.month)
+			+ '-' + fXSDateTime_pad(oDateTime.day);
+};
+
+function fXSDateTime_getTimeComponent(oDateTime) {
+	var aValue	= cString(oDateTime.seconds).split('.');
+	return fXSDateTime_pad(oDateTime.hours)
+			+ ':' + fXSDateTime_pad(oDateTime.minutes)
+			+ ':' + fXSDateTime_pad(aValue[0])
+			+ (aValue.length > 1 ? '.' + aValue[1] : '');
+};
+
+function fXSDateTime_normalize(oValue) {
+	return fXSDate_normalize(fXSTime_normalize(oValue));
+};
+
+//
+fStaticContext_defineSystemDataType("dateTime",	cXSDateTime);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSDecimal(nValue) {
+	this.value	= nValue;
+};
+
+cXSDecimal.prototype	= new cXSAnyAtomicType;
+cXSDecimal.prototype.builtInKind	= cXSConstants.DECIMAL_DT;
+cXSDecimal.prototype.primitiveKind	= cXSAnySimpleType.PRIMITIVE_DECIMAL;
+
+cXSDecimal.prototype.value	= null;
+
+cXSDecimal.prototype.valueOf	= function() {
+	return this.value;
+};
+
+cXSDecimal.prototype.toString	= function() {
+	return cString(this.value);
+};
+
+var rXSDecimal	= /^[+\-]?((\d+(\.\d*)?)|(\.\d+))$/;
+cXSDecimal.cast	= function(vValue) {
+	if (vValue instanceof cXSDecimal)
+		return vValue;
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch	= fString_trim(vValue).match(rXSDecimal);
+		if (aMatch)
+			return new cXSDecimal(+vValue);
+		throw new cException("FORG0001");
+	}
+	if (vValue instanceof cXSBoolean)
+		return new cXSDecimal(vValue * 1);
+	if (fXSAnyAtomicType_isNumeric(vValue)) {
+		if (!fIsNaN(vValue) && fIsFinite(vValue))
+			return new cXSDecimal(+vValue);
+		throw new cException("FOCA0002"
+
+		);
+	}
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+//
+fStaticContext_defineSystemDataType("decimal",	cXSDecimal);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSDouble(nValue) {
+	this.value	= nValue;
+};
+
+cXSDouble.prototype	= new cXSAnyAtomicType;
+cXSDouble.prototype.builtInKind		= cXSConstants.DOUBLE_DT;
+cXSDouble.prototype.primitiveKind	= cXSAnySimpleType.PRIMITIVE_DOUBLE;
+
+cXSDouble.prototype.value	= null;
+
+cXSDouble.prototype.valueOf	= function() {
+	return this.value;
+};
+
+cXSDouble.prototype.toString	= function() {
+	return cString(this.value);
+};
+
+var rXSDouble	= /^([+\-]?((\d+(\.\d*)?)|(\.\d+))([eE][+\-]?\d+)?|(-?INF)|NaN)$/;
+cXSDouble.cast	= function(vValue) {
+	if (vValue instanceof cXSDouble)
+		return vValue;
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch	= fString_trim(vValue).match(rXSDouble);
+		if (aMatch)
+			return new cXSDouble(aMatch[7] ? +aMatch[7].replace("INF", "Infinity") : +vValue);
+		throw new cException("FORG0001");
+	}
+	if (vValue instanceof cXSBoolean)
+		return new cXSDouble(vValue * 1);
+	if (fXSAnyAtomicType_isNumeric(vValue))
+		return new cXSDouble(vValue.value);
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+//
+fStaticContext_defineSystemDataType("double",	cXSDouble);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSDuration(nYear, nMonth, nDay, nHours, nMinutes, nSeconds, bNegative) {
+	this.year	= nYear;
+	this.month	= nMonth;
+	this.day	= nDay;
+	this.hours	= nHours;
+	this.minutes	= nMinutes;
+	this.seconds	= nSeconds;
+	this.negative	= bNegative;
+};
+
+cXSDuration.prototype	= new cXSAnyAtomicType;
+cXSDuration.prototype.builtInKind	= cXSConstants.DURATION_DT;
+cXSDuration.prototype.primitiveKind	= cXSAnySimpleType.PRIMITIVE_DURATION;
+
+cXSDuration.prototype.year		= null;
+cXSDuration.prototype.month		= null;
+cXSDuration.prototype.day		= null;
+cXSDuration.prototype.hours		= null;
+cXSDuration.prototype.minutes	= null;
+cXSDuration.prototype.seconds	= null;
+cXSDuration.prototype.negative	= null;
+
+cXSDuration.prototype.toString	= function() {
+	return (this.negative ? '-' : '') + 'P'
+			+ ((fXSDuration_getYearMonthComponent(this) + fXSDuration_getDayTimeComponent(this)) || 'T0S');
+};
+
+var rXSDuration		= /^(-)?P(?:([0-9]+)Y)?(?:([0-9]+)M)?(?:([0-9]+)D)?(?:T(?:([0-9]+)H)?(?:([0-9]+)M)?(?:((?:(?:[0-9]+(?:.[0-9]*)?)|(?:.[0-9]+)))S)?)?$/;
+cXSDuration.cast	= function(vValue) {
+	if (vValue instanceof cXSDuration)
+		return vValue;
+	if (vValue instanceof cXSYearMonthDuration)
+		return new cXSDuration(vValue.year, vValue.month, 0, 0, 0, 0, vValue.negative);
+	if (vValue instanceof cXSDayTimeDuration)
+		return new cXSDuration(0, 0, vValue.day, vValue.hours, vValue.minutes, vValue.seconds, vValue.negative);
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch	= fString_trim(vValue).match(rXSDuration);
+		if (aMatch)
+			return fXSDuration_normalize(new cXSDuration(+aMatch[2] || 0, +aMatch[3] || 0, +aMatch[4] || 0, +aMatch[5] || 0, +aMatch[6] || 0, +aMatch[7] || 0, aMatch[1] == '-'));
+		throw new cException("FORG0001");
+	}
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+// Utilities
+function fXSDuration_getYearMonthComponent(oDuration) {
+	return (oDuration.year ? oDuration.year + 'Y' : '')
+			+ (oDuration.month ? oDuration.month + 'M' : '');
+};
+
+function fXSDuration_getDayTimeComponent(oDuration) {
+	return (oDuration.day ? oDuration.day + 'D' : '')
+			+ (oDuration.hours || oDuration.minutes || oDuration.seconds
+				? 'T'
+					+ (oDuration.hours ? oDuration.hours + 'H' : '')
+					+ (oDuration.minutes ? oDuration.minutes + 'M' : '')
+					+ (oDuration.seconds ? oDuration.seconds + 'S' : '')
+				: '');
+};
+
+function fXSDuration_normalize(oDuration) {
+	return fXSYearMonthDuration_normalize(fXSDayTimeDuration_normalize(oDuration));
+};
+
+//
+fStaticContext_defineSystemDataType("duration",	cXSDuration);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSFloat(nValue) {
+	this.value	= nValue;
+};
+
+cXSFloat.prototype	= new cXSAnyAtomicType;
+cXSFloat.prototype.builtInKind		= cXSConstants.FLOAT_DT;
+cXSFloat.prototype.primitiveKind	= cXSAnySimpleType.PRIMITIVE_FLOAT;
+
+cXSFloat.prototype.value	= null;
+
+cXSFloat.prototype.valueOf	= function() {
+	return this.value;
+};
+
+cXSFloat.prototype.toString	= function() {
+	return cString(this.value);
+};
+
+var rXSFloat	= /^([+\-]?((\d+(\.\d*)?)|(\.\d+))([eE][+\-]?\d+)?|(-?INF)|NaN)$/;
+cXSFloat.cast	= function(vValue) {
+	if (vValue instanceof cXSFloat)
+		return vValue;
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch	= fString_trim(vValue).match(rXSFloat);
+		if (aMatch)
+			return new cXSFloat(aMatch[7] ? +aMatch[7].replace("INF", "Infinity") : +vValue);
+		throw new cException("FORG0001");
+	}
+	if (vValue instanceof cXSBoolean)
+		return new cXSFloat(vValue * 1);
+	if (fXSAnyAtomicType_isNumeric(vValue))
+		return new cXSFloat(vValue.value);
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+//
+fStaticContext_defineSystemDataType("float",	cXSFloat);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSGDay(nDay, nTimezone) {
+	this.day		= nDay;
+	this.timezone	= nTimezone;
+};
+
+cXSGDay.prototype	= new cXSAnyAtomicType;
+cXSGDay.prototype.builtInKind	= cXSConstants.GDAY_DT;
+cXSGDay.prototype.primitiveKind	= cXSAnySimpleType.PRIMITIVE_GDAY;
+
+cXSGDay.prototype.day		= null;
+cXSGDay.prototype.timezone	= null;
+
+cXSGDay.prototype.toString	= function() {
+	return '-'
+			+ '-'
+			+ '-' + fXSDateTime_pad(this.day)
+			+ fXSDateTime_getTZComponent(this);
+};
+
+var rXSGDay		= /^---(0[1-9]|[12]\d|3[01])(Z|([+\-])(0\d|1[0-4]):([0-5]\d))?$/;
+cXSGDay.cast	= function(vValue) {
+	if (vValue instanceof cXSGDay)
+		return vValue;
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch	= fString_trim(vValue).match(rXSGDay);
+		if (aMatch) {
+			var nDay	= +aMatch[1];
+			return new cXSGDay(	nDay,
+								aMatch[2] ? aMatch[2] == 'Z' ? 0 : (aMatch[3] == '-' ? -1 : 1) * (aMatch[4] * 60 + aMatch[5] * 1) : null
+			);
+		}
+		throw new cException("FORG0001");
+	}
+	if (vValue instanceof cXSDate || vValue instanceof cXSDateTime)
+		return new cXSGDay(vValue.day, vValue.timezone);
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+//
+fStaticContext_defineSystemDataType("gDay",	cXSGDay);
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSGMonth(nMonth, nTimezone) {
+	this.month		= nMonth;
+	this.timezone	= nTimezone;
+};
+
+cXSGMonth.prototype	= new cXSAnyAtomicType;
+cXSGMonth.prototype.builtInKind		= cXSConstants.GMONTH_DT;
+cXSGMonth.prototype.primitiveKind	= cXSAnySimpleType.PRIMITIVE_GMONTH;
+
+cXSGMonth.prototype.month		= null;
+cXSGMonth.prototype.timezone	= null;
+
+cXSGMonth.prototype.toString	= function() {
+	return '-'
+			+ '-' + fXSDateTime_pad(this.month)
+			+ fXSDateTime_getTZComponent(this);
+};
+
+var rXSGMonth	= /^--(0[1-9]|1[0-2])(Z|([+\-])(0\d|1[0-4]):([0-5]\d))?$/;
+cXSGMonth.cast	= function(vValue) {
+	if (vValue instanceof cXSGMonth)
+		return vValue;
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch	= fString_trim(vValue).match(rXSGMonth);
+		if (aMatch) {
+			var nMonth	= +aMatch[1];
+			return new cXSGMonth(	nMonth,
+									aMatch[2] ? aMatch[2] == 'Z' ? 0 : (aMatch[3] == '-' ? -1 : 1) * (aMatch[4] * 60 + aMatch[5] * 1) : null
+			);
+		}
+		throw new cException("FORG0001");
+	}
+	if (vValue instanceof cXSDate || vValue instanceof cXSDateTime)
+		return new cXSGMonth(vValue.month, vValue.timezone);
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+//
+fStaticContext_defineSystemDataType("gMonth",	cXSGMonth);
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSGMonthDay(nMonth, nDay, nTimezone) {
+	this.month		= nMonth;
+	this.day		= nDay;
+	this.timezone	= nTimezone;
+};
+
+cXSGMonthDay.prototype	= new cXSAnyAtomicType;
+cXSGMonthDay.prototype.builtInKind		= cXSConstants.GMONTHDAY_DT;
+cXSGMonthDay.prototype.primitiveKind	= cXSAnySimpleType.PRIMITIVE_GMONTHDAY;
+
+cXSGMonthDay.prototype.month	= null;
+cXSGMonthDay.prototype.day		= null;
+cXSGMonthDay.prototype.timezone	= null;
+
+cXSGMonthDay.prototype.toString	= function() {
+	return '-'
+			+ '-' + fXSDateTime_pad(this.month)
+			+ '-' + fXSDateTime_pad(this.day)
+			+ fXSDateTime_getTZComponent(this);
+};
+
+var rXSGMonthDay	= /^--(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])(Z|([+\-])(0\d|1[0-4]):([0-5]\d))?$/;
+cXSGMonthDay.cast	= function(vValue) {
+	if (vValue instanceof cXSGMonthDay)
+		return vValue;
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch	= fString_trim(vValue).match(rXSGMonthDay);
+		if (aMatch) {
+			var nMonth	= +aMatch[1],
+				nDay	= +aMatch[2];
+			if (nDay - 1 < fXSDate_getDaysForYearMonth(1976, nMonth))
+				return new cXSGMonthDay(	nMonth,
+											nDay,
+											aMatch[3] ? aMatch[3] == 'Z' ? 0 : (aMatch[4] == '-' ? -1 : 1) * (aMatch[5] * 60 + aMatch[6] * 1) : null
+				);
+			//
+			throw new cException("FORG0001"
+
+			);
+		}
+		throw new cException("FORG0001");
+	}
+	if (vValue instanceof cXSDate || vValue instanceof cXSDateTime)
+		return new cXSGMonthDay(vValue.month, vValue.day, vValue.timezone);
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+//
+fStaticContext_defineSystemDataType("gMonthDay",	cXSGMonthDay);
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSGYear(nYear, nTimezone) {
+	this.year	= nYear;
+	this.timezone	= nTimezone;
+};
+
+cXSGYear.prototype	= new cXSAnyAtomicType;
+cXSGYear.prototype.builtInKind		= cXSConstants.GYEAR_DT;
+cXSGYear.prototype.primitiveKind	= cXSAnySimpleType.PRIMITIVE_GYEAR;
+
+cXSGYear.prototype.year		= null;
+cXSGYear.prototype.timezone	= null;
+
+cXSGYear.prototype.toString	= function() {
+	return fXSDateTime_pad(this.year)
+			+ fXSDateTime_getTZComponent(this);
+};
+
+var rXSGYear		= /^-?([1-9]\d\d\d+|0\d\d\d)(Z|([+\-])(0\d|1[0-4]):([0-5]\d))?$/;
+cXSGYear.cast	= function(vValue) {
+	if (vValue instanceof cXSGYear)
+		return vValue;
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch	= fString_trim(vValue).match(rXSGYear);
+		if (aMatch) {
+			var nYear	= +aMatch[1];
+			return new cXSGYear(	nYear,
+									aMatch[2] ? aMatch[2] == 'Z' ? 0 : (aMatch[3] == '-' ? -1 : 1) * (aMatch[4] * 60 + aMatch[5] * 1) : null
+			);
+		}
+		throw new cException("FORG0001");
+	}
+	if (vValue instanceof cXSDate || vValue instanceof cXSDateTime)
+		return new cXSGYear(vValue.year, vValue.timezone);
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+//
+fStaticContext_defineSystemDataType("gYear",	cXSGYear);
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSGYearMonth(nYear, nMonth, nTimezone) {
+	this.year		= nYear;
+	this.month		= nMonth;
+	this.timezone	= nTimezone;
+};
+
+cXSGYearMonth.prototype	= new cXSAnyAtomicType;
+cXSGYearMonth.prototype.builtInKind		= cXSConstants.GYEARMONTH_DT;
+cXSGYearMonth.prototype.primitiveKind	= cXSAnySimpleType.PRIMITIVE_GYEARMONTH;
+
+cXSGYearMonth.prototype.year	= null;
+cXSGYearMonth.prototype.month	= null;
+cXSGYearMonth.prototype.timezone= null;
+
+cXSGYearMonth.prototype.toString	= function() {
+	return fXSDateTime_pad(this.year)
+			+ '-' + fXSDateTime_pad(this.month)
+			+ fXSDateTime_getTZComponent(this);
+};
+
+var rXSGYearMonth	= /^-?([1-9]\d\d\d+|0\d\d\d)-(0[1-9]|1[0-2])(Z|([+\-])(0\d|1[0-4]):([0-5]\d))?$/;
+cXSGYearMonth.cast	= function(vValue) {
+	if (vValue instanceof cXSGYearMonth)
+		return vValue;
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch	= fString_trim(vValue).match(rXSGYearMonth);
+		if (aMatch) {
+			var nYear	= +aMatch[1],
+				nMonth	= +aMatch[2];
+			return new cXSGYearMonth(	nYear,
+										nMonth,
+										aMatch[3] ? aMatch[3] == 'Z' ? 0 : (aMatch[4] == '-' ? -1 : 1) * (aMatch[5] * 60 + aMatch[6] * 1) : null
+			);
+		}
+		throw new cException("FORG0001");
+	}
+	if (vValue instanceof cXSDate || vValue instanceof cXSDateTime)
+		return new cXSGYearMonth(vValue.year, vValue.month, vValue.timezone);
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+//
+fStaticContext_defineSystemDataType("gYearMonth",	cXSGYearMonth);
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSHexBinary(sValue) {
+	this.value	= sValue;
+};
+
+cXSHexBinary.prototype	= new cXSAnyAtomicType;
+cXSHexBinary.prototype.builtInKind		= cXSConstants.HEXBINARY_DT;
+cXSHexBinary.prototype.primitiveKind	= cXSAnySimpleType.PRIMITIVE_HEXBINARY;
+
+cXSHexBinary.prototype.value	= null;
+
+cXSHexBinary.prototype.valueOf	= function() {
+	return this.value;
+};
+
+cXSHexBinary.prototype.toString	= function() {
+	return this.value;
+};
+
+var rXSHexBinary	= /^([0-9a-fA-F]{2})*$/;
+cXSHexBinary.cast	= function(vValue) {
+	if (vValue instanceof cXSHexBinary)
+		return vValue;
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch	= fString_trim(vValue).match(rXSHexBinary);
+		if (aMatch)
+			return new cXSHexBinary(aMatch[0].toUpperCase());
+		throw new cException("FORG0001");
+	}
+	if (vValue instanceof cXSBase64Binary) {
+		var sValue	= fWindow_atob(vValue.valueOf()),
+			aValue	= [];
+		for (var nIndex = 0, nLength = sValue.length, sLetter; nIndex < nLength; nIndex++) {
+			sLetter = sValue.charCodeAt(nIndex).toString(16);
+			aValue.push(new cArray(3 - sLetter.length).join('0') + sLetter);
+		}
+		return new cXSHexBinary(aValue.join(''));
+	}
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+//
+fStaticContext_defineSystemDataType("hexBinary",	cXSHexBinary);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSNOTATION() {
+
+};
+
+cXSNOTATION.prototype	= new cXSAnyAtomicType;
+cXSNOTATION.prototype.builtInKind	= cXSConstants.NOTATION_DT;
+cXSNOTATION.prototype.primitiveKind	= cXSAnySimpleType.PRIMITIVE_NOTATION;
+
+cXSNOTATION.cast	= function(vValue) {
+	throw new cException("XPST0017"
+
+	);	//  {http://www.w3.org/2001/XMLSchema}NOTATION
+};
+
+//
+fStaticContext_defineSystemDataType("NOTATION",	cXSNOTATION);
+
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSQName(sPrefix, sLocalName, sNameSpaceURI) {
+	this.prefix	= sPrefix;
+	this.localName	= sLocalName;
+	this.namespaceURI	= sNameSpaceURI;
+};
+
+cXSQName.prototype	= new cXSAnyAtomicType;
+cXSQName.prototype.builtInKind		= cXSConstants.QNAME_DT;
+cXSQName.prototype.primitiveKind	= cXSAnySimpleType.PRIMITIVE_QNAME;
+
+cXSQName.prototype.prefix	= null;
+cXSQName.prototype.localName	= null;
+cXSQName.prototype.namespaceURI	= null;
+
+cXSQName.prototype.toString	= function() {
+	return (this.prefix ? this.prefix + ':' : '') + this.localName;
+};
+
+var rXSQName	= /^(?:(?![0-9-])(\w[\w.-]*)\:)?(?![0-9-])(\w[\w.-]*)$/;
+cXSQName.cast	= function(vValue) {
+	if (vValue instanceof cXSQName)
+		return vValue;
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch	= fString_trim(vValue).match(rXSQName);
+		if (aMatch)
+			return new cXSQName(aMatch[1] || null, aMatch[2], null);
+		throw new cException("FORG0001");
+	}
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+//
+fStaticContext_defineSystemDataType("QName",	cXSQName);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSString(sValue) {
+	this.value	= sValue;
+};
+
+cXSString.prototype	= new cXSAnyAtomicType;
+
+cXSString.prototype.value	= null;
+cXSString.prototype.builtInKind		= cXSConstants.STRING_DT;
+cXSString.prototype.primitiveKind	= cXSAnySimpleType.PRIMITIVE_STRING;
+
+cXSString.prototype.valueOf		= function() {
+	return this.value;
+};
+
+cXSString.prototype.toString	= function() {
+	return this.value;
+};
+
+cXSString.cast	= function(vValue) {
+	return new cXSString(cString(vValue));
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+//
+fStaticContext_defineSystemDataType("string",	cXSString);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSTime(nHours, nMinutes, nSeconds, nTimezone) {
+	this.hours	= nHours;
+	this.minutes	= nMinutes;
+	this.seconds	= nSeconds;
+	this.timezone	= nTimezone;
+};
+
+cXSTime.prototype	= new cXSAnyAtomicType;
+cXSTime.prototype.builtInKind	= cXSConstants.TIME_DT;
+cXSTime.prototype.primitiveKind	= cXSAnySimpleType.PRIMITIVE_TIME;
+
+cXSTime.prototype.hours		= null;
+cXSTime.prototype.minutes	= null;
+cXSTime.prototype.seconds	= null;
+cXSTime.prototype.timezone		= null;
+
+cXSTime.prototype.toString	= function() {
+	return fXSDateTime_getTimeComponent(this)
+			+ fXSDateTime_getTZComponent(this);
+};
+
+var rXSTime		= /^(([01]\d|2[0-3]):([0-5]\d):([0-5]\d)(?:\.(\d+))?|(24:00:00)(?:\.(0+))?)(Z|([+\-])(0\d|1[0-4]):([0-5]\d))?$/;
+cXSTime.cast	= function(vValue) {
+	if (vValue instanceof cXSTime)
+		return vValue;
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch	= fString_trim(vValue).match(rXSTime);
+		if (aMatch) {
+			var bValue	= !!aMatch[6];
+			return new cXSTime(bValue ? 0 : +aMatch[2],
+								bValue ? 0 : +aMatch[3],
+								cNumber((bValue ? 0 : aMatch[4]) + '.' + (bValue ? 0 : aMatch[5] || 0)),
+								aMatch[8] ? aMatch[8] == 'Z' ? 0 : (aMatch[9] == '-' ? -1 : 1) * (aMatch[10] * 60 + aMatch[11] * 1) : null
+			);
+		}
+		throw new cException("FORG0001");
+	}
+	if (vValue instanceof cXSDateTime)
+		return new cXSTime(vValue.hours, vValue.minutes, vValue.seconds, vValue.timezone);
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+//
+function fXSTime_normalize(oValue) {
+	//
+	if (oValue.seconds >= 60 || oValue.seconds < 0) {
+		oValue.minutes	+= ~~(oValue.seconds / 60) - (oValue.seconds < 0 && oValue.seconds % 60 ? 1 : 0);
+		oValue.seconds	= oValue.seconds % 60 + (oValue.seconds < 0 && oValue.seconds % 60 ? 60 : 0);
+	}
+	//
+	if (oValue.minutes >= 60 || oValue.minutes < 0) {
+		oValue.hours	+= ~~(oValue.minutes / 60) - (oValue.minutes < 0 && oValue.minutes % 60 ? 1 : 0);
+		oValue.minutes	= oValue.minutes % 60 + (oValue.minutes < 0 && oValue.minutes % 60 ? 60 : 0);
+	}
+	//
+	if (oValue.hours >= 24 || oValue.hours < 0) {
+		if (oValue instanceof cXSDateTime)
+			oValue.day		+= ~~(oValue.hours / 24) - (oValue.hours < 0 && oValue.hours % 24 ? 1 : 0);
+		oValue.hours	= oValue.hours % 24 + (oValue.hours < 0 && oValue.hours % 24 ? 24 : 0);
+	}
+	//
+	return oValue;
+};
+
+//
+fStaticContext_defineSystemDataType("time",	cXSTime);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSUntypedAtomic(sValue) {
+	this.value	= sValue;
+};
+
+cXSUntypedAtomic.prototype	= new cXSAnyAtomicType;
+cXSUntypedAtomic.prototype.builtInKind	= cXSConstants.XT_UNTYPEDATOMIC_DT;
+
+cXSUntypedAtomic.prototype.toString	= function() {
+	return cString(this.value);
+};
+
+cXSUntypedAtomic.cast	= function(vValue) {
+	if (vValue instanceof cXSUntypedAtomic)
+		return vValue;
+
+	return new cXSUntypedAtomic(cString(vValue));
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+//
+fStaticContext_defineSystemDataType("untypedAtomic",	cXSUntypedAtomic);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSYearMonthDuration(nYear, nMonth, bNegative) {
+	cXSDuration.call(this, nYear, nMonth, 0, 0, 0, 0, bNegative);
+};
+
+cXSYearMonthDuration.prototype	= new cXSDuration;
+cXSYearMonthDuration.prototype.builtInKind	= cXSConstants.XT_YEARMONTHDURATION_DT;
+
+cXSYearMonthDuration.prototype.toString	= function() {
+	return (this.negative ? '-' : '') + 'P'
+			+ (fXSDuration_getYearMonthComponent(this) || '0M');
+};
+
+var rXSYearMonthDuration	= /^(-)?P(?:([0-9]+)Y)?(?:([0-9]+)M)?$/;
+cXSYearMonthDuration.cast	= function(vValue) {
+	if (vValue instanceof cXSYearMonthDuration)
+		return vValue;
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch	= fString_trim(vValue).match(rXSYearMonthDuration);
+		if (aMatch)
+			return fXSYearMonthDuration_normalize(new cXSYearMonthDuration(+aMatch[2] || 0, +aMatch[3] || 0, aMatch[1] == '-'));
+		throw new cException("FORG0001");
+	}
+	if (vValue instanceof cXSDayTimeDuration)
+		return new cXSYearMonthDuration(0, 0);
+	if (vValue instanceof cXSDuration)
+		return new cXSYearMonthDuration(vValue.year, vValue.month, vValue.negative);
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+//
+function fXSYearMonthDuration_normalize(oDuration) {
+	if (oDuration.month >= 12) {
+		oDuration.year	+= ~~(oDuration.month / 12);
+		oDuration.month	%= 12;
+	}
+	return oDuration;
+};
+
+//
+fStaticContext_defineSystemDataType("yearMonthDuration",	cXSYearMonthDuration);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSDayTimeDuration(nDay, nHours, nMinutes, nSeconds, bNegative) {
+	cXSDuration.call(this, 0, 0, nDay, nHours, nMinutes, nSeconds, bNegative);
+};
+
+cXSDayTimeDuration.prototype	= new cXSDuration;
+cXSDayTimeDuration.prototype.builtInKind	= cXSConstants.DAYTIMEDURATION_DT;
+
+cXSDayTimeDuration.prototype.toString	= function() {
+	return (this.negative ? '-' : '') + 'P'
+			+ (fXSDuration_getDayTimeComponent(this) || 'T0S');
+};
+
+var rXSDayTimeDuration	= /^(-)?P(?:([0-9]+)D)?(?:T(?:([0-9]+)H)?(?:([0-9]+)M)?(?:((?:(?:[0-9]+(?:.[0-9]*)?)|(?:.[0-9]+)))S)?)?$/;
+cXSDayTimeDuration.cast	= function(vValue) {
+	if (vValue instanceof cXSDayTimeDuration)
+		return vValue;
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch	= fString_trim(vValue).match(rXSDayTimeDuration);
+		if (aMatch)
+			return fXSDayTimeDuration_normalize(new cXSDayTimeDuration(+aMatch[2] || 0, +aMatch[3] || 0, +aMatch[4] || 0, +aMatch[5] || 0, aMatch[1] == '-'));
+		throw new cException("FORG0001");
+	}
+	if (vValue instanceof cXSYearMonthDuration)
+		return new cXSDayTimeDuration(0, 0, 0, 0);
+	if (vValue instanceof cXSDuration)
+		return new cXSDayTimeDuration(vValue.day, vValue.hours, vValue.minutes, vValue.seconds, vValue.negative);
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+// Utilities
+function fXSDayTimeDuration_normalize(oDuration) {
+	if (oDuration.seconds >= 60) {
+		oDuration.minutes	+= ~~(oDuration.seconds / 60);
+		oDuration.seconds	%= 60;
+	}
+	if (oDuration.minutes >= 60) {
+		oDuration.hours		+= ~~(oDuration.minutes / 60);
+		oDuration.minutes	%= 60;
+	}
+	if (oDuration.hours >= 24) {
+		oDuration.day		+= ~~(oDuration.hours / 24);
+		oDuration.hours		%= 24;
+	}
+	return oDuration;
+};
+
+//
+fStaticContext_defineSystemDataType("dayTimeDuration",	cXSDayTimeDuration);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSInteger(nValue) {
+	this.value	= nValue;
+};
+
+cXSInteger.prototype	= new cXSDecimal;
+cXSInteger.prototype.builtInKind	= cXSConstants.INTEGER_DT;
+
+var rXSInteger	= /^[-+]?[0-9]+$/;
+cXSInteger.cast	= function(vValue) {
+	if (vValue instanceof cXSInteger)
+		return new cXSInteger(vValue.value);
+	if (vValue instanceof cXSString || vValue instanceof cXSUntypedAtomic) {
+		var aMatch	= fString_trim(vValue).match(rXSInteger);
+		if (aMatch)
+			return new cXSInteger(+vValue);
+		throw new cException("FORG0001");
+	}
+	if (vValue instanceof cXSBoolean)
+		return new cXSInteger(vValue * 1);
+	if (fXSAnyAtomicType_isNumeric(vValue)) {
+		if (!fIsNaN(vValue) && fIsFinite(vValue))
+			return new cXSInteger(+vValue);
+		throw new cException("FOCA0002"
+
+		);
+	}
+	//
+	throw new cException("XPTY0004"
+
+	);
+};
+
+//
+fStaticContext_defineSystemDataType("integer",	cXSInteger);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSNonPositiveInteger(nValue) {
+	this.value	= nValue;
+};
+
+cXSNonPositiveInteger.prototype	= new cXSInteger;
+cXSNonPositiveInteger.prototype.builtInKind	= cXSConstants.NONPOSITIVEINTEGER_DT;
+
+cXSNonPositiveInteger.cast	= function(vValue) {
+	var oValue;
+	try {
+		oValue	= cXSInteger.cast(vValue);
+	}
+	catch (oError) {
+		throw oError;
+	}
+	// facet validation
+	if (oValue.value <= 0)
+		return new cXSNonPositiveInteger(oValue.value);
+	//
+	throw new cException("FORG0001");
+};
+
+//
+fStaticContext_defineSystemDataType("nonPositiveInteger",	cXSNonPositiveInteger);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSNegativeInteger(nValue) {
+	this.value	= nValue;
+};
+
+cXSNegativeInteger.prototype	= new cXSNonPositiveInteger;
+cXSNegativeInteger.prototype.builtInKind	= cXSConstants.NEGATIVEINTEGER_DT;
+
+cXSNegativeInteger.cast	= function(vValue) {
+	var oValue;
+	try {
+		oValue	= cXSInteger.cast(vValue);
+	}
+	catch (oError) {
+		throw oError;
+	}
+	// facet validation
+	if (oValue.value <= -1)
+		return new cXSNegativeInteger(oValue.value);
+	//
+	throw new cException("FORG0001");
+};
+
+//
+fStaticContext_defineSystemDataType("negativeInteger",	cXSNegativeInteger);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSLong(nValue) {
+	this.value	= nValue;
+};
+
+cXSLong.prototype	= new cXSInteger;
+cXSLong.prototype.builtInKind	= cXSConstants.LONG_DT;
+
+cXSLong.cast	= function(vValue) {
+	var oValue;
+	try {
+		oValue	= cXSInteger.cast(vValue);
+	}
+	catch (oError) {
+		throw oError;
+	}
+	// facet validation
+	if (oValue.value <= 9223372036854775807 && oValue.value >= -9223372036854775808)
+		return new cXSLong(oValue.value);
+	//
+	throw new cException("FORG0001");
+};
+
+//
+fStaticContext_defineSystemDataType("long",	cXSLong);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSInt(nValue) {
+	this.value	= nValue;
+};
+
+cXSInt.prototype	= new cXSLong;
+cXSInt.prototype.builtInKind	= cXSConstants.INT_DT;
+
+cXSInt.cast	= function(vValue) {
+	var oValue;
+	try {
+		oValue	= cXSInteger.cast(vValue);
+	}
+	catch (oError) {
+		throw oError;
+	}
+	// facet validation
+	if (oValue.value <= 2147483647 && oValue.value >= -2147483648)
+		return new cXSInt(oValue.value);
+	//
+	throw new cException("FORG0001");
+};
+
+//
+fStaticContext_defineSystemDataType("int",	cXSInt);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSShort(nValue) {
+	this.value	= nValue;
+};
+
+cXSShort.prototype	= new cXSInt;
+cXSShort.prototype.builtInKind	= cXSConstants.SHORT_DT;
+
+cXSShort.cast	= function(vValue) {
+	var oValue;
+	try {
+		oValue	= cXSInteger.cast(vValue);
+	}
+	catch (oError) {
+		throw oError;
+	}
+	// facet validation
+	if (oValue.value <= 32767 && oValue.value >= -32768)
+		return new cXSShort(oValue.value);
+	//
+	throw new cException("FORG0001");
+};
+
+//
+fStaticContext_defineSystemDataType("short",	cXSShort);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSByte(nValue) {
+	this.value	= nValue;
+};
+
+cXSByte.prototype	= new cXSShort;
+cXSByte.prototype.builtInKind	= cXSConstants.BYTE_DT;
+
+cXSByte.cast	= function(vValue) {
+	var oValue;
+	try {
+		oValue	= cXSInteger.cast(vValue);
+	}
+	catch (oError) {
+		throw oError;
+	}
+	// facet validation
+	if (oValue.value <= 127 && oValue.value >= -128)
+		return new cXSByte(oValue.value);
+	//
+	throw new cException("FORG0001");
+};
+
+//
+fStaticContext_defineSystemDataType("byte",	cXSByte);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSNonNegativeInteger(nValue) {
+	this.value	= nValue;
+};
+
+cXSNonNegativeInteger.prototype	= new cXSInteger;
+cXSNonNegativeInteger.prototype.builtInKind	= cXSConstants.NONNEGATIVEINTEGER_DT;
+
+cXSNonNegativeInteger.cast	= function(vValue) {
+	var oValue;
+	try {
+		oValue	= cXSInteger.cast(vValue);
+	}
+	catch (oError) {
+		throw oError;
+	}
+	// facet validation
+	if (oValue.value >= 0)
+		return new cXSNonNegativeInteger(oValue.value);
+	//
+	throw new cException("FORG0001");
+};
+
+//
+fStaticContext_defineSystemDataType("nonNegativeInteger",	cXSNonNegativeInteger);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSPositiveInteger(nValue) {
+	this.value	= nValue;
+};
+
+cXSPositiveInteger.prototype	= new cXSNonNegativeInteger;
+cXSPositiveInteger.prototype.builtInKind	= cXSConstants.POSITIVEINTEGER_DT;
+
+cXSPositiveInteger.cast	= function(vValue) {
+	var oValue;
+	try {
+		oValue	= cXSInteger.cast(vValue);
+	}
+	catch (oError) {
+		throw oError;
+	}
+	// facet validation
+	if (oValue.value >= 1)
+		return new cXSPositiveInteger(oValue.value);
+	//
+	throw new cException("FORG0001");
+};
+
+//
+fStaticContext_defineSystemDataType("positiveInteger",	cXSPositiveInteger);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSUnsignedLong(nValue) {
+	this.value	= nValue;
+};
+
+cXSUnsignedLong.prototype	= new cXSNonNegativeInteger;
+cXSUnsignedLong.prototype.builtInKind	= cXSConstants.UNSIGNEDLONG_DT;
+
+cXSUnsignedLong.cast	= function(vValue) {
+	var oValue;
+	try {
+		oValue	= cXSInteger.cast(vValue);
+	}
+	catch (oError) {
+		throw oError;
+	}
+	// facet validation
+	if (oValue.value >= 1 && oValue.value <= 18446744073709551615)
+		return new cXSUnsignedLong(oValue.value);
+	//
+	throw new cException("FORG0001");
+};
+
+//
+fStaticContext_defineSystemDataType("unsignedLong",	cXSUnsignedLong);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSUnsignedInt(nValue) {
+	this.value	= nValue;
+};
+
+cXSUnsignedInt.prototype	= new cXSNonNegativeInteger;
+cXSUnsignedInt.prototype.builtInKind	= cXSConstants.UNSIGNEDINT_DT;
+
+cXSUnsignedInt.cast	= function(vValue) {
+	var oValue;
+	try {
+		oValue	= cXSInteger.cast(vValue);
+	}
+	catch (oError) {
+		throw oError;
+	}
+	// facet validation
+	if (oValue.value >= 1 && oValue.value <= 4294967295)
+		return new cXSUnsignedInt(oValue.value);
+	//
+	throw new cException("FORG0001");
+};
+
+//
+fStaticContext_defineSystemDataType("unsignedInt",	cXSUnsignedInt);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSUnsignedShort(nValue) {
+	this.value	= nValue;
+};
+
+cXSUnsignedShort.prototype	= new cXSUnsignedInt;
+cXSUnsignedShort.prototype.builtInKind	= cXSConstants.UNSIGNEDSHORT_DT;
+
+cXSUnsignedShort.cast	= function(vValue) {
+	var oValue;
+	try {
+		oValue	= cXSInteger.cast(vValue);
+	}
+	catch (oError) {
+		throw oError;
+	}
+	// facet validation
+	if (oValue.value >= 1 && oValue.value <= 65535)
+		return new cXSUnsignedShort(oValue.value);
+	//
+	throw new cException("FORG0001");
+};
+
+//
+fStaticContext_defineSystemDataType("unsignedShort",	cXSUnsignedShort);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSUnsignedByte(nValue) {
+	this.value	= nValue;
+};
+
+cXSUnsignedByte.prototype	= new cXSUnsignedShort;
+cXSUnsignedByte.prototype.builtInKind	= cXSConstants.UNSIGNEDBYTE_DT;
+
+cXSUnsignedByte.cast	= function(vValue) {
+	var oValue;
+	try {
+		oValue	= cXSInteger.cast(vValue);
+	}
+	catch (oError) {
+		throw oError;
+	}
+	// facet validation
+	if (oValue.value >= 1 && oValue.value <= 255)
+		return new cXSUnsignedByte(oValue.value);
+	//
+	throw new cException("FORG0001");
+};
+
+//
+fStaticContext_defineSystemDataType("unsignedByte",	cXSUnsignedByte);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSNormalizedString(sValue) {
+	this.value	= sValue;
+};
+
+cXSNormalizedString.prototype	= new cXSString;
+cXSNormalizedString.prototype.builtInKind	= cXSConstants.NORMALIZEDSTRING_DT;
+
+cXSNormalizedString.cast	= function(vValue) {
+	return new cXSNormalizedString(cString(vValue));
+};
+
+//
+fStaticContext_defineSystemDataType("normalizedString",	cXSNormalizedString);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSToken(sValue) {
+	this.value	= sValue;
+};
+
+cXSToken.prototype	= new cXSNormalizedString;
+cXSToken.prototype.builtInKind	= cXSConstants.TOKEN_DT;
+
+cXSToken.cast	= function(vValue) {
+	return new cXSToken(cString(vValue));
+};
+
+//
+fStaticContext_defineSystemDataType("token",	cXSToken);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSName(sValue) {
+	this.value	= sValue;
+};
+
+cXSName.prototype	= new cXSToken;
+cXSName.prototype.builtInKind	= cXSConstants.NAME_DT;
+
+cXSName.cast	= function(vValue) {
+	return new cXSName(cString(vValue));
+};
+
+//
+fStaticContext_defineSystemDataType("Name",	cXSName);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSNCName(sValue) {
+	this.value	= sValue;
+};
+
+cXSNCName.prototype	= new cXSName;
+cXSNCName.prototype.builtInKind	= cXSConstants.NCNAME_DT;
+
+cXSNCName.cast	= function(vValue) {
+	return new cXSNCName(cString(vValue));
+};
+
+//
+fStaticContext_defineSystemDataType("NCName",	cXSNCName);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSENTITY(sValue) {
+	this.value	= sValue;
+};
+
+cXSENTITY.prototype	= new cXSNCName;
+cXSENTITY.prototype.builtInKind	= cXSConstants.ENTITY_DT;
+
+cXSENTITY.cast	= function(vValue) {
+	return new cXSENTITY(cString(vValue));
+};
+
+//
+fStaticContext_defineSystemDataType("ENTITY",	cXSENTITY);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSID(sValue) {
+	this.value	= sValue;
+};
+
+cXSID.prototype	= new cXSNCName;
+cXSID.prototype.builtInKind	= cXSConstants.ID_DT;
+
+cXSID.cast	= function(vValue) {
+	return new cXSID(cString(vValue));
+};
+
+//
+fStaticContext_defineSystemDataType("ID",	cXSID);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSIDREF(sValue) {
+	this.value	= sValue;
+};
+
+cXSIDREF.prototype	= new cXSNCName;
+cXSIDREF.prototype.builtInKind	= cXSConstants.IDREF_DT;
+
+cXSIDREF.cast	= function(vValue) {
+	return new cXSIDREF(cString(vValue));
+};
+
+//
+fStaticContext_defineSystemDataType("IDREF",	cXSIDREF);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSLanguage(sValue) {
+	this.value	= sValue;
+};
+
+cXSLanguage.prototype	= new cXSToken;
+cXSLanguage.prototype.builtInKind	= cXSConstants.LANGUAGE_DT;
+
+cXSLanguage.cast	= function(vValue) {
+	return new cXSLanguage(cString(vValue));
+};
+
+//
+fStaticContext_defineSystemDataType("language",	cXSLanguage);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXSNMTOKEN(sValue) {
+	this.value	= sValue;
+};
+
+cXSNMTOKEN.prototype	= new cXSToken;
+cXSNMTOKEN.prototype.builtInKind	= cXSConstants.NMTOKEN_DT;
+
+cXSNMTOKEN.cast	= function(vValue) {
+	return new cXSNMTOKEN(cString(vValue));
+};
+
+//
+fStaticContext_defineSystemDataType("NMTOKEN",	cXSNMTOKEN);
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXTItem() {
+
+};
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXTNode() {
+
+};
+
+cXTNode.prototype	= new cXTItem;
+
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXTAttribute() {
+
+};
+
+cXTAttribute.prototype	= new cXTNode;
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXTComment() {
+
+};
+
+cXTComment.prototype	= new cXTNode;
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXTDocument() {
+
+};
+
+cXTDocument.prototype	= new cXTNode;
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXTElement() {
+
+};
+
+cXTElement.prototype	= new cXTNode;
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXTProcessingInstruction() {
+
+};
+
+cXTProcessingInstruction.prototype	= new cXTNode;
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+function cXTText() {
+
+};
+
+cXTText.prototype	= new cXTNode;
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+/*
+	12.1 Comparisons of base64Binary and hexBinary Values
+		op:hexBinary-equal
+		op:base64Binary-equal
+*/
+hStaticContext_operators["hexBinary-equal"]	= function(oLeft, oRight) {
+	return new cXSBoolean(oLeft.valueOf() == oRight.valueOf());
+};
+
+hStaticContext_operators["base64Binary-equal"]	= function(oLeft, oRight) {
+	return new cXSBoolean(oLeft.valueOf() == oRight.valueOf());
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+/*
+	9.2 Operators on Boolean Values
+		op:boolean-equal
+		op:boolean-less-than
+		op:boolean-greater-than
+*/
+
+// 9.2 Operators on Boolean Values
+// op:boolean-equal($value1 as xs:boolean, $value2 as xs:boolean) as xs:boolean
+hStaticContext_operators["boolean-equal"]	= function(oLeft, oRight) {
+	return new cXSBoolean(oLeft.valueOf() == oRight.valueOf());
+};
+
+// op:boolean-less-than($arg1 as xs:boolean, $arg2 as xs:boolean) as xs:boolean
+hStaticContext_operators["boolean-less-than"]	= function(oLeft, oRight) {
+	return new cXSBoolean(oLeft.valueOf() < oRight.valueOf());
+};
+
+// op:boolean-greater-than($arg1 as xs:boolean, $arg2 as xs:boolean) as xs:boolean
+hStaticContext_operators["boolean-greater-than"]	= function(oLeft, oRight) {
+	return new cXSBoolean(oLeft.valueOf() > oRight.valueOf());
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+/*
+	10.4 Comparison Operators on Duration, Date and Time Values
+		op:yearMonthDuration-less-than
+		op:yearMonthDuration-greater-than
+		op:dayTimeDuration-less-than
+		op:dayTimeDuration-greater-than
+		op:duration-equal
+		op:dateTime-equal
+		op:dateTime-less-than
+		op:dateTime-greater-than
+		op:date-equal
+		op:date-less-than
+		op:date-greater-than
+		op:time-equal
+		op:time-less-than
+		op:time-greater-than
+		op:gYearMonth-equal
+		op:gYear-equal
+		op:gMonthDay-equal
+		op:gMonth-equal
+		op:gDay-equal
+
+	10.6 Arithmetic Operators on Durations
+		op:add-yearMonthDurations
+		op:subtract-yearMonthDurations
+		op:multiply-yearMonthDuration
+		op:divide-yearMonthDuration
+		op:divide-yearMonthDuration-by-yearMonthDuration
+		op:add-dayTimeDurations
+		op:subtract-dayTimeDurations
+		op:multiply-dayTimeDuration
+		op:divide-dayTimeDuration
+		op:divide-dayTimeDuration-by-dayTimeDuration
+
+
+	10.8 Arithmetic Operators on Durations, Dates and Times
+		op:subtract-dateTimes
+		op:subtract-dates
+		op:subtract-times
+		op:add-yearMonthDuration-to-dateTime
+		op:add-dayTimeDuration-to-dateTime
+		op:subtract-yearMonthDuration-from-dateTime
+		op:subtract-dayTimeDuration-from-dateTime
+		op:add-yearMonthDuration-to-date
+		op:add-dayTimeDuration-to-date
+		op:subtract-yearMonthDuration-from-date
+		op:subtract-dayTimeDuration-from-date
+		op:add-dayTimeDuration-to-time
+		op:subtract-dayTimeDuration-from-time
+
+*/
+
+// 10.4 Comparison Operators on Duration, Date and Time Values
+// op:yearMonthDuration-less-than($arg1 as xs:yearMonthDuration, $arg2 as xs:yearMonthDuration) as xs:boolean
+hStaticContext_operators["yearMonthDuration-less-than"]	= function(oLeft, oRight) {
+	return new cXSBoolean(fOperator_yearMonthDuration_toMonths(oLeft) < fOperator_yearMonthDuration_toMonths(oRight));
+};
+
+// op:yearMonthDuration-greater-than($arg1 as xs:yearMonthDuration, $arg2 as xs:yearMonthDuration) as xs:boolean
+hStaticContext_operators["yearMonthDuration-greater-than"]	= function(oLeft, oRight) {
+	return new cXSBoolean(fOperator_yearMonthDuration_toMonths(oLeft) > fOperator_yearMonthDuration_toMonths(oRight));
+};
+
+// op:dayTimeDuration-less-than($arg1 as dayTimeDuration, $arg2 as dayTimeDuration) as xs:boolean
+hStaticContext_operators["dayTimeDuration-less-than"]	= function(oLeft, oRight) {
+	return new cXSBoolean(fOperator_dayTimeDuration_toSeconds(oLeft) < fOperator_dayTimeDuration_toSeconds(oRight));
+};
+
+// op:dayTimeDuration-greater-than($arg1 as dayTimeDuration, $arg2 as dayTimeDuration) as xs:boolean
+hStaticContext_operators["dayTimeDuration-greater-than"]	= function(oLeft, oRight) {
+	return new cXSBoolean(fOperator_dayTimeDuration_toSeconds(oLeft) > fOperator_dayTimeDuration_toSeconds(oRight));
+};
+
+// op:duration-equal($arg1 as xs:duration, $arg2 as xs:duration) as xs:boolean
+hStaticContext_operators["duration-equal"]	= function(oLeft, oRight) {
+	return new cXSBoolean(oLeft.negative == oRight.negative
+			&& fOperator_yearMonthDuration_toMonths(oLeft) == fOperator_yearMonthDuration_toMonths(oRight)
+			&& fOperator_dayTimeDuration_toSeconds(oLeft) == fOperator_dayTimeDuration_toSeconds(oRight));
+};
+
+// op:dateTime-equal($arg1 as xs:dateTime, $arg2 as xs:dateTime) as xs:boolean
+hStaticContext_operators["dateTime-equal"]	= function(oLeft, oRight) {
+	return fOperator_compareDateTimes(oLeft, oRight, 'eq');
+};
+
+// op:dateTime-less-than($arg1 as xs:dateTime, $arg2 as xs:dateTime) as xs:boolean
+hStaticContext_operators["dateTime-less-than"]	= function(oLeft, oRight) {
+	return fOperator_compareDateTimes(oLeft, oRight, 'lt');
+};
+
+//op:dateTime-greater-than($arg1 as xs:dateTime, $arg2 as xs:dateTime) as xs:boolean
+hStaticContext_operators["dateTime-greater-than"]	= function(oLeft, oRight) {
+	return fOperator_compareDateTimes(oLeft, oRight, 'gt');
+};
+
+// op:date-equal($arg1 as xs:date, $arg2 as xs:date) as xs:boolean
+hStaticContext_operators["date-equal"]	= function(oLeft, oRight) {
+	return fOperator_compareDates(oLeft, oRight, 'eq');
+};
+
+// op:date-less-than($arg1 as xs:date, $arg2 as xs:date) as xs:boolean
+hStaticContext_operators["date-less-than"]	= function(oLeft, oRight) {
+	return fOperator_compareDates(oLeft, oRight, 'lt');
+};
+
+// op:date-greater-than($arg1 as xs:date, $arg2 as xs:date) as xs:boolean
+hStaticContext_operators["date-greater-than"]	= function(oLeft, oRight) {
+	return fOperator_compareDates(oLeft, oRight, 'gt');
+};
+
+// op:time-equal($arg1 as xs:time, $arg2 as xs:time) as xs:boolean
+hStaticContext_operators["time-equal"]	= function(oLeft, oRight) {
+	return fOperator_compareTimes(oLeft, oRight, 'eq');
+};
+
+// op:time-less-than($arg1 as xs:time, $arg2 as xs:time) as xs:boolean
+hStaticContext_operators["time-less-than"]	= function(oLeft, oRight) {
+	return fOperator_compareTimes(oLeft, oRight, 'lt');
+};
+
+// op:time-greater-than($arg1 as xs:time, $arg2 as xs:time) as xs:boolean
+hStaticContext_operators["time-greater-than"]	= function(oLeft, oRight) {
+	return fOperator_compareTimes(oLeft, oRight, 'gt');
+};
+
+// op:gYearMonth-equal($arg1 as xs:gYearMonth, $arg2 as xs:gYearMonth) as xs:boolean
+hStaticContext_operators["gYearMonth-equal"]	= function(oLeft, oRight) {
+	return fOperator_compareDateTimes(
+			new cXSDateTime(oLeft.year, oLeft.month, fXSDate_getDaysForYearMonth(oLeft.year, oLeft.month), 0, 0, 0, oLeft.timezone == null ? this.timezone : oLeft.timezone),
+			new cXSDateTime(oRight.year, oRight.month, fXSDate_getDaysForYearMonth(oRight.year, oRight.month), 0, 0, 0, oRight.timezone == null ? this.timezone : oRight.timezone),
+			'eq'
+	);
+};
+
+// op:gYear-equal($arg1 as xs:gYear, $arg2 as xs:gYear) as xs:boolean
+hStaticContext_operators["gYear-equal"]	= function(oLeft, oRight) {
+	return fOperator_compareDateTimes(
+			new cXSDateTime(oLeft.year, 1, 1, 0, 0, 0, oLeft.timezone == null ? this.timezone : oLeft.timezone),
+			new cXSDateTime(oRight.year, 1, 1, 0, 0, 0, oRight.timezone == null ? this.timezone : oRight.timezone),
+			'eq'
+	);
+};
+
+// op:gMonthDay-equal($arg1 as xs:gMonthDay, $arg2 as xs:gMonthDay) as xs:boolean
+hStaticContext_operators["gMonthDay-equal"]	= function(oLeft, oRight) {
+	return fOperator_compareDateTimes(
+			new cXSDateTime(1972, oLeft.month, oLeft.day, 0, 0, 0, oLeft.timezone == null ? this.timezone : oLeft.timezone),
+			new cXSDateTime(1972, oRight.month, oRight.day, 0, 0, 0, oRight.timezone == null ? this.timezone : oRight.timezone),
+			'eq'
+	);
+};
+
+// op:gMonth-equal($arg1 as xs:gMonth, $arg2 as xs:gMonth) as xs:boolean
+hStaticContext_operators["gMonth-equal"]	= function(oLeft, oRight) {
+	return fOperator_compareDateTimes(
+			new cXSDateTime(1972, oLeft.month, fXSDate_getDaysForYearMonth(1972, oRight.month), 0, 0, 0, oLeft.timezone == null ? this.timezone : oLeft.timezone),
+			new cXSDateTime(1972, oRight.month, fXSDate_getDaysForYearMonth(1972, oRight.month), 0, 0, 0, oRight.timezone == null ? this.timezone : oRight.timezone),
+			'eq'
+	);
+};
+
+// op:gDay-equal($arg1 as xs:gDay, $arg2 as xs:gDay) as xs:boolean
+hStaticContext_operators["gDay-equal"]	= function(oLeft, oRight) {
+	return fOperator_compareDateTimes(
+			new cXSDateTime(1972, 12, oLeft.day, 0, 0, 0, oLeft.timezone == null ? this.timezone : oLeft.timezone),
+			new cXSDateTime(1972, 12, oRight.day, 0, 0, 0, oRight.timezone == null ? this.timezone : oRight.timezone),
+			'eq'
+	);
+};
+
+// 10.6 Arithmetic Operators on Durations
+// op:add-yearMonthDurations($arg1 as xs:yearMonthDuration, $arg2 as xs:yearMonthDuration) as xs:yearMonthDuration
+hStaticContext_operators["add-yearMonthDurations"]	= function(oLeft, oRight) {
+	return fOperator_yearMonthDuration_fromMonths(fOperator_yearMonthDuration_toMonths(oLeft) + fOperator_yearMonthDuration_toMonths(oRight));
+};
+
+// op:subtract-yearMonthDurations($arg1 as xs:yearMonthDuration, $arg2 as xs:yearMonthDuration) as xs:yearMonthDuration
+hStaticContext_operators["subtract-yearMonthDurations"]	= function(oLeft, oRight) {
+	return fOperator_yearMonthDuration_fromMonths(fOperator_yearMonthDuration_toMonths(oLeft) - fOperator_yearMonthDuration_toMonths(oRight));
+};
+
+// op:multiply-yearMonthDuration($arg1 as xs:yearMonthDuration, $arg2 as xs:double) as xs:yearMonthDuration
+hStaticContext_operators["multiply-yearMonthDuration"]	= function(oLeft, oRight) {
+	return fOperator_yearMonthDuration_fromMonths(fOperator_yearMonthDuration_toMonths(oLeft) * oRight);
+};
+
+// op:divide-yearMonthDuration($arg1 as xs:yearMonthDuration, $arg2 as xs:double) as xs:yearMonthDuration
+hStaticContext_operators["divide-yearMonthDuration"]	= function(oLeft, oRight) {
+	return fOperator_yearMonthDuration_fromMonths(fOperator_yearMonthDuration_toMonths(oLeft) / oRight);
+};
+
+// op:divide-yearMonthDuration-by-yearMonthDuration($arg1 as xs:yearMonthDuration, $arg2 as xs:yearMonthDuration) as xs:decimal
+hStaticContext_operators["divide-yearMonthDuration-by-yearMonthDuration"]	= function(oLeft, oRight) {
+	return new cXSDecimal(fOperator_yearMonthDuration_toMonths(oLeft) / fOperator_yearMonthDuration_toMonths(oRight));
+};
+
+// op:add-dayTimeDurations($arg1 as xs:dayTimeDuration, $arg2 as xs:dayTimeDuration) as xs:dayTimeDuration
+hStaticContext_operators["add-dayTimeDurations"]	= function(oLeft, oRight) {
+	return fOperator_dayTimeDuration_fromSeconds(fOperator_dayTimeDuration_toSeconds(oLeft) + fOperator_dayTimeDuration_toSeconds(oRight));
+};
+
+// op:subtract-dayTimeDurations($arg1 as xs:dayTimeDuration, $arg2 as xs:dayTimeDuration) as xs:dayTimeDuration
+hStaticContext_operators["subtract-dayTimeDurations"]	= function(oLeft, oRight) {
+	return fOperator_dayTimeDuration_fromSeconds(fOperator_dayTimeDuration_toSeconds(oLeft) - fOperator_dayTimeDuration_toSeconds(oRight));
+};
+
+// op:multiply-dayTimeDurations($arg1 as xs:dayTimeDuration, $arg2 as xs:double) as xs:dayTimeDuration
+hStaticContext_operators["multiply-dayTimeDuration"]	= function(oLeft, oRight) {
+	return fOperator_dayTimeDuration_fromSeconds(fOperator_dayTimeDuration_toSeconds(oLeft) * oRight);
+};
+
+// op:divide-dayTimeDurations($arg1 as xs:dayTimeDuration, $arg2 as xs:double) as xs:dayTimeDuration
+hStaticContext_operators["divide-dayTimeDuration"]	= function(oLeft, oRight) {
+	return fOperator_dayTimeDuration_fromSeconds(fOperator_dayTimeDuration_toSeconds(oLeft) / oRight);
+};
+
+// op:divide-dayTimeDuration-by-dayTimeDuration($arg1 as xs:dayTimeDuration, $arg2 as xs:dayTimeDuration) as xs:decimal
+hStaticContext_operators["divide-dayTimeDuration-by-dayTimeDuration"]	= function(oLeft, oRight) {
+	return new cXSDecimal(fOperator_dayTimeDuration_toSeconds(oLeft) / fOperator_dayTimeDuration_toSeconds(oRight));
+};
+
+// 10.8 Arithmetic Operators on Durations, Dates and Times
+// op:subtract-dateTimes($arg1 as xs:dateTime, $arg2 as xs:dateTime) as xs:dayTimeDuration
+hStaticContext_operators["subtract-dateTimes"]	= function(oLeft, oRight) {
+	return fOperator_dayTimeDuration_fromSeconds(fOperator_dateTime_toSeconds(oLeft) - fOperator_dateTime_toSeconds(oRight));
+};
+
+// op:subtract-dates($arg1 as xs:date, $arg2 as xs:date) as xs:dayTimeDuration
+hStaticContext_operators["subtract-dates"]	= function(oLeft, oRight) {
+	return fOperator_dayTimeDuration_fromSeconds(fOperator_dateTime_toSeconds(oLeft) - fOperator_dateTime_toSeconds(oRight));
+};
+
+// op:subtract-times($arg1 as xs:time, $arg2 as xs:time) as xs:dayTimeDuration
+hStaticContext_operators["subtract-times"]	= function(oLeft, oRight) {
+	return fOperator_dayTimeDuration_fromSeconds(fOperator_time_toSeconds(oLeft) - fOperator_time_toSeconds(oRight));
+};
+
+// op:add-yearMonthDuration-to-dateTime($arg1 as xs:dateTime, $arg2 as xs:yearMonthDuration) as xs:dateTime
+hStaticContext_operators["add-yearMonthDuration-to-dateTime"]	= function(oLeft, oRight) {
+	return fOperator_addYearMonthDuration2DateTime(oLeft, oRight, '+');
+};
+
+// op:add-dayTimeDuration-to-dateTime($arg1 as xs:dateTime, $arg2 as xs:dayTimeDuration) as xs:dateTime
+hStaticContext_operators["add-dayTimeDuration-to-dateTime"]	= function(oLeft, oRight) {
+	return fOperator_addDayTimeDuration2DateTime(oLeft, oRight, '+');
+};
+
+// op:subtract-yearMonthDuration-from-dateTime($arg1 as xs:dateTime, $arg2 as xs:yearMonthDuration) as xs:dateTime
+hStaticContext_operators["subtract-yearMonthDuration-from-dateTime"]	= function(oLeft, oRight) {
+	return fOperator_addYearMonthDuration2DateTime(oLeft, oRight, '-');
+};
+
+// op:subtract-dayTimeDuration-from-dateTime($arg1 as xs:dateTime, $arg2 as xs:dayTimeDuration) as xs:dateTime
+hStaticContext_operators["subtract-dayTimeDuration-from-dateTime"]	= function(oLeft, oRight) {
+	return fOperator_addDayTimeDuration2DateTime(oLeft, oRight, '-');
+};
+
+// op:add-yearMonthDuration-to-date($arg1 as xs:date, $arg2 as xs:yearMonthDuration) as xs:date
+hStaticContext_operators["add-yearMonthDuration-to-date"]	= function(oLeft, oRight) {
+	return fOperator_addYearMonthDuration2DateTime(oLeft, oRight, '+');
+};
+
+// op:add-dayTimeDuration-to-date($arg1 as xs:date, $arg2 as xs:dayTimeDuration) as xs:date
+hStaticContext_operators["add-dayTimeDuration-to-date"]	= function(oLeft, oRight) {
+	return fOperator_addDayTimeDuration2DateTime(oLeft, oRight, '+');
+};
+
+// op:subtract-yearMonthDuration-from-date($arg1 as xs:date, $arg2  as xs:yearMonthDuration) as xs:date
+hStaticContext_operators["subtract-yearMonthDuration-from-date"]	= function(oLeft, oRight) {
+	return fOperator_addYearMonthDuration2DateTime(oLeft, oRight, '-');
+};
+
+// op:subtract-dayTimeDuration-from-date($arg1 as xs:date, $arg2  as xs:dayTimeDuration) as xs:date
+hStaticContext_operators["subtract-dayTimeDuration-from-date"]	= function(oLeft, oRight) {
+	return fOperator_addDayTimeDuration2DateTime(oLeft, oRight, '-');
+};
+
+// op:add-dayTimeDuration-to-time($arg1 as xs:time, $arg2  as xs:dayTimeDuration) as xs:time
+hStaticContext_operators["add-dayTimeDuration-to-time"]	= function(oLeft, oRight) {
+	var oValue	= new cXSTime(oLeft.hours, oLeft.minutes, oLeft.seconds, oLeft.timezone);
+	oValue.hours	+= oRight.hours;
+	oValue.minutes	+= oRight.minutes;
+	oValue.seconds	+= oRight.seconds;
+	//
+	return fXSTime_normalize(oValue);
+};
+
+// op:subtract-dayTimeDuration-from-time($arg1 as xs:time, $arg2  as xs:dayTimeDuration) as xs:time
+hStaticContext_operators["subtract-dayTimeDuration-from-time"]	= function(oLeft, oRight) {
+	var oValue	= new cXSTime(oLeft.hours, oLeft.minutes, oLeft.seconds, oLeft.timezone);
+	oValue.hours	-= oRight.hours;
+	oValue.minutes	-= oRight.minutes;
+	oValue.seconds	-= oRight.seconds;
+	//
+	return fXSTime_normalize(oValue);
+};
+
+function fOperator_compareTimes(oLeft, oRight, sComparator) {
+	var nLeft	= fOperator_time_toSeconds(oLeft),
+		nRight	= fOperator_time_toSeconds(oRight);
+	return new cXSBoolean(sComparator == 'lt' ? nLeft < nRight : sComparator == 'gt' ? nLeft > nRight : nLeft == nRight);
+};
+
+function fOperator_compareDates(oLeft, oRight, sComparator) {
+	return fOperator_compareDateTimes(cXSDateTime.cast(oLeft), cXSDateTime.cast(oRight), sComparator);
+};
+
+function fOperator_compareDateTimes(oLeft, oRight, sComparator) {
+	// Adjust object time zone to Z and compare as strings
+	var oTimezone	= new cXSDayTimeDuration(0, 0, 0, 0),
+		sLeft	= fFunction_dateTime_adjustTimezone(oLeft, oTimezone).toString(),
+		sRight	= fFunction_dateTime_adjustTimezone(oRight, oTimezone).toString();
+	return new cXSBoolean(sComparator == 'lt' ? sLeft < sRight : sComparator == 'gt' ? sLeft > sRight : sLeft == sRight);
+};
+
+function fOperator_addYearMonthDuration2DateTime(oLeft, oRight, sOperator) {
+	var oValue;
+	if (oLeft instanceof cXSDate)
+		oValue	= new cXSDate(oLeft.year, oLeft.month, oLeft.day, oLeft.timezone, oLeft.negative);
+	else
+	if (oLeft instanceof cXSDateTime)
+		oValue	= new cXSDateTime(oLeft.year, oLeft.month, oLeft.day, oLeft.hours, oLeft.minutes, oLeft.seconds, oLeft.timezone, oLeft.negative);
+	//
+	oValue.year		= oValue.year + oRight.year * (sOperator == '-' ?-1 : 1);
+	oValue.month	= oValue.month + oRight.month * (sOperator == '-' ?-1 : 1);
+	//
+	fXSDate_normalize(oValue, true);
+	// Correct day if out of month range
+	var nDay	= fXSDate_getDaysForYearMonth(oValue.year, oValue.month);
+	if (oValue.day > nDay)
+		oValue.day	= nDay;
+	//
+	return oValue;
+};
+
+function fOperator_addDayTimeDuration2DateTime(oLeft, oRight, sOperator) {
+	var oValue;
+	if (oLeft instanceof cXSDate) {
+		var nValue	= (oRight.hours * 60 + oRight.minutes) * 60 + oRight.seconds;
+		oValue	= new cXSDate(oLeft.year, oLeft.month, oLeft.day, oLeft.timezone, oLeft.negative);
+		oValue.day	= oValue.day + oRight.day * (sOperator == '-' ?-1 : 1) - 1 * (nValue && sOperator == '-');
+		//
+		fXSDate_normalize(oValue);
+	}
+	else
+	if (oLeft instanceof cXSDateTime) {
+		oValue	= new cXSDateTime(oLeft.year, oLeft.month, oLeft.day, oLeft.hours, oLeft.minutes, oLeft.seconds, oLeft.timezone, oLeft.negative);
+		oValue.seconds	= oValue.seconds + oRight.seconds * (sOperator == '-' ?-1 : 1);
+		oValue.minutes	= oValue.minutes + oRight.minutes * (sOperator == '-' ?-1 : 1);
+		oValue.hours	= oValue.hours + oRight.hours * (sOperator == '-' ?-1 : 1);
+		oValue.day		= oValue.day + oRight.day * (sOperator == '-' ?-1 : 1);
+		//
+		fXSDateTime_normalize(oValue);
+	}
+	return oValue;
+};
+
+// xs:dayTimeDuration to/from seconds
+function fOperator_dayTimeDuration_toSeconds(oDuration) {
+	return (((oDuration.day * 24 + oDuration.hours) * 60 + oDuration.minutes) * 60 + oDuration.seconds) * (oDuration.negative ? -1 : 1);
+};
+
+function fOperator_dayTimeDuration_fromSeconds(nValue) {
+	var bNegative	=(nValue = cMath.round(nValue)) < 0,
+		nDays	= ~~((nValue = cMath.abs(nValue)) / 86400),
+		nHours	= ~~((nValue -= nDays * 3600 * 24) / 3600),
+		nMinutes= ~~((nValue -= nHours * 3600) / 60),
+		nSeconds	= nValue -= nMinutes * 60;
+	return new cXSDayTimeDuration(nDays, nHours, nMinutes, nSeconds, bNegative);
+};
+
+// xs:yearMonthDuration to/from months
+function fOperator_yearMonthDuration_toMonths(oDuration) {
+	return (oDuration.year * 12 + oDuration.month) * (oDuration.negative ? -1 : 1);
+};
+
+function fOperator_yearMonthDuration_fromMonths(nValue) {
+	var nNegative	=(nValue = cMath.round(nValue)) < 0,
+		nYears	= ~~((nValue = cMath.abs(nValue)) / 12),
+		nMonths		= nValue -= nYears * 12;
+	return new cXSYearMonthDuration(nYears, nMonths, nNegative);
+};
+
+// xs:time to seconds
+function fOperator_time_toSeconds(oTime) {
+	return oTime.seconds + (oTime.minutes - (oTime.timezone != null ? oTime.timezone % 60 : 0) + (oTime.hours - (oTime.timezone != null ? ~~(oTime.timezone / 60) : 0)) * 60) * 60;
+};
+
+// This function unlike all other date-related functions rely on interpretor's dateTime handling
+function fOperator_dateTime_toSeconds(oValue) {
+	var oDate	= new cDate((oValue.negative ? -1 : 1) * oValue.year, oValue.month, oValue.day, 0, 0, 0, 0);
+	if (oValue instanceof cXSDateTime) {
+		oDate.setHours(oValue.hours);
+		oDate.setMinutes(oValue.minutes);
+		oDate.setSeconds(oValue.seconds);
+	}
+	if (oValue.timezone != null)
+		oDate.setMinutes(oDate.getMinutes() - oValue.timezone);
+	return oDate.getTime() / 1000;
+};
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+/*
+	14 Functions and Operators on Nodes
+		op:is-same-node
+		op:node-before
+		op:node-after
+*/
+
+// 14 Operators on Nodes
+// op:is-same-node($parameter1 as node(), $parameter2 as node()) as xs:boolean
+hStaticContext_operators["is-same-node"]	= function(oLeft, oRight) {
+	return new cXSBoolean(this.DOMAdapter.isSameNode(oLeft, oRight));
+};
+
+// op:node-before($parameter1 as node(), $parameter2 as node()) as xs:boolean
+hStaticContext_operators["node-before"]	= function(oLeft, oRight) {
+	return new cXSBoolean(!!(this.DOMAdapter.compareDocumentPosition(oLeft, oRight) & 4));
+};
+
+// op:node-after($parameter1 as node(), $parameter2 as node()) as xs:boolean
+hStaticContext_operators["node-after"]	= function(oLeft, oRight) {
+	return new cXSBoolean(!!(this.DOMAdapter.compareDocumentPosition(oLeft, oRight) & 2));
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+/*
+	13.1 Operators on NOTATION
+		op:NOTATION-equal
+*/
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+/*
+	6.2 Operators on Numeric Values
+		op:numeric-add
+		op:numeric-subtract
+		op:numeric-multiply
+		op:numeric-divide
+		op:numeric-integer-divide
+		op:numeric-mod
+		op:numeric-unary-plus
+		op:numeric-unary-minus
+
+	6.3 Comparison Operators on Numeric Values
+		op:numeric-equal
+		op:numeric-less-than
+		op:numeric-greater-than
+*/
+
+// 6.2 Operators on Numeric Values
+function fFunctionCall_numeric_getPower(oLeft, oRight) {
+	if (fIsNaN(oLeft) || (cMath.abs(oLeft) == nInfinity) || fIsNaN(oRight) || (cMath.abs(oRight) == nInfinity))
+		return 0;
+	var aLeft	= cString(oLeft).match(rNumericLiteral),
+		aRight	= cString(oRight).match(rNumericLiteral),
+		nPower	= cMath.max(1, (aLeft[2] || aLeft[3] || '').length + (aLeft[5] || 0) * (aLeft[4] == '+' ?-1 : 1), (aRight[2] || aRight[3] || '').length + (aRight[5] || 0) * (aRight[4] == '+' ?-1 : 1));
+	return nPower + (nPower % 2 ? 0 : 1);
+};
+
+// op:numeric-add($arg1 as numeric, $arg2 as numeric) as numeric
+hStaticContext_operators["numeric-add"]		= function(oLeft, oRight) {
+	var nLeft	= oLeft.valueOf(),
+		nRight	= oRight.valueOf(),
+		nPower	= cMath.pow(10, fFunctionCall_numeric_getPower(nLeft, nRight));
+	return fOperator_numeric_getResultOfType(oLeft, oRight, ((nLeft * nPower) + (nRight * nPower))/nPower);
+};
+
+// op:numeric-subtract($arg1 as numeric, $arg2 as numeric) as numeric
+hStaticContext_operators["numeric-subtract"]	= function(oLeft, oRight) {
+	var nLeft	= oLeft.valueOf(),
+		nRight	= oRight.valueOf(),
+		nPower	= cMath.pow(10, fFunctionCall_numeric_getPower(nLeft, nRight));
+	return fOperator_numeric_getResultOfType(oLeft, oRight, ((nLeft * nPower) - (nRight * nPower))/nPower);
+};
+
+// op:numeric-multiply($arg1 as numeric, $arg2 as numeric) as numeric
+hStaticContext_operators["numeric-multiply"]	= function(oLeft, oRight) {
+	var nLeft	= oLeft.valueOf(),
+		nRight	= oRight.valueOf(),
+		nPower	= cMath.pow(10, fFunctionCall_numeric_getPower(nLeft, nRight));
+	return fOperator_numeric_getResultOfType(oLeft, oRight, ((nLeft * nPower) * (nRight * nPower))/(nPower * nPower));
+};
+
+// op:numeric-divide($arg1 as numeric, $arg2 as numeric) as numeric
+hStaticContext_operators["numeric-divide"]	= function(oLeft, oRight) {
+	var nLeft	= oLeft.valueOf(),
+		nRight	= oRight.valueOf(),
+		nPower	= cMath.pow(10, fFunctionCall_numeric_getPower(nLeft, nRight));
+	return fOperator_numeric_getResultOfType(oLeft, oRight, (oLeft * nPower) / (oRight * nPower));
+};
+
+// op:numeric-integer-divide($arg1 as numeric, $arg2 as numeric) as xs:integer
+hStaticContext_operators["numeric-integer-divide"]	= function(oLeft, oRight) {
+	var oValue = oLeft / oRight;
+	return new cXSInteger(cMath.floor(oValue) + (oValue < 0));
+};
+
+// op:numeric-mod($arg1 as numeric, $arg2 as numeric) as numeric
+hStaticContext_operators["numeric-mod"]	= function(oLeft, oRight) {
+	var nLeft	= oLeft.valueOf(),
+		nRight	= oRight.valueOf(),
+		nPower	= cMath.pow(10, fFunctionCall_numeric_getPower(nLeft, nRight));
+	return fOperator_numeric_getResultOfType(oLeft, oRight, ((nLeft * nPower) % (nRight * nPower)) / nPower);
+};
+
+// op:numeric-unary-plus($arg as numeric) as numeric
+hStaticContext_operators["numeric-unary-plus"]	= function(oRight) {
+	return oRight;
+};
+
+// op:numeric-unary-minus($arg as numeric) as numeric
+hStaticContext_operators["numeric-unary-minus"]	= function(oRight) {
+	oRight.value	*=-1;
+	return oRight;
+};
+
+
+// 6.3 Comparison Operators on Numeric Values
+// op:numeric-equal($arg1 as numeric, $arg2 as numeric) as xs:boolean
+hStaticContext_operators["numeric-equal"]	= function(oLeft, oRight) {
+	return new cXSBoolean(oLeft.valueOf() == oRight.valueOf());
+};
+
+// op:numeric-less-than($arg1 as numeric, $arg2 as numeric) as xs:boolean
+hStaticContext_operators["numeric-less-than"]	= function(oLeft, oRight) {
+	return new cXSBoolean(oLeft.valueOf() < oRight.valueOf());
+};
+
+// op:numeric-greater-than($arg1 as numeric, $arg2 as numeric) as xs:boolean
+hStaticContext_operators["numeric-greater-than"]	= function(oLeft, oRight) {
+	return new cXSBoolean(oLeft.valueOf() > oRight.valueOf());
+};
+
+function fOperator_numeric_getResultOfType(oLeft, oRight, nResult) {
+	return new (oLeft instanceof cXSInteger && oRight instanceof cXSInteger && nResult == cMath.round(nResult) ? cXSInteger : cXSDecimal)(nResult);
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+/*
+	11.2 Functions and Operators Related to QNames
+		op:QName-equal
+
+*/
+
+// 11.2 Operators Related to QNames
+// op:QName-equal($arg1 as xs:QName, $arg2 as xs:QName) as xs:boolean
+hStaticContext_operators["QName-equal"]	= function(oLeft, oRight) {
+	return new cXSBoolean(oLeft.localName == oRight.localName && oLeft.namespaceURI == oRight.namespaceURI);
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+/*
+	15.1 General Functions and Operators on Sequences
+		op:concatenate
+
+	15.3 Equals, Union, Intersection and Except
+		op:union
+		op:intersect
+		op:except
+
+	15.5 Functions and Operators that Generate Sequences
+		op:to
+
+*/
+
+// 15.1 General Functions and Operators on Sequences
+// op:concatenate($seq1 as item()*, $seq2 as item()*) as item()*
+hStaticContext_operators["concatenate"]	= function(oSequence1, oSequence2) {
+	return oSequence1.concat(oSequence2);
+};
+
+// 15.3 Equals, Union, Intersection and Except
+// op:union($parameter1 as node()*, $parameter2 as node()*) as node()*
+hStaticContext_operators["union"]	= function(oSequence1, oSequence2) {
+	var oSequence	= [];
+	// Process first collection
+	for (var nIndex = 0, nLength = oSequence1.length, oItem; nIndex < nLength; nIndex++) {
+		if (!this.DOMAdapter.isNode(oItem = oSequence1[nIndex]))
+			throw new cException("XPTY0004"
+
+			);	// Required item type of second operand of 'intersect' is node(); supplied value has item type xs:integer
+		//
+		if (fArray_indexOf(oSequence, oItem) ==-1)
+			oSequence.push(oItem);
+	}
+	// Process second collection
+	for (var nIndex = 0, nLength = oSequence2.length, oItem; nIndex < nLength; nIndex++) {
+		if (!this.DOMAdapter.isNode(oItem = oSequence2[nIndex]))
+			throw new cException("XPTY0004"
+
+			);	// Required item type of second operand of 'intersect' is node(); supplied value has item type xs:integer
+		//
+		if (fArray_indexOf(oSequence, oItem) ==-1)
+			oSequence.push(oItem);
+	}
+	return fFunction_sequence_order(oSequence, this);
+};
+
+// op:intersect($parameter1 as node()*, $parameter2 as node()*) as node()*
+hStaticContext_operators["intersect"]	= function(oSequence1, oSequence2) {
+	var oSequence	= [];
+	for (var nIndex = 0, nLength = oSequence1.length, oItem, bFound; nIndex < nLength; nIndex++) {
+		if (!this.DOMAdapter.isNode(oItem = oSequence1[nIndex]))
+			throw new cException("XPTY0004"
+
+			);	// Required item type of second operand of 'intersect' is node(); supplied value has item type xs:integer
+		//
+		bFound	= false;
+		for (var nRightIndex = 0, nRightLength = oSequence2.length;(nRightIndex < nRightLength) && !bFound; nRightIndex++) {
+			if (!this.DOMAdapter.isNode(oSequence2[nRightIndex]))
+				throw new cException("XPTY0004"
+
+				);
+			bFound = this.DOMAdapter.isSameNode(oSequence2[nRightIndex], oItem);
+		}
+		//
+		if (bFound && fArray_indexOf(oSequence, oItem) ==-1)
+			oSequence.push(oItem);
+	}
+	return fFunction_sequence_order(oSequence, this);
+};
+
+// op:except($parameter1 as node()*, $parameter2 as node()*) as node()*
+hStaticContext_operators["except"]	= function(oSequence1, oSequence2) {
+	var oSequence	= [];
+	for (var nIndex = 0, nLength = oSequence1.length, oItem, bFound; nIndex < nLength; nIndex++) {
+		if (!this.DOMAdapter.isNode(oItem = oSequence1[nIndex]))
+			throw new cException("XPTY0004"
+
+			);	// Required item type of second operand of 'intersect' is node(); supplied value has item type xs:integer
+		//
+		bFound	= false;
+		for (var nRightIndex = 0, nRightLength = oSequence2.length;(nRightIndex < nRightLength) && !bFound; nRightIndex++) {
+			if (!this.DOMAdapter.isNode(oSequence2[nRightIndex]))
+				throw new cException("XPTY0004"
+
+				);
+			bFound = this.DOMAdapter.isSameNode(oSequence2[nRightIndex], oItem);
+		}
+		//
+		if (!bFound && fArray_indexOf(oSequence, oItem) ==-1)
+			oSequence.push(oItem);
+	}
+	return fFunction_sequence_order(oSequence, this);
+};
+
+// 15.5 Functions and Operators that Generate Sequences
+// op:to($firstval as xs:integer, $lastval as xs:integer) as xs:integer*
+hStaticContext_operators["to"]	= function(oLeft, oRight) {
+	var oSequence	= [];
+	for (var nIndex = oLeft.valueOf(), nLength = oRight.valueOf(); nIndex <= nLength; nIndex++)
+		oSequence.push(new cXSInteger(nIndex));
+	//
+	return oSequence;
+};
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+/*
+	2 Accessors
+		node-name
+		nilled
+		string
+		data
+		base-uri
+		document-uri
+
+*/
+
+// fn:node-name($arg as node()?) as xs:QName?
+fStaticContext_defineSystemFunction("node-name",		[[cXTNode, '?']],	function(oNode) {
+	if (oNode != null) {
+		var fGetProperty	= this.DOMAdapter.getProperty;
+		switch (fGetProperty(oNode, "nodeType")) {
+			case 1:		// ELEMENT_NAME
+			case 2:		// ATTRIBUTE_NODE
+				return new cXSQName(fGetProperty(oNode, "prefix"), fGetProperty(oNode, "localName"), fGetProperty(oNode, "namespaceURI"));
+			case 5:		// ENTITY_REFERENCE_NODE
+				throw "Not implemented";
+			case 6:		// ENTITY_NODE
+				throw "Not implemented";
+			case 7:		// PROCESSING_INSTRUCTION_NODE
+				return new cXSQName(null, fGetProperty(oNode, "target"), null);
+			case 10:	// DOCUMENT_TYPE_NODE
+				return new cXSQName(null, fGetProperty(oNode, "name"), null);
+		}
+	}
+	//
+	return null;
+});
+
+// fn:nilled($arg as node()?) as xs:boolean?
+fStaticContext_defineSystemFunction("nilled",	[[cXTNode, '?']],	function(oNode) {
+	if (oNode != null) {
+		if (this.DOMAdapter.getProperty(oNode, "nodeType") == 1)
+			return new cXSBoolean(false);	// TODO: Determine if node is nilled
+	}
+	//
+	return null;
+});
+
+// fn:string() as xs:string
+// fn:string($arg as item()?) as xs:string
+fStaticContext_defineSystemFunction("string",	[[cXTItem, '?', true]],	function(/*[*/oItem/*]*/) {
+	if (!arguments.length) {
+		if (!this.item)
+			throw new cException("XPDY0002");
+		oItem	= this.item;
+	}
+	return oItem == null ? new cXSString('') : cXSString.cast(fFunction_sequence_atomize([oItem], this)[0]);
+});
+
+// fn:data($arg as item()*) as xs:anyAtomicType*
+fStaticContext_defineSystemFunction("data",	[[cXTItem, '*']],		function(oSequence1) {
+	return fFunction_sequence_atomize(oSequence1, this);
+});
+
+// fn:base-uri() as xs:anyURI?
+// fn:base-uri($arg as node()?) as xs:anyURI?
+fStaticContext_defineSystemFunction("base-uri",	[[cXTNode, '?', true]],	function(oNode) {
+	if (!arguments.length) {
+		if (!this.DOMAdapter.isNode(this.item))
+			throw new cException("XPTY0004"
+
+			);
+		oNode	= this.item;
+	}
+	//
+	return cXSAnyURI.cast(new cXSString(this.DOMAdapter.getProperty(oNode, "baseURI") || ''));
+});
+
+// fn:document-uri($arg as node()?) as xs:anyURI?
+fStaticContext_defineSystemFunction("document-uri",	[[cXTNode, '?']],	function(oNode) {
+	if (oNode != null) {
+		var fGetProperty	= this.DOMAdapter.getProperty;
+		if (fGetProperty(oNode, "nodeType") == 9)
+			return cXSAnyURI.cast(new cXSString(fGetProperty(oNode, "documentURI") || ''));
+	}
+	//
+	return null;
+});
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+/*
+	8 Functions on anyURI
+		resolve-uri
+*/
+
+// fn:resolve-uri($relative as xs:string?) as xs:anyURI?
+// fn:resolve-uri($relative as xs:string?, $base as xs:string) as xs:anyURI?
+fStaticContext_defineSystemFunction("resolve-uri",	[[cXSString, '?'], [cXSString, '', true]],	function(sUri, sBaseUri) {
+	if (arguments.length < 2) {
+		if (!this.DOMAdapter.isNode(this.item))
+			throw new cException("XPTY0004"
+
+			);
+		sBaseUri	= new cXSString(this.DOMAdapter.getProperty(this.item, "baseURI") || '');
+	}
+
+	if (sUri == null)
+		return null;
+
+	//
+	if (sUri.valueOf() == '' || sUri.valueOf().charAt(0) == '#')
+		return cXSAnyURI.cast(sBaseUri);
+
+	var oUri	= cXSAnyURI.cast(sUri);
+	if (oUri.scheme)
+		return oUri;
+
+	var oBaseUri	= cXSAnyURI.cast(sBaseUri);
+	oUri.scheme	= oBaseUri.scheme;
+
+	if (!oUri.authority) {
+		// authority
+		oUri.authority	= oBaseUri.authority;
+
+		// path
+		if (oUri.path.charAt(0) != '/') {
+			var aUriSegments		= oUri.path.split('/'),
+				aBaseUriSegments	= oBaseUri.path.split('/');
+			aBaseUriSegments.pop();
+
+			var nBaseUriStart	= aBaseUriSegments[0] == '' ? 1 : 0;
+			for (var nIndex = 0, nLength = aUriSegments.length; nIndex < nLength; nIndex++) {
+				if (aUriSegments[nIndex] == '..') {
+					if (aBaseUriSegments.length > nBaseUriStart)
+						aBaseUriSegments.pop();
+					else {
+						aBaseUriSegments.push(aUriSegments[nIndex]);
+						nBaseUriStart++;
+					}
+				}
+				else
+				if (aUriSegments[nIndex] != '.')
+					aBaseUriSegments.push(aUriSegments[nIndex]);
+			}
+			if (aUriSegments[--nIndex] == '..' || aUriSegments[nIndex] == '.')
+				aBaseUriSegments.push('');
+			//
+			oUri.path	= aBaseUriSegments.join('/');
+		}
+	}
+
+	return oUri;
+});
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+/*
+	9.1 Additional Boolean Constructor Functions
+		true
+		false
+
+	9.3 Functions on Boolean Values
+		not
+*/
+
+// 9.1 Additional Boolean Constructor Functions
+// fn:true() as xs:boolean
+fStaticContext_defineSystemFunction("true",	[],	function() {
+	return new cXSBoolean(true);
+});
+
+// fn:false() as xs:boolean
+fStaticContext_defineSystemFunction("false",	[],	function() {
+	return new cXSBoolean(false);
+});
+
+// 9.3 Functions on Boolean Values
+// fn:not($arg as item()*) as xs:boolean
+fStaticContext_defineSystemFunction("not",	[[cXTItem, '*']],	function(oSequence1) {
+	return new cXSBoolean(!fFunction_sequence_toEBV(oSequence1, this));
+});
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+/*
+	16 Context Functions
+		position
+		last
+		current-dateTime
+		current-date
+		current-time
+		implicit-timezone
+		default-collation
+		static-base-uri
+
+*/
+// fn:position() as xs:integer
+fStaticContext_defineSystemFunction("position",	[],	function() {
+	return new cXSInteger(this.position);
+});
+
+// fn:last() as xs:integer
+fStaticContext_defineSystemFunction("last",	[],	function() {
+	return new cXSInteger(this.size);
+});
+
+// fn:current-dateTime() as xs:dateTime (2004-05-12T18:17:15.125Z)
+fStaticContext_defineSystemFunction("current-dateTime",	[],	 function() {
+	return this.dateTime;
+});
+
+// fn:current-date() as xs:date (2004-05-12+01:00)
+fStaticContext_defineSystemFunction("current-date",	[],	function() {
+	return cXSDate.cast(this.dateTime);
+});
+
+// fn:current-time() as xs:time (23:17:00.000-05:00)
+fStaticContext_defineSystemFunction("current-time",	[],	function() {
+	return cXSTime.cast(this.dateTime);
+});
+
+// fn:implicit-timezone() as xs:dayTimeDuration
+fStaticContext_defineSystemFunction("implicit-timezone",	[],	function() {
+	return this.timezone;
+});
+
+// fn:default-collation() as xs:string
+fStaticContext_defineSystemFunction("default-collation",	[],	 function() {
+	return new cXSString(this.staticContext.defaultCollationName);
+});
+
+// fn:static-base-uri() as xs:anyURI?
+fStaticContext_defineSystemFunction("static-base-uri",	[],	function() {
+	return cXSAnyURI.cast(new cXSString(this.staticContext.baseURI || ''));
+});
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+/*
+	10.5 Component Extraction Functions on Durations, Dates and Times
+		years-from-duration
+		months-from-duration
+		days-from-duration
+		hours-from-duration
+		minutes-from-duration
+		seconds-from-duration
+		year-from-dateTime
+		month-from-dateTime
+		day-from-dateTime
+		hours-from-dateTime
+		minutes-from-dateTime
+		seconds-from-dateTime
+		timezone-from-dateTime
+		year-from-date
+		month-from-date
+		day-from-date
+		timezone-from-date
+		hours-from-time
+		minutes-from-time
+		seconds-from-time
+		timezone-from-time
+
+	10.7 Timezone Adjustment Functions on Dates and Time Values
+		adjust-dateTime-to-timezone
+		adjust-date-to-timezone
+		adjust-time-to-timezone
+*/
+
+// 10.5 Component Extraction Functions on Durations, Dates and Times
+// functions on duration
+// fn:years-from-duration($arg as xs:duration?) as xs:integer?
+fStaticContext_defineSystemFunction("years-from-duration",	[[cXSDuration, '?']],	function(oDuration) {
+	return fFunction_duration_getComponent(oDuration, "year");
+});
+
+// fn:months-from-duration($arg as xs:duration?) as xs:integer?
+fStaticContext_defineSystemFunction("months-from-duration",	[[cXSDuration, '?']],	function(oDuration) {
+	return fFunction_duration_getComponent(oDuration, "month");
+});
+
+// fn:days-from-duration($arg as xs:duration?) as xs:integer?
+fStaticContext_defineSystemFunction("days-from-duration",	[[cXSDuration, '?']],	function(oDuration) {
+	return fFunction_duration_getComponent(oDuration, "day");
+});
+
+// fn:hours-from-duration($arg as xs:duration?) as xs:integer?
+fStaticContext_defineSystemFunction("hours-from-duration",	[[cXSDuration, '?']],	function(oDuration) {
+	return fFunction_duration_getComponent(oDuration, "hours");
+});
+
+// fn:minutes-from-duration($arg as xs:duration?) as xs:integer?
+fStaticContext_defineSystemFunction("minutes-from-duration",	[[cXSDuration, '?']],	function(oDuration) {
+	return fFunction_duration_getComponent(oDuration, "minutes");
+});
+
+// fn:seconds-from-duration($arg as xs:duration?) as xs:decimal?
+fStaticContext_defineSystemFunction("seconds-from-duration",	[[cXSDuration, '?']],	function(oDuration) {
+	return fFunction_duration_getComponent(oDuration, "seconds");
+});
+
+// functions on dateTime
+// fn:year-from-dateTime($arg as xs:dateTime?) as xs:integer?
+fStaticContext_defineSystemFunction("year-from-dateTime",		[[cXSDateTime, '?']],	function(oDateTime) {
+	return fFunction_dateTime_getComponent(oDateTime,	"year");
+});
+
+// fn:month-from-dateTime($arg as xs:dateTime?) as xs:integer?
+fStaticContext_defineSystemFunction("month-from-dateTime",		[[cXSDateTime, '?']],	function(oDateTime) {
+	return fFunction_dateTime_getComponent(oDateTime, "month");
+});
+
+// fn:day-from-dateTime($arg as xs:dateTime?) as xs:integer?
+fStaticContext_defineSystemFunction("day-from-dateTime",			[[cXSDateTime, '?']],	function(oDateTime) {
+	return fFunction_dateTime_getComponent(oDateTime, "day");
+});
+
+// fn:hours-from-dateTime($arg as xs:dateTime?) as xs:integer?
+fStaticContext_defineSystemFunction("hours-from-dateTime",		[[cXSDateTime, '?']],	function(oDateTime) {
+	return fFunction_dateTime_getComponent(oDateTime, "hours");
+});
+
+// fn:minutes-from-dateTime($arg as xs:dateTime?) as xs:integer?
+fStaticContext_defineSystemFunction("minutes-from-dateTime",		[[cXSDateTime, '?']],	function(oDateTime) {
+	return fFunction_dateTime_getComponent(oDateTime, "minutes");
+});
+
+// fn:seconds-from-dateTime($arg as xs:dateTime?) as xs:decimal?
+fStaticContext_defineSystemFunction("seconds-from-dateTime",		[[cXSDateTime, '?']],	function(oDateTime) {
+	return fFunction_dateTime_getComponent(oDateTime, "seconds");
+});
+
+// fn:timezone-from-dateTime($arg as xs:dateTime?) as xs:dayTimeDuration?
+fStaticContext_defineSystemFunction("timezone-from-dateTime",	[[cXSDateTime, '?']],	function(oDateTime) {
+	return fFunction_dateTime_getComponent(oDateTime, "timezone");
+});
+
+// functions on date
+// fn:year-from-date($arg as xs:date?) as xs:integer?
+fStaticContext_defineSystemFunction("year-from-date",	[[cXSDate, '?']],	function(oDate) {
+	return fFunction_dateTime_getComponent(oDate, "year");
+});
+
+// fn:month-from-date($arg as xs:date?) as xs:integer?
+fStaticContext_defineSystemFunction("month-from-date",	[[cXSDate, '?']],	function(oDate) {
+	return fFunction_dateTime_getComponent(oDate, "month");
+});
+
+// fn:day-from-date($arg as xs:date?) as xs:integer?
+fStaticContext_defineSystemFunction("day-from-date",		[[cXSDate, '?']],	function(oDate) {
+	return fFunction_dateTime_getComponent(oDate, "day");
+});
+
+// fn:timezone-from-date($arg as xs:date?) as xs:dayTimeDuration?
+fStaticContext_defineSystemFunction("timezone-from-date",	[[cXSDate, '?']],	function(oDate) {
+	return fFunction_dateTime_getComponent(oDate, "timezone");
+});
+
+// functions on time
+// fn:hours-from-time($arg as xs:time?) as xs:integer?
+fStaticContext_defineSystemFunction("hours-from-time",		[[cXSTime, '?']],	function(oTime) {
+	return fFunction_dateTime_getComponent(oTime, "hours");
+});
+
+// fn:minutes-from-time($arg as xs:time?) as xs:integer?
+fStaticContext_defineSystemFunction("minutes-from-time",		[[cXSTime, '?']],	function(oTime) {
+	return fFunction_dateTime_getComponent(oTime, "minutes");
+});
+
+// fn:seconds-from-time($arg as xs:time?) as xs:decimal?
+fStaticContext_defineSystemFunction("seconds-from-time",		[[cXSTime, '?']],	function(oTime) {
+	return fFunction_dateTime_getComponent(oTime, "seconds");
+});
+
+// fn:timezone-from-time($arg as xs:time?) as xs:dayTimeDuration?
+fStaticContext_defineSystemFunction("timezone-from-time",	[[cXSTime, '?']],	function(oTime) {
+	return fFunction_dateTime_getComponent(oTime, "timezone");
+});
+
+
+// 10.7 Timezone Adjustment Functions on Dates and Time Values
+// fn:adjust-dateTime-to-timezone($arg as xs:dateTime?) as xs:dateTime?
+// fn:adjust-dateTime-to-timezone($arg as xs:dateTime?, $timezone as xs:dayTimeDuration?) as xs:dateTime?
+fStaticContext_defineSystemFunction("adjust-dateTime-to-timezone",	[[cXSDateTime, '?'], [cXSDayTimeDuration, '?', true]],	function(oDateTime, oDayTimeDuration) {
+	return fFunction_dateTime_adjustTimezone(oDateTime, arguments.length > 1 && oDayTimeDuration != null ? arguments.length > 1 ? oDayTimeDuration : this.timezone : null);
+});
+
+// fn:adjust-date-to-timezone($arg as xs:date?) as xs:date?
+// fn:adjust-date-to-timezone($arg as xs:date?, $timezone as xs:dayTimeDuration?) as xs:date?
+fStaticContext_defineSystemFunction("adjust-date-to-timezone",		[[cXSDate, '?'], [cXSDayTimeDuration, '?', true]],	function(oDate, oDayTimeDuration) {
+	return fFunction_dateTime_adjustTimezone(oDate, arguments.length > 1 && oDayTimeDuration != null ? arguments.length > 1 ? oDayTimeDuration : this.timezone : null);
+});
+
+// fn:adjust-time-to-timezone($arg as xs:time?) as xs:time?
+// fn:adjust-time-to-timezone($arg as xs:time?, $timezone as xs:dayTimeDuration?) as xs:time?
+fStaticContext_defineSystemFunction("adjust-time-to-timezone",		[[cXSTime, '?'], [cXSDayTimeDuration, '?', true]],	function(oTime, oDayTimeDuration) {
+	return fFunction_dateTime_adjustTimezone(oTime, arguments.length > 1 && oDayTimeDuration != null ? arguments.length > 1 ? oDayTimeDuration : this.timezone : null);
+});
+
+//
+function fFunction_duration_getComponent(oDuration, sName) {
+	if (oDuration == null)
+		return null;
+
+	var nValue	= oDuration[sName] * (oDuration.negative ?-1 : 1);
+	return sName == "seconds" ? new cXSDecimal(nValue) : new cXSInteger(nValue);
+};
+
+//
+function fFunction_dateTime_getComponent(oDateTime, sName) {
+	if (oDateTime == null)
+		return null;
+
+	if (sName == "timezone") {
+		var nTimezone	= oDateTime.timezone;
+		if (nTimezone == null)
+			return null;
+		return new cXSDayTimeDuration(0, cMath.abs(~~(nTimezone / 60)), cMath.abs(nTimezone % 60), 0, nTimezone < 0);
+	}
+	else {
+		var nValue	= oDateTime[sName];
+		if (!(oDateTime instanceof cXSDate)) {
+			if (sName == "hours")
+				if (nValue == 24)
+					nValue	= 0;
+		}
+		if (!(oDateTime instanceof cXSTime))
+			nValue	*= oDateTime.negative ?-1 : 1;
+		return sName == "seconds" ? new cXSDecimal(nValue) : new cXSInteger(nValue);
+	}
+};
+
+//
+function fFunction_dateTime_adjustTimezone(oDateTime, oTimezone) {
+	if (oDateTime == null)
+		return null;
+
+	// Create a copy
+	var oValue;
+	if (oDateTime instanceof cXSDate)
+		oValue	= new cXSDate(oDateTime.year, oDateTime.month, oDateTime.day, oDateTime.timezone, oDateTime.negative);
+	else
+	if (oDateTime instanceof cXSTime)
+		oValue	= new cXSTime(oDateTime.hours, oDateTime.minutes, oDateTime.seconds, oDateTime.timezone, oDateTime.negative);
+	else
+		oValue	= new cXSDateTime(oDateTime.year, oDateTime.month, oDateTime.day, oDateTime.hours, oDateTime.minutes, oDateTime.seconds, oDateTime.timezone, oDateTime.negative);
+
+	//
+	if (oTimezone == null)
+		oValue.timezone	= null;
+	else {
+		var nTimezone	= fOperator_dayTimeDuration_toSeconds(oTimezone) / 60;
+		if (oDateTime.timezone != null) {
+			var nDiff	= nTimezone - oDateTime.timezone;
+			if (oDateTime instanceof cXSDate) {
+				if (nDiff < 0)
+					oValue.day--;
+			}
+			else {
+				oValue.minutes	+= nDiff % 60;
+				oValue.hours	+= ~~(nDiff / 60);
+			}
+			//
+			fXSDateTime_normalize(oValue);
+		}
+		oValue.timezone	= nTimezone;
+	}
+	return oValue;
+};
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+/*
+	14 Functions and Operators on Nodes
+		name
+		local-name
+		namespace-uri
+		number
+		lang
+		root
+
+*/
+
+// 14 Functions on Nodes
+// fn:name() as xs:string
+// fn:name($arg as node()?) as xs:string
+fStaticContext_defineSystemFunction("name",	[[cXTNode, '?', true]],	function(oNode) {
+	if (!arguments.length) {
+		if (!this.DOMAdapter.isNode(this.item))
+			throw new cException("XPTY0004"
+
+			);
+		oNode	= this.item;
+	}
+	else
+	if (oNode == null)
+		return new cXSString('');
+	//
+	var vValue	= hStaticContext_functions["node-name"].call(this, oNode);
+	return new cXSString(vValue == null ? '' : vValue.toString());
+});
+
+// fn:local-name() as xs:string
+// fn:local-name($arg as node()?) as xs:string
+fStaticContext_defineSystemFunction("local-name",	[[cXTNode, '?', true]],	function(oNode) {
+	if (!arguments.length) {
+		if (!this.DOMAdapter.isNode(this.item))
+			throw new cException("XPTY0004"
+
+			);
+		oNode	= this.item;
+	}
+	else
+	if (oNode == null)
+		return new cXSString('');
+	//
+	return new cXSString(this.DOMAdapter.getProperty(oNode, "localName") || '');
+});
+
+// fn:namespace-uri() as xs:anyURI
+// fn:namespace-uri($arg as node()?) as xs:anyURI
+fStaticContext_defineSystemFunction("namespace-uri",	[[cXTNode, '?', true]],	function(oNode) {
+	if (!arguments.length) {
+		if (!this.DOMAdapter.isNode(this.item))
+			throw new cException("XPTY0004"
+
+			);
+		oNode	= this.item;
+	}
+	else
+	if (oNode == null)
+		return cXSAnyURI.cast(new cXSString(''));
+	//
+	return cXSAnyURI.cast(new cXSString(this.DOMAdapter.getProperty(oNode, "namespaceURI") || ''));
+});
+
+// fn:number() as xs:double
+// fn:number($arg as xs:anyAtomicType?) as xs:double
+fStaticContext_defineSystemFunction("number",	[[cXSAnyAtomicType, '?', true]],	function(/*[*/oItem/*]*/) {
+	if (!arguments.length) {
+		if (!this.item)
+			throw new cException("XPDY0002");
+		oItem	= fFunction_sequence_atomize([this.item], this)[0];
+	}
+
+	// If input item cannot be cast to xs:decimal, a NaN should be returned
+	var vValue	= new cXSDouble(nNaN);
+	if (oItem != null) {
+		try {
+			vValue	= cXSDouble.cast(oItem);
+		}
+		catch (e) {
+
+		}
+	}
+	return vValue;
+});
+
+// fn:lang($testlang as xs:string?) as xs:boolean
+// fn:lang($testlang as xs:string?, $node as node()) as xs:boolean
+fStaticContext_defineSystemFunction("lang",	[[cXSString, '?'], [cXTNode, '', true]],	function(sLang, oNode) {
+	if (arguments.length < 2) {
+		if (!this.DOMAdapter.isNode(this.item))
+			throw new cException("XPTY0004"
+
+			);
+		oNode	= this.item;
+	}
+
+	var fGetProperty	= this.DOMAdapter.getProperty;
+	if (fGetProperty(oNode, "nodeType") == 2)
+		oNode	= fGetProperty(oNode, "ownerElement");
+
+	// walk up the tree looking for xml:lang attribute
+	for (var aAttributes; oNode; oNode = fGetProperty(oNode, "parentNode"))
+		if (aAttributes = fGetProperty(oNode, "attributes"))
+			for (var nIndex = 0, nLength = aAttributes.length; nIndex < nLength; nIndex++)
+				if (fGetProperty(aAttributes[nIndex], "nodeName") == "xml:lang")
+					return new cXSBoolean(fGetProperty(aAttributes[nIndex], "value").replace(/-.+/, '').toLowerCase() == sLang.valueOf().replace(/-.+/, '').toLowerCase());
+	//
+	return new cXSBoolean(false);
+});
+
+// fn:root() as node()
+// fn:root($arg as node()?) as node()?
+fStaticContext_defineSystemFunction("root",	[[cXTNode, '?', true]],	function(oNode) {
+	if (!arguments.length) {
+		if (!this.DOMAdapter.isNode(this.item))
+			throw new cException("XPTY0004"
+
+			);
+		oNode	= this.item;
+	}
+	else
+	if (oNode == null)
+		return null;
+
+	var fGetProperty	= this.DOMAdapter.getProperty;
+
+	// If context node is Attribute
+	if (fGetProperty(oNode, "nodeType") == 2)
+		oNode	= fGetProperty(oNode, "ownerElement");
+
+	for (var oParent = oNode; oParent; oParent = fGetProperty(oNode, "parentNode"))
+		oNode	= oParent;
+
+	return oNode;
+});
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+/*
+	6.4 Functions on Numeric Values
+		abs
+		ceiling
+		floor
+		round
+		round-half-to-even
+*/
+
+// 6.4 Functions on Numeric Values
+// fn:abs($arg as numeric?) as numeric?
+fStaticContext_defineSystemFunction("abs",		[[cXSDouble, '?']],	function(oValue) {
+	return new cXSDecimal(cMath.abs(oValue));
+});
+
+// fn:ceiling($arg as numeric?) as numeric?
+fStaticContext_defineSystemFunction("ceiling",	[[cXSDouble, '?']],	function(oValue) {
+	return new cXSDecimal(cMath.ceil(oValue));
+});
+
+// fn:floor($arg as numeric?) as numeric?
+fStaticContext_defineSystemFunction("floor",		[[cXSDouble, '?']],	function(oValue) {
+	return new cXSDecimal(cMath.floor(oValue));
+});
+
+// fn:round($arg as numeric?) as numeric?
+fStaticContext_defineSystemFunction("round",		[[cXSDouble, '?']],	function(oValue) {
+	return new cXSDecimal(cMath.round(oValue));
+});
+
+// fn:round-half-to-even($arg as numeric?) as numeric?
+// fn:round-half-to-even($arg as numeric?, $precision as xs:integer) as numeric?
+fStaticContext_defineSystemFunction("round-half-to-even",	[[cXSDouble, '?'], [cXSInteger, '', true]],	function(oValue, oPrecision) {
+	var nPrecision	= arguments.length > 1 ? oPrecision.valueOf() : 0;
+
+	//
+	if (nPrecision < 0) {
+		var oPower	= new cXSInteger(cMath.pow(10,-nPrecision)),
+			nRounded= cMath.round(hStaticContext_operators["numeric-divide"].call(this, oValue, oPower)),
+			oRounded= new cXSInteger(nRounded);
+			nDecimal= cMath.abs(hStaticContext_operators["numeric-subtract"].call(this, oRounded, hStaticContext_operators["numeric-divide"].call(this, oValue, oPower)));
+		return hStaticContext_operators["numeric-multiply"].call(this, hStaticContext_operators["numeric-add"].call(this, oRounded, new cXSDecimal(nDecimal == 0.5 && nRounded % 2 ?-1 : 0)), oPower);
+	}
+	else {
+		var oPower	= new cXSInteger(cMath.pow(10, nPrecision)),
+			nRounded= cMath.round(hStaticContext_operators["numeric-multiply"].call(this, oValue, oPower)),
+			oRounded= new cXSInteger(nRounded);
+			nDecimal= cMath.abs(hStaticContext_operators["numeric-subtract"].call(this, oRounded, hStaticContext_operators["numeric-multiply"].call(this, oValue, oPower)));
+		return hStaticContext_operators["numeric-divide"].call(this, hStaticContext_operators["numeric-add"].call(this, oRounded, new cXSDecimal(nDecimal == 0.5 && nRounded % 2 ?-1 : 0)), oPower);
+	}
+});
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+/*
+	11.1 Additional Constructor Functions for QNames
+		resolve-QName
+		QName
+
+	11.2 Functions and Operators Related to QNames
+		prefix-from-QName
+		local-name-from-QName
+		namespace-uri-from-QName
+		namespace-uri-for-prefix
+		in-scope-prefixes
+
+*/
+
+// 11.1 Additional Constructor Functions for QNames
+// fn:resolve-QName($qname as xs:string?, $element as element()) as xs:QName?
+fStaticContext_defineSystemFunction("resolve-QName",	[[cXSString, '?'], [cXTElement]],	function(oQName, oElement) {
+	if (oQName == null)
+		return null;
+
+	var sQName	= oQName.valueOf(),
+		aMatch	= sQName.match(rXSQName);
+	if (!aMatch)
+		throw new cException("FOCA0002"
+
+		);
+
+	var sPrefix	= aMatch[1] || null,
+		sLocalName	= aMatch[2],
+		sNameSpaceURI = this.DOMAdapter.lookupNamespaceURI(oElement, sPrefix);
+	//
+	if (sPrefix != null &&!sNameSpaceURI)
+		throw new cException("FONS0004"
+
+		);
+
+	return new cXSQName(sPrefix, sLocalName, sNameSpaceURI || null);
+});
+
+// fn:QName($paramURI as xs:string?, $paramQName as xs:string) as xs:QName
+fStaticContext_defineSystemFunction("QName",		[[cXSString, '?'], [cXSString]],	function(oUri, oQName) {
+	var sQName	= oQName.valueOf(),
+		aMatch	= sQName.match(rXSQName);
+
+	if (!aMatch)
+		throw new cException("FOCA0002"
+
+		);
+
+	return new cXSQName(aMatch[1] || null, aMatch[2] || null, oUri == null ? '' : oUri.valueOf());
+});
+
+// 11.2 Functions Related to QNames
+// fn:prefix-from-QName($arg as xs:QName?) as xs:NCName?
+fStaticContext_defineSystemFunction("prefix-from-QName",			[[cXSQName, '?']],	function(oQName) {
+	if (oQName != null) {
+		if (oQName.prefix)
+			return new cXSNCName(oQName.prefix);
+	}
+	//
+	return null;
+});
+
+// fn:local-name-from-QName($arg as xs:QName?) as xs:NCName?
+fStaticContext_defineSystemFunction("local-name-from-QName",		[[cXSQName, '?']],	function(oQName) {
+	if (oQName == null)
+		return null;
+
+	return new cXSNCName(oQName.localName);
+});
+
+// fn:namespace-uri-from-QName($arg as xs:QName?) as xs:anyURI?
+fStaticContext_defineSystemFunction("namespace-uri-from-QName",	[[cXSQName, '?']],	function(oQName) {
+	if (oQName == null)
+		return null;
+
+	return cXSAnyURI.cast(new cXSString(oQName.namespaceURI || ''));
+});
+
+// fn:namespace-uri-for-prefix($prefix as xs:string?, $element as element()) as xs:anyURI?
+fStaticContext_defineSystemFunction("namespace-uri-for-prefix",	[[cXSString, '?'], [cXTElement]],	function(oPrefix, oElement) {
+	var sPrefix	= oPrefix == null ? '' : oPrefix.valueOf(),
+		sNameSpaceURI	= this.DOMAdapter.lookupNamespaceURI(oElement, sPrefix || null);
+
+	return sNameSpaceURI == null ? null : cXSAnyURI.cast(new cXSString(sNameSpaceURI));
+});
+
+// fn:in-scope-prefixes($element as element()) as xs:string*
+fStaticContext_defineSystemFunction("in-scope-prefixes",	[[cXTElement]],	function(oElement) {
+	throw "Function '" + "in-scope-prefixes" + "' not implemented";
+});
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+/*
+	15.1 General Functions and Operators on Sequences
+		boolean
+		index-of
+		empty
+		exists
+		distinct-values
+		insert-before
+		remove
+		reverse
+		subsequence
+		unordered
+
+	15.2 Functions That Test the Cardinality of Sequences
+		zero-or-one
+		one-or-more
+		exactly-one
+
+	15.3 Equals, Union, Intersection and Except
+		deep-equal
+
+	15.4 Aggregate Functions
+		count
+		avg
+		max
+		min
+		sum
+
+	15.5 Functions and Operators that Generate Sequences
+		id
+		idref
+		doc
+		doc-available
+		collection
+		element-with-id
+
+*/
+
+// 15.1 General Functions and Operators on Sequences
+// fn:boolean($arg as item()*) as xs:boolean
+fStaticContext_defineSystemFunction("boolean",	[[cXTItem, '*']],	function(oSequence1) {
+	return new cXSBoolean(fFunction_sequence_toEBV(oSequence1, this));
+});
+
+// fn:index-of($seqParam as xs:anyAtomicType*, $srchParam as xs:anyAtomicType) as xs:integer*
+// fn:index-of($seqParam as xs:anyAtomicType*, $srchParam as xs:anyAtomicType, $collation as xs:string) as xs:integer*
+fStaticContext_defineSystemFunction("index-of",	[[cXSAnyAtomicType, '*'], [cXSAnyAtomicType], [cXSString, '', true]],	function(oSequence1, oSearch, oCollation) {
+	if (!oSequence1.length || oSearch == null)
+		return [];
+
+	// TODO: Implement collation
+
+	var vLeft	= oSearch;
+	// Cast to XSString if Untyped
+	if (vLeft instanceof cXSUntypedAtomic)
+		vLeft	= cXSString.cast(vLeft);
+
+	var oSequence	= [];
+	for (var nIndex = 0, nLength = oSequence1.length, vRight; nIndex < nLength; nIndex++) {
+		vRight	= oSequence1[nIndex];
+		// Cast to XSString if Untyped
+		if (vRight instanceof cXSUntypedAtomic)
+			vRight	= cXSString.cast(vRight);
+		//
+		if (vRight.valueOf() === vLeft.valueOf())
+			oSequence.push(new cXSInteger(nIndex + 1));
+	}
+
+	return oSequence;
+});
+
+// fn:empty($arg as item()*) as xs:boolean
+fStaticContext_defineSystemFunction("empty",	[[cXTItem, '*']],	function(oSequence1) {
+	return new cXSBoolean(!oSequence1.length);
+});
+
+// fn:exists($arg as item()*) as xs:boolean
+fStaticContext_defineSystemFunction("exists",	[[cXTItem, '*']],	function(oSequence1) {
+	return new cXSBoolean(!!oSequence1.length);
+});
+
+// fn:distinct-values($arg as xs:anyAtomicType*) as xs:anyAtomicType*
+// fn:distinct-values($arg as xs:anyAtomicType*, $collation as xs:string) as xs:anyAtomicType*
+fStaticContext_defineSystemFunction("distinct-values",	[[cXSAnyAtomicType, '*'], [cXSString, '', true]],	function(oSequence1, oCollation) {
+	if (arguments.length > 1)
+		throw "Collation parameter in function '" + "distinct-values" + "' is not implemented";
+
+	if (!oSequence1.length)
+		return null;
+
+	var oSequence	= [];
+	for (var nIndex = 0, nLength = oSequence1.length, vLeft; nIndex < nLength; nIndex++) {
+		vLeft	= oSequence1[nIndex];
+		// Cast to XSString if Untyped
+		if (vLeft instanceof cXSUntypedAtomic)
+			vLeft	= cXSString.cast(vLeft);
+		for (var nRightIndex = 0, nRightLength = oSequence.length, vRight, bFound = false; (nRightIndex < nRightLength) &&!bFound; nRightIndex++) {
+			vRight	= oSequence[nRightIndex];
+			// Cast to XSString if Untyped
+			if (vRight instanceof cXSUntypedAtomic)
+				vRight	= cXSString.cast(vRight);
+			//
+			if (vRight.valueOf() === vLeft.valueOf())
+				bFound	= true;
+		}
+		if (!bFound)
+			oSequence.push(oSequence1[nIndex]);
+	}
+
+	return oSequence;
+});
+
+// fn:insert-before($target as item()*, $position as xs:integer, $inserts as item()*) as item()*
+fStaticContext_defineSystemFunction("insert-before",	[[cXTItem, '*'], [cXSInteger], [cXTItem, '*']],	function(oSequence1, oPosition, oSequence3) {
+	if (!oSequence1.length)
+		return oSequence3;
+	if (!oSequence3.length)
+		return oSequence1;
+
+	var nLength 	= oSequence1.length,
+		nPosition	= oPosition.valueOf();
+	if (nPosition < 1)
+		nPosition	= 1;
+	else
+	if (nPosition > nLength)
+		nPosition	= nLength + 1;
+
+	var oSequence	=  [];
+	for (var nIndex = 0; nIndex < nLength; nIndex++) {
+		if (nPosition == nIndex + 1)
+			oSequence	= oSequence.concat(oSequence3);
+		oSequence.push(oSequence1[nIndex]);
+	}
+	if (nPosition == nIndex + 1)
+		oSequence	= oSequence.concat(oSequence3);
+
+	return oSequence;
+});
+
+// fn:remove($target as item()*, $position as xs:integer) as item()*
+fStaticContext_defineSystemFunction("remove",	[[cXTItem, '*'], [cXSInteger]],	function(oSequence1, oPosition) {
+	if (!oSequence1.length)
+		return [];
+
+	var nLength 	= oSequence1.length,
+		nPosition	= oPosition.valueOf();
+
+	if (nPosition < 1 || nPosition > nLength)
+		return oSequence1;
+
+	var oSequence	=  [];
+	for (var nIndex = 0; nIndex < nLength; nIndex++)
+		if (nPosition != nIndex + 1)
+			oSequence.push(oSequence1[nIndex]);
+
+	return oSequence;
+});
+
+// fn:reverse($arg as item()*) as item()*
+fStaticContext_defineSystemFunction("reverse",	[[cXTItem, '*']],	function(oSequence1) {
+	oSequence1.reverse();
+
+	return oSequence1;
+});
+
+// fn:subsequence($sourceSeq as item()*, $startingLoc as xs:double) as item()*
+// fn:subsequence($sourceSeq as item()*, $startingLoc as xs:double, $length as xs:double) as item()*
+fStaticContext_defineSystemFunction("subsequence",	[[cXTItem, '*'], [cXSDouble, ''], [cXSDouble, '', true]],	function(oSequence1, oStart, oLength) {
+	var nPosition	= cMath.round(oStart),
+		nLength		= arguments.length > 2 ? cMath.round(oLength) : oSequence1.length - nPosition + 1;
+
+	// TODO: Handle out-of-range position and length values
+	return oSequence1.slice(nPosition - 1, nPosition - 1 + nLength);
+});
+
+// fn:unordered($sourceSeq as item()*) as item()*
+fStaticContext_defineSystemFunction("unordered",	[[cXTItem, '*']],	function(oSequence1) {
+	return oSequence1;
+});
+
+
+// 15.2 Functions That Test the Cardinality of Sequences
+// fn:zero-or-one($arg as item()*) as item()?
+fStaticContext_defineSystemFunction("zero-or-one",	[[cXTItem, '*']],	function(oSequence1) {
+	if (oSequence1.length > 1)
+		throw new cException("FORG0003");
+
+	return oSequence1;
+});
+
+// fn:one-or-more($arg as item()*) as item()+
+fStaticContext_defineSystemFunction("one-or-more",	[[cXTItem, '*']],	function(oSequence1) {
+	if (!oSequence1.length)
+		throw new cException("FORG0004");
+
+	return oSequence1;
+});
+
+// fn:exactly-one($arg as item()*) as item()
+fStaticContext_defineSystemFunction("exactly-one",	[[cXTItem, '*']],	function(oSequence1) {
+	if (oSequence1.length != 1)
+		throw new cException("FORG0005");
+
+	return oSequence1;
+});
+
+
+// 15.3 Equals, Union, Intersection and Except
+// fn:deep-equal($parameter1 as item()*, $parameter2 as item()*) as xs:boolean
+// fn:deep-equal($parameter1 as item()*, $parameter2 as item()*, $collation as string) as xs:boolean
+fStaticContext_defineSystemFunction("deep-equal",	[[cXTItem, '*'], [cXTItem, '*'], [cXSString, '', true]],	function(oSequence1, oSequence2, oCollation) {
+	throw "Function '" + "deep-equal" + "' not implemented";
+});
+
+
+// 15.4 Aggregate Functions
+// fn:count($arg as item()*) as xs:integer
+fStaticContext_defineSystemFunction("count",	[[cXTItem, '*']],	function(oSequence1) {
+	return new cXSInteger(oSequence1.length);
+});
+
+// fn:avg($arg as xs:anyAtomicType*) as xs:anyAtomicType?
+fStaticContext_defineSystemFunction("avg",	[[cXSAnyAtomicType, '*']],	function(oSequence1) {
+	if (!oSequence1.length)
+		return null;
+
+	//
+	try {
+		var vValue	= oSequence1[0];
+		if (vValue instanceof cXSUntypedAtomic)
+			vValue	= cXSDouble.cast(vValue);
+		for (var nIndex = 1, nLength = oSequence1.length, vRight; nIndex < nLength; nIndex++) {
+			vRight	= oSequence1[nIndex];
+			if (vRight instanceof cXSUntypedAtomic)
+				vRight	= cXSDouble.cast(vRight);
+			vValue	= hAdditiveExpr_operators['+'](vValue, vRight, this);
+		}
+		return hMultiplicativeExpr_operators['div'](vValue, new cXSInteger(nLength), this);
+	}
+	catch (e) {
+		// XPTY0004: Arithmetic operator is not defined for provided arguments
+		throw e.code != "XPTY0004" ? e : new cException("FORG0006"
+
+		);
+	}
+});
+
+// fn:max($arg as xs:anyAtomicType*) as xs:anyAtomicType?
+// fn:max($arg as xs:anyAtomicType*, $collation as string) as xs:anyAtomicType?
+fStaticContext_defineSystemFunction("max",	[[cXSAnyAtomicType, '*'], [cXSString, '', true]],	function(oSequence1, oCollation) {
+	if (!oSequence1.length)
+		return null;
+
+	// TODO: Implement collation
+
+	//
+	try {
+		var vValue	= oSequence1[0];
+		if (vValue instanceof cXSUntypedAtomic)
+			vValue	= cXSDouble.cast(vValue);
+		for (var nIndex = 1, nLength = oSequence1.length, vRight; nIndex < nLength; nIndex++) {
+			vRight	= oSequence1[nIndex];
+			if (vRight instanceof cXSUntypedAtomic)
+				vRight	= cXSDouble.cast(vRight);
+			if (hComparisonExpr_ValueComp_operators['ge'](vRight, vValue, this).valueOf())
+				vValue	= vRight;
+		}
+		return vValue;
+	}
+	catch (e) {
+		// XPTY0004: Cannot compare {type1} with {type2}
+		throw e.code != "XPTY0004" ? e : new cException("FORG0006"
+
+		);
+	}
+});
+
+// fn:min($arg as xs:anyAtomicType*) as xs:anyAtomicType?
+// fn:min($arg as xs:anyAtomicType*, $collation as string) as xs:anyAtomicType?
+fStaticContext_defineSystemFunction("min",	[[cXSAnyAtomicType, '*'], [cXSString, '', true]],	function(oSequence1, oCollation) {
+	if (!oSequence1.length)
+		return null;
+
+	// TODO: Implement collation
+
+	//
+	try {
+		var vValue	= oSequence1[0];
+		if (vValue instanceof cXSUntypedAtomic)
+			vValue	= cXSDouble.cast(vValue);
+		for (var nIndex = 1, nLength = oSequence1.length, vRight; nIndex < nLength; nIndex++) {
+			vRight	= oSequence1[nIndex];
+			if (vRight instanceof cXSUntypedAtomic)
+				vRight	= cXSDouble.cast(vRight);
+			if (hComparisonExpr_ValueComp_operators['le'](vRight, vValue, this).valueOf())
+				vValue	= vRight;
+			}
+		return vValue;
+	}
+	catch (e) {
+		// Cannot compare {type1} with {type2}
+		throw e.code != "XPTY0004" ? e : new cException("FORG0006"
+
+		);
+	}
+});
+
+// fn:sum($arg as xs:anyAtomicType*) as xs:anyAtomicType
+// fn:sum($arg as xs:anyAtomicType*, $zero as xs:anyAtomicType?) as xs:anyAtomicType?
+fStaticContext_defineSystemFunction("sum",	[[cXSAnyAtomicType, '*'], [cXSAnyAtomicType, '?', true]],	function(oSequence1, oZero) {
+	if (!oSequence1.length) {
+		if (arguments.length > 1)
+			return oZero;
+		else
+			return new cXSDouble(0);
+
+		return null;
+	}
+
+	// TODO: Implement collation
+
+	//
+	try {
+		var vValue	= oSequence1[0];
+		if (vValue instanceof cXSUntypedAtomic)
+			vValue	= cXSDouble.cast(vValue);
+		for (var nIndex = 1, nLength = oSequence1.length, vRight; nIndex < nLength; nIndex++) {
+			vRight	= oSequence1[nIndex];
+			if (vRight instanceof cXSUntypedAtomic)
+				vRight	= cXSDouble.cast(vRight);
+			vValue	= hAdditiveExpr_operators['+'](vValue, vRight, this);
+		}
+		return vValue;
+	}
+	catch (e) {
+		// XPTY0004: Arithmetic operator is not defined for provided arguments
+		throw e.code != "XPTY0004" ? e : new cException("FORG0006"
+
+		);
+	}
+});
+
+
+// 15.5 Functions and Operators that Generate Sequences
+// fn:id($arg as xs:string*) as element()*
+// fn:id($arg as xs:string*, $node as node()) as element()*
+fStaticContext_defineSystemFunction("id",	[[cXSString, '*'], [cXTNode, '', true]],	function(oSequence1, oNode) {
+	if (arguments.length < 2) {
+		if (!this.DOMAdapter.isNode(this.item))
+			throw new cException("XPTY0004"
+
+			);
+		oNode	= this.item;
+	}
+
+	// Get root node and check if it is Document
+	var oDocument	= hStaticContext_functions["root"].call(this, oNode);
+	if (this.DOMAdapter.getProperty(oDocument, "nodeType") != 9)
+		throw new cException("FODC0001");
+
+	// Search for elements
+	var oSequence	= [];
+	for (var nIndex = 0; nIndex < oSequence1.length; nIndex++)
+		for (var nRightIndex = 0, aValue = fString_trim(oSequence1[nIndex]).split(/\s+/), nRightLength = aValue.length; nRightIndex < nRightLength; nRightIndex++)
+			if ((oNode = this.DOMAdapter.getElementById(oDocument, aValue[nRightIndex])) && fArray_indexOf(oSequence, oNode) ==-1)
+				oSequence.push(oNode);
+	//
+	return fFunction_sequence_order(oSequence, this);
+});
+
+// fn:idref($arg as xs:string*) as node()*
+// fn:idref($arg as xs:string*, $node as node()) as node()*
+fStaticContext_defineSystemFunction("idref",	[[cXSString, '*'], [cXTNode, '', true]],	function(oSequence1, oNode) {
+	throw "Function '" + "idref" + "' not implemented";
+});
+
+// fn:doc($uri as xs:string?) as document-node()?
+fStaticContext_defineSystemFunction("doc",			[[cXSString, '?', true]],	function(oUri) {
+	throw "Function '" + "doc" + "' not implemented";
+});
+
+// fn:doc-available($uri as xs:string?) as xs:boolean
+fStaticContext_defineSystemFunction("doc-available",	[[cXSString, '?', true]],	function(oUri) {
+	throw "Function '" + "doc-available" + "' not implemented";
+});
+
+// fn:collection() as node()*
+// fn:collection($arg as xs:string?) as node()*
+fStaticContext_defineSystemFunction("collection",	[[cXSString, '?', true]],	function(oUri) {
+	throw "Function '" + "collection" + "' not implemented";
+});
+
+// fn:element-with-id($arg as xs:string*) as element()*
+// fn:element-with-id($arg as xs:string*, $node as node()) as element()*
+fStaticContext_defineSystemFunction("element-with-id",	[[cXSString, '*'], [cXTNode, '', true]],	function(oSequence1, oNode) {
+	throw "Function '" + "element-with-id" + "' not implemented";
+});
+
+// EBV calculation
+function fFunction_sequence_toEBV(oSequence1, oContext) {
+	if (!oSequence1.length)
+		return false;
+
+	var oItem	= oSequence1[0];
+	if (oContext.DOMAdapter.isNode(oItem))
+		return true;
+
+	if (oSequence1.length == 1) {
+		if (oItem instanceof cXSBoolean)
+			return oItem.value.valueOf();
+		if (oItem instanceof cXSString)
+			return !!oItem.valueOf().length;
+		if (fXSAnyAtomicType_isNumeric(oItem))
+			return !(fIsNaN(oItem.valueOf()) || oItem.valueOf() == 0);
+
+		throw new cException("FORG0006"
+
+		);
+	}
+
+	throw new cException("FORG0006"
+
+	);
+};
+
+function fFunction_sequence_atomize(oSequence1, oContext) {
+	var oSequence	= [];
+	for (var nIndex = 0, nLength = oSequence1.length, oItem, vItem; nIndex < nLength; nIndex++) {
+		oItem	= oSequence1[nIndex];
+		vItem	= null;
+		// Untyped
+		if (oItem == null)
+			vItem	= null;
+		// Node type
+		else
+		if (oContext.DOMAdapter.isNode(oItem)) {
+			var fGetProperty	= oContext.DOMAdapter.getProperty;
+			switch (fGetProperty(oItem, "nodeType")) {
+				case 1:	// ELEMENT_NODE
+					vItem	= new cXSUntypedAtomic(fGetProperty(oItem, "textContent"));
+					break;
+				case 2:	// ATTRIBUTE_NODE
+					vItem	= new cXSUntypedAtomic(fGetProperty(oItem, "value"));
+					break;
+				case 3:	// TEXT_NODE
+				case 4:	// CDATA_SECTION_NODE
+				case 8:	// COMMENT_NODE
+					vItem	= new cXSUntypedAtomic(fGetProperty(oItem, "data"));
+					break;
+				case 7:	// PROCESSING_INSTRUCTION_NODE
+					vItem	= new cXSUntypedAtomic(fGetProperty(oItem, "data"));
+					break;
+				case 9:	// DOCUMENT_NODE
+					var oNode	= fGetProperty(oItem, "documentElement");
+					vItem	= new cXSUntypedAtomic(oNode ? fGetProperty(oNode, "textContent") : '');
+					break;
+			}
+		}
+		// Base types
+		else
+		if (oItem instanceof cXSAnyAtomicType)
+			vItem	= oItem;
+
+		//
+		if (vItem != null)
+			oSequence.push(vItem);
+	}
+
+	return oSequence;
+};
+
+// Orders items in sequence in document order
+function fFunction_sequence_order(oSequence1, oContext) {
+	return oSequence1.sort(function(oNode, oNode2) {
+		var nPosition	= oContext.DOMAdapter.compareDocumentPosition(oNode, oNode2);
+		return nPosition & 2 ? 1 : nPosition & 4 ?-1 : 0;
+	});
+};
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+/*
+	7.2 Functions to Assemble and Disassemble Strings
+		codepoints-to-string
+		string-to-codepoints
+
+	7.3 Equality and Comparison of Strings
+		compare
+		codepoint-equal
+
+	7.4 Functions on String Values
+		concat
+		string-join
+		substring
+		string-length
+		normalize-space
+		normalize-unicode
+		upper-case
+		lower-case
+		translate
+		encode-for-uri
+		iri-to-uri
+		escape-html-uri
+
+	7.5 Functions Based on Substring Matching
+		contains
+		starts-with
+		ends-with
+		substring-before
+		substring-after
+
+	7.6 String Functions that Use Pattern Matching
+		matches
+		replace
+		tokenize
+*/
+
+// 7.2 Functions to Assemble and Disassemble Strings
+// fn:codepoints-to-string($arg as xs:integer*) as xs:string
+fStaticContext_defineSystemFunction("codepoints-to-string",	[[cXSInteger, '*']],	function(oSequence1) {
+	var aValue	= [];
+	for (var nIndex = 0, nLength = oSequence1.length; nIndex < nLength; nIndex++)
+		aValue.push(cString.fromCharCode(oSequence1[nIndex]));
+
+	return new cXSString(aValue.join(''));
+});
+
+// fn:string-to-codepoints($arg as xs:string?) as xs:integer*
+fStaticContext_defineSystemFunction("string-to-codepoints",	[[cXSString, '?']],	function(oValue) {
+	if (oValue == null)
+		return null;
+
+	var sValue	= oValue.valueOf();
+	if (sValue == '')
+		return [];
+
+	var oSequence	= [];
+	for (var nIndex = 0, nLength = sValue.length; nIndex < nLength; nIndex++)
+		oSequence.push(new cXSInteger(sValue.charCodeAt(nIndex)));
+
+	return oSequence;
+});
+
+// 7.3 Equality and Comparison of Strings
+// fn:compare($comparand1 as xs:string?, $comparand2 as xs:string?) as xs:integer?
+// fn:compare($comparand1 as xs:string?, $comparand2 as xs:string?, $collation as xs:string) as xs:integer?
+fStaticContext_defineSystemFunction("compare",	[[cXSString, '?'], [cXSString, '?'], [cXSString, '', true]],	function(oValue1, oValue2, oCollation) {
+	if (oValue1 == null || oValue2 == null)
+		return null;
+
+	var sCollation	= this.staticContext.defaultCollationName,
+		vCollation;
+	if (arguments.length > 2)
+		sCollation	= oCollation.valueOf();
+
+	vCollation	= sCollation == sNS_XPF + "/collation/codepoint" ? oCodepointStringCollator : this.staticContext.getCollation(sCollation);
+	if (!vCollation)
+		throw new cException("FOCH0002"
+
+		);
+
+	return new cXSInteger(vCollation.compare(oValue1.valueOf(), oValue2.valueOf()));
+});
+
+// fn:codepoint-equal($comparand1 as xs:string?, $comparand2  as xs:string?) as xs:boolean?
+fStaticContext_defineSystemFunction("codepoint-equal",	[[cXSString, '?'], [cXSString, '?']],	function(oValue1, oValue2) {
+	if (oValue1 == null || oValue2 == null)
+		return null;
+
+	// TODO: Check if JS uses 'Unicode code point collation' here
+
+	return new cXSBoolean(oValue1.valueOf() == oValue2.valueOf());
+});
+
+
+// 7.4 Functions on String Values
+// fn:concat($arg1 as xs:anyAtomicType?, $arg2 as xs:anyAtomicType?, ...) as xs:string
+fStaticContext_defineSystemFunction("concat",	null,	function() {
+	// check arguments length
+	if (arguments.length < 2)
+		throw new cException("XPST0017"
+
+		);
+
+	var aValue	= [];
+	for (var nIndex = 0, nLength = arguments.length, oSequence; nIndex < nLength; nIndex++) {
+		oSequence	= arguments[nIndex];
+		// Assert cardinality
+		fFunctionCall_assertSequenceCardinality(this, oSequence, '?'
+
+		);
+		//
+		if (oSequence.length)
+			aValue[aValue.length]	= cXSString.cast(fFunction_sequence_atomize(oSequence, this)[0]).valueOf();
+	}
+
+	return new cXSString(aValue.join(''));
+});
+
+// fn:string-join($arg1 as xs:string*, $arg2 as xs:string) as xs:string
+fStaticContext_defineSystemFunction("string-join",	[[cXSString, '*'], [cXSString]],	function(oSequence1, oValue) {
+	return new cXSString(oSequence1.join(oValue));
+});
+
+// fn:substring($sourceString as xs:string?, $startingLoc as xs:double) as xs:string
+// fn:substring($sourceString as xs:string?, $startingLoc as xs:double, $length as xs:double) as xs:string
+fStaticContext_defineSystemFunction("substring",	[[cXSString, '?'], [cXSDouble], [cXSDouble, '', true]],	function(oValue, oStart, oLength) {
+	var sValue	= oValue == null ? '' : oValue.valueOf(),
+		nStart	= cMath.round(oStart) - 1,
+		nEnd	= arguments.length > 2 ? nStart + cMath.round(oLength) : sValue.length;
+
+	// TODO: start can be negative
+	return new cXSString(nEnd > nStart ? sValue.substring(nStart, nEnd) : '');
+});
+
+// fn:string-length() as xs:integer
+// fn:string-length($arg as xs:string?) as xs:integer
+fStaticContext_defineSystemFunction("string-length",	[[cXSString, '?', true]],	function(oValue) {
+	if (!arguments.length) {
+		if (!this.item)
+			throw new cException("XPDY0002");
+		oValue	= cXSString.cast(fFunction_sequence_atomize([this.item], this)[0]);
+	}
+	return new cXSInteger(oValue == null ? 0 : oValue.valueOf().length);
+});
+
+// fn:normalize-space() as xs:string
+// fn:normalize-space($arg as xs:string?) as xs:string
+fStaticContext_defineSystemFunction("normalize-space",	[[cXSString, '?', true]],	function(oValue) {
+	if (!arguments.length) {
+		if (!this.item)
+			throw new cException("XPDY0002");
+		oValue	= cXSString.cast(fFunction_sequence_atomize([this.item], this)[0]);
+	}
+	return new cXSString(oValue == null ? '' : fString_trim(oValue).replace(/\s\s+/g, ' '));
+});
+
+// fn:normalize-unicode($arg as xs:string?) as xs:string
+// fn:normalize-unicode($arg as xs:string?, $normalizationForm as xs:string) as xs:string
+fStaticContext_defineSystemFunction("normalize-unicode",	[[cXSString, '?'], [cXSString, '', true]],	function(oValue, oNormalization) {
+	throw "Function '" + "normalize-unicode" + "' not implemented";
+});
+
+// fn:upper-case($arg as xs:string?) as xs:string
+fStaticContext_defineSystemFunction("upper-case",	[[cXSString, '?']],	function(oValue) {
+	return new cXSString(oValue == null ? '' : oValue.valueOf().toUpperCase());
+});
+
+// fn:lower-case($arg as xs:string?) as xs:string
+fStaticContext_defineSystemFunction("lower-case",	[[cXSString, '?']],	function(oValue) {
+	return new cXSString(oValue == null ? '' : oValue.valueOf().toLowerCase());
+});
+
+// fn:translate($arg as xs:string?, $mapString as xs:string, $transString as xs:string) as xs:string
+fStaticContext_defineSystemFunction("translate",	[[cXSString, '?'], [cXSString], [cXSString]],	function(oValue, oMap, oTranslate) {
+	if (oValue == null)
+		return new cXSString('');
+
+	var aValue	= oValue.valueOf().split(''),
+		aMap	= oMap.valueOf().split(''),
+		aTranslate	= oTranslate.valueOf().split(''),
+		nTranslateLength	= aTranslate.length,
+		aReturn	= [];
+	for (var nIndex = 0, nLength = aValue.length, nPosition; nIndex < nLength; nIndex++)
+		if ((nPosition = aMap.indexOf(aValue[nIndex])) ==-1)
+			aReturn[aReturn.length]	= aValue[nIndex];
+		else
+		if (nPosition < nTranslateLength)
+			aReturn[aReturn.length]	= aTranslate[nPosition];
+
+	return new cXSString(aReturn.join(''));
+});
+
+// fn:encode-for-uri($uri-part as xs:string?) as xs:string
+fStaticContext_defineSystemFunction("encode-for-uri",	[[cXSString, '?']],	function(oValue) {
+	return new cXSString(oValue == null ? '' : window.encodeURIComponent(oValue));
+});
+
+// fn:iri-to-uri($iri as xs:string?) as xs:string
+fStaticContext_defineSystemFunction("iri-to-uri",		[[cXSString, '?']],	function(oValue) {
+	return new cXSString(oValue == null ? '' : window.encodeURI(window.decodeURI(oValue)));
+});
+
+// fn:escape-html-uri($uri as xs:string?) as xs:string
+fStaticContext_defineSystemFunction("escape-html-uri",	[[cXSString, '?']],	function(oValue) {
+	if (oValue == null || oValue.valueOf() == '')
+		return new cXSString('');
+	// Encode
+	var aValue	= oValue.valueOf().split('');
+	for (var nIndex = 0, nLength = aValue.length, nCode; nIndex < nLength; nIndex++)
+		if ((nCode = aValue[nIndex].charCodeAt(0)) < 32 || nCode > 126)
+			aValue[nIndex]	= window.encodeURIComponent(aValue[nIndex]);
+	return new cXSString(aValue.join(''));
+});
+
+
+// 7.5 Functions Based on Substring Matching
+// fn:contains($arg1 as xs:string?, $arg2 as xs:string?) as xs:boolean
+// fn:contains($arg1 as xs:string?, $arg2 as xs:string?, $collation as xs:string) as xs:boolean
+fStaticContext_defineSystemFunction("contains",	[[cXSString, '?'], [cXSString, '?'], [cXSString, '', true]],	function(oValue, oSearch, oCollation) {
+	if (arguments.length > 2)
+		throw "Collation parameter in function '" + "contains" + "' is not implemented";
+	return new cXSBoolean((oValue == null ? '' : oValue.valueOf()).indexOf(oSearch == null ? '' : oSearch.valueOf()) >= 0);
+});
+
+// fn:starts-with($arg1 as xs:string?, $arg2 as xs:string?) as xs:boolean
+// fn:starts-with($arg1 as xs:string?, $arg2 as xs:string?, $collation as xs:string) as xs:boolean
+fStaticContext_defineSystemFunction("starts-with",	[[cXSString, '?'], [cXSString, '?'], [cXSString, '', true]],	function(oValue, oSearch, oCollation) {
+	if (arguments.length > 2)
+		throw "Collation parameter in function '" + "starts-with" + "' is not implemented";
+	return new cXSBoolean((oValue == null ? '' : oValue.valueOf()).indexOf(oSearch == null ? '' : oSearch.valueOf()) == 0);
+});
+
+// fn:ends-with($arg1 as xs:string?, $arg2 as xs:string?) as xs:boolean
+// fn:ends-with($arg1 as xs:string?, $arg2 as xs:string?, $collation as xs:string) as xs:boolean
+fStaticContext_defineSystemFunction("ends-with",	[[cXSString, '?'], [cXSString, '?'], [cXSString, '', true]],	function(oValue, oSearch, oCollation) {
+	if (arguments.length > 2)
+		throw "Collation parameter in function '" + "ends-with" + "' is not implemented";
+	var sValue	= oValue == null ? '' : oValue.valueOf(),
+		sSearch	= oSearch == null ? '' : oSearch.valueOf();
+
+	return new cXSBoolean(sValue.indexOf(sSearch) == sValue.length - sSearch.length);
+});
+
+// fn:substring-before($arg1 as xs:string?, $arg2 as xs:string?) as xs:string
+// fn:substring-before($arg1 as xs:string?, $arg2 as xs:string?, $collation as xs:string) as xs:string
+fStaticContext_defineSystemFunction("substring-before",	[[cXSString, '?'], [cXSString, '?'], [cXSString, '', true]],	function(oValue, oSearch, oCollation) {
+	if (arguments.length > 2)
+		throw "Collation parameter in function '" + "substring-before" + "' is not implemented";
+
+	var sValue	= oValue == null ? '' : oValue.valueOf(),
+		sSearch	= oSearch == null ? '' : oSearch.valueOf(),
+		nPosition;
+
+	return new cXSString((nPosition = sValue.indexOf(sSearch)) >= 0 ? sValue.substring(0, nPosition) : '');
+});
+
+// fn:substring-after($arg1 as xs:string?, $arg2 as xs:string?) as xs:string
+// fn:substring-after($arg1 as xs:string?, $arg2 as xs:string?, $collation as xs:string) as xs:string
+fStaticContext_defineSystemFunction("substring-after",	[[cXSString, '?'], [cXSString, '?'], [cXSString, '', true]],	function(oValue, oSearch, oCollation) {
+	if (arguments.length > 2)
+		throw "Collation parameter in function '" + "substring-after" + "' is not implemented";
+
+	var sValue	= oValue == null ? '' : oValue.valueOf(),
+		sSearch	= oSearch == null ? '' : oSearch.valueOf(),
+		nPosition;
+
+	return new cXSString((nPosition = sValue.indexOf(sSearch)) >= 0 ? sValue.substring(nPosition + sSearch.length) : '');
+});
+
+
+// 7.6 String Functions that Use Pattern Matching
+function fFunction_string_createRegExp(sValue, sFlags) {
+	var d1	= '\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF',
+		d2	= '\u0370-\u037D\u037F-\u1FFF\u200C-\u200D',
+		d3	= '\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD',
+		c	= 'A-Z_a-z\\-.0-9\u00B7' + d1 + '\u0300-\u036F' + d2 + '\u203F-\u2040' + d3,
+		i	= 'A-Z_a-z' + d1 + d2 + d3;
+
+	sValue	= sValue
+				.replace(/\[\\i-\[:\]\]/g, '[' + i + ']')
+				.replace(/\[\\c-\[:\]\]/g, '[' + c + ']')
+				.replace(/\\i/g, '[:' + i + ']')
+				.replace(/\\I/g, '[^:' + i + ']')
+				.replace(/\\c/g, '[:' + c + ']')
+				.replace(/\\C/g, '[^:' + c + ']');
+
+	// Check if all flags are legal
+	if (sFlags && !sFlags.match(/^[smix]+$/))
+		throw new cException("FORX0001");	// Invalid character '{%0}' in regular expression flags
+
+	var bFlagS	= sFlags.indexOf('s') >= 0,
+		bFlagX	= sFlags.indexOf('x') >= 0;
+	if (bFlagS || bFlagX) {
+		// Strip 's' and 'x' from flags
+		sFlags	= sFlags.replace(/[sx]/g, '');
+		var aValue	= [],
+			rValue	= /\s/;
+		for (var nIndex = 0, nLength = sValue.length, bValue = false, sCharCurr, sCharPrev = ''; nIndex < nLength; nIndex++) {
+			sCharCurr	= sValue.charAt(nIndex);
+			if (sCharPrev != '\\') {
+				if (sCharCurr == '[')
+					bValue	= true;
+				else
+				if (sCharCurr == ']')
+					bValue	= false;
+			}
+			// Replace '\s' for flag 'x' if not in []
+			if (bValue || !(bFlagX && rValue.test(sCharCurr))) {
+				// Replace '.' for flag 's' if not in []
+				if (!bValue && (bFlagS && sCharCurr == '.' && sCharPrev != '\\'))
+					aValue[aValue.length]	= '(?:.|\\s)';
+				else
+					aValue[aValue.length]	= sCharCurr;
+			}
+			sCharPrev	= sCharCurr;
+		}
+		sValue	= aValue.join('');
+	}
+
+	return new cRegExp(sValue, sFlags + 'g');
+};
+
+// fn:matches($input as xs:string?, $pattern as xs:string) as xs:boolean
+// fn:matches($input as xs:string?, $pattern as xs:string, $flags as xs:string) as xs:boolean
+fStaticContext_defineSystemFunction("matches",	[[cXSString, '?'], [cXSString], [cXSString, '', true]],	function(oValue, oPattern, oFlags) {
+	var sValue	= oValue == null ? '' : oValue.valueOf(),
+		rRegExp	= fFunction_string_createRegExp(oPattern.valueOf(), arguments.length > 2 ? oFlags.valueOf() : '');
+
+	return new cXSBoolean(rRegExp.test(sValue));
+});
+
+// fn:replace($input as xs:string?, $pattern as xs:string, $replacement as xs:string) as xs:string
+// fn:replace($input as xs:string?, $pattern as xs:string, $replacement as xs:string, $flags as xs:string) as xs:string
+fStaticContext_defineSystemFunction("replace",	[[cXSString, '?'], [cXSString],  [cXSString], [cXSString, '', true]],	function(oValue, oPattern, oReplacement, oFlags) {
+	var sValue	= oValue == null ? '' : oValue.valueOf(),
+		rRegExp	= fFunction_string_createRegExp(oPattern.valueOf(), arguments.length > 3 ? oFlags.valueOf() : '');
+
+	return new cXSBoolean(sValue.replace(rRegExp, oReplacement.valueOf()));
+});
+
+// fn:tokenize($input as xs:string?, $pattern as xs:string) as xs:string*
+// fn:tokenize($input as xs:string?, $pattern as xs:string, $flags as xs:string) as xs:string*
+fStaticContext_defineSystemFunction("tokenize",	[[cXSString, '?'], [cXSString], [cXSString, '', true]],	function(oValue, oPattern, oFlags) {
+	var sValue	= oValue == null ? '' : oValue.valueOf(),
+		rRegExp	= fFunction_string_createRegExp(oPattern.valueOf(), arguments.length > 2 ? oFlags.valueOf() : '');
+
+	var oSequence	= [];
+	for (var nIndex = 0, aValue = sValue.split(rRegExp), nLength = aValue.length; nIndex < nLength; nIndex++)
+		oSequence.push(new cXSString(aValue[nIndex]));
+
+	return oSequence;
+});
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+/*
+	4 The Trace Function
+		trace
+*/
+
+// fn:trace($value as item()*, $label as xs:string) as item()*
+fStaticContext_defineSystemFunction("trace",		[[cXTItem, '*'], [cXSString]],	function(oSequence1, oLabel) {
+	var oConsole	= window.console;
+	if (oConsole && oConsole.log)
+		oConsole.log(oLabel.valueOf(), oSequence1);
+	return oSequence1;
+});
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+var oCodepointStringCollator	= new cStringCollator;
+
+oCodepointStringCollator.equals	= function(sValue1, sValue2) {
+	return sValue1 == sValue2;
+};
+
+oCodepointStringCollator.compare	= function(sValue1, sValue2) {
+	return sValue1 == sValue2 ? 0 : sValue1 > sValue2 ? 1 :-1;
+};
+function cLXDOMAdapter() {
+
+};
+
+cLXDOMAdapter.prototype	= new cDOMAdapter;
+
+var oLXDOMAdapter_staticContext	= new cStaticContext;
+
+cLXDOMAdapter.prototype.getProperty	= function(oNode, sName) {
+		if (sName in oNode)
+		return oNode[sName];
+
+		if (sName == "baseURI") {
+		var sBaseURI	= '',
+			fResolveUri	= oLXDOMAdapter_staticContext.getFunction('{' + "http://www.w3.org/2005/xpath-functions" + '}' + "resolve-uri"),
+			cXSString	= oLXDOMAdapter_staticContext.getDataType('{' + "http://www.w3.org/2001/XMLSchema" + '}' + "string");
+
+		for (var oParent = oNode, sUri; oParent; oParent = oParent.parentNode)
+			if (oParent.nodeType == 1  && (sUri = oParent.getAttribute("xml:base")))
+				sBaseURI	= fResolveUri(new cXSString(sUri), new cXSString(sBaseURI)).toString();
+				return sBaseURI;
+	}
+	else
+	if (sName == "textContent") {
+		var aText = [];
+		(function(oNode) {
+			for (var nIndex = 0, oChild; oChild = oNode.childNodes[nIndex]; nIndex++)
+				if (oChild.nodeType == 3  || oChild.nodeType == 4 )
+					aText.push(oChild.data);
+				else
+				if (oChild.nodeType == 1  && oChild.firstChild)
+					arguments.callee(oChild);
+		})(oNode);
+		return aText.join('');
+	}
+};
+
+cLXDOMAdapter.prototype.compareDocumentPosition	= function(oNode, oChild) {
+		if ("compareDocumentPosition" in oNode)
+		return oNode.compareDocumentPosition(oChild);
+
+		if (oChild == oNode)
+		return 0;
+
+		var oAttr1	= null,
+		oAttr2	= null,
+		aAttributes,
+		oAttr, oElement, nIndex, nLength;
+	if (oNode.nodeType == 2 ) {
+		oAttr1	= oNode;
+		oNode	= this.getProperty(oAttr1, "ownerElement");
+	}
+	if (oChild.nodeType == 2 ) {
+		oAttr2	= oChild;
+		oChild	= this.getProperty(oAttr2, "ownerElement");
+	}
+
+		if (oAttr1 && oAttr2 && oNode && oNode == oChild) {
+		for (nIndex = 0, aAttributes = this.getProperty(oNode, "attributes"), nLength = aAttributes.length; nIndex < nLength; nIndex++) {
+			oAttr	= aAttributes[nIndex];
+			if (oAttr == oAttr1)
+				return 32  | 4 ;
+			if (oAttr == oAttr2)
+				return 32  | 2 ;
+		}
+	}
+
+		var aChain1	= [], nLength1, oNode1,
+		aChain2	= [], nLength2, oNode2;
+		if (oAttr1)
+		aChain1.push(oAttr1);
+	for (oElement = oNode; oElement; oElement = oElement.parentNode)
+		aChain1.push(oElement);
+	if (oAttr2)
+		aChain2.push(oAttr2);
+	for (oElement = oChild; oElement; oElement = oElement.parentNode)
+		aChain2.push(oElement);
+		if (((oNode.ownerDocument || oNode) != (oChild.ownerDocument || oChild)) || (aChain1[aChain1.length - 1] != aChain2[aChain2.length - 1]))
+		return 32  | 1 ;
+		for (nIndex = cMath.min(nLength1 = aChain1.length, nLength2 = aChain2.length); nIndex; --nIndex)
+		if ((oNode1 = aChain1[--nLength1]) != (oNode2 = aChain2[--nLength2])) {
+						if (oNode1.nodeType == 2 )
+				return 4 ;
+			if (oNode2.nodeType == 2 )
+				return 2 ;
+						if (!oNode2.nextSibling)
+				return 4 ;
+			if (!oNode1.nextSibling)
+				return 2 ;
+			for (oElement = oNode2.previousSibling; oElement; oElement = oElement.previousSibling)
+				if (oElement == oNode1)
+					return 4 ;
+			return 2 ;
+		}
+		return nLength1 < nLength2 ? 4  | 16  : 2  | 8 ;
+};
+
+cLXDOMAdapter.prototype.lookupNamespaceURI	= function(oNode, sPrefix) {
+		if ("lookupNamespaceURI" in oNode)
+		return oNode.lookupNamespaceURI(sPrefix);
+
+		for (; oNode && oNode.nodeType != 9  ; oNode = oNode.parentNode)
+		if (sPrefix == this.getProperty(oChild, "prefix"))
+			return this.getProperty(oNode, "namespaceURI");
+		else
+		if (oNode.nodeType == 1)				for (var oAttributes = this.getProperty(oNode, "attributes"), nIndex = 0, nLength = oAttributes.length, sName = "xmlns" + ':' + sPrefix; nIndex < nLength; nIndex++)
+				if (this.getProperty(oAttributes[nIndex], "nodeName") == sName)
+					return this.getProperty(oAttributes[nIndex], "value");
+	return null;
+};
+
+cLXDOMAdapter.prototype.getElementsByTagNameNS	= function(oNode, sNameSpaceURI, sLocalName) {
+		if ("getElementsByTagNameNS" in oNode)
+		return oNode.getElementsByTagNameNS(sNameSpaceURI, sLocalName);
+
+		var aElements	= [],
+		bNameSpaceURI	= '*' == sNameSpaceURI,
+		bLocalName		= '*' == sLocalName;
+	(function(oNode) {
+		for (var nIndex = 0, oChild; oChild = oNode.childNodes[nIndex]; nIndex++)
+			if (oChild.nodeType == 1) {					if ((bLocalName || sLocalName == this.getProperty(oChild, "localName")) && (bNameSpaceURI || sNameSpaceURI == this.getProperty(oChild, "namespaceURI")))
+					aElements[aElements.length]	= oChild;
+				if (oChild.firstChild)
+					arguments.callee(oChild);
+			}
+	})(oNode);
+	return aElements;
+};
+
+var oMSHTMLDOMAdapter	= new cLXDOMAdapter;
+
+oMSHTMLDOMAdapter.getProperty	= function(oNode, sName) {
+	if (sName == "localName") {
+		if (oNode.nodeType == 1)
+			return oNode.nodeName.toLowerCase();
+	}
+	if (sName == "prefix")
+		return null;
+	if (sName == "namespaceURI")
+		return oNode.nodeType == 1 ? "http://www.w3.org/1999/xhtml" : null;
+	if (sName == "textContent")
+		return oNode.innerText;
+	if (sName == "attributes" && oNode.nodeType == 1) {
+		var aAttributes	= [];
+		for (var nIndex = 0, oAttributes = oNode.attributes, nLength = oAttributes.length, oNode2, oAttribute; nIndex < nLength; nIndex++) {
+			oNode2	= oAttributes[nIndex];
+			if (oNode2.specified) {
+				oAttribute	= new cAttr;
+				oAttribute.ownerElement	= oNode;
+				oAttribute.ownerDocument= oNode.ownerDocument;
+				oAttribute.specified	= true;
+				oAttribute.value		=
+				oAttribute.nodeValue	= oNode2.nodeValue;
+				oAttribute.name			=
+				oAttribute.nodeName		=
+								oAttribute.localName	= oNode2.nodeName.toLowerCase();
+								aAttributes[aAttributes.length]	= oAttribute;
+			}
+		}
+		return aAttributes;
+	}
+		return cLXDOMAdapter.prototype.getProperty.call(this, oNode, sName);
+};
+
+
+var oMSXMLDOMAdapter	= new cLXDOMAdapter;
+
+oMSXMLDOMAdapter.getProperty	= function(oNode, sName) {
+	if (sName == "localName") {
+		if (oNode.nodeType == 7)
+			return null;
+		if (oNode.nodeType == 1)
+			return oNode.baseName;
+	}
+	if (sName == "prefix" || sName == "namespaceURI")
+		return oNode[sName] || null;
+	if (sName == "textContent")
+		return oNode.text;
+	if (sName == "attributes" && oNode.nodeType == 1) {
+		var aAttributes	= [];
+		for (var nIndex = 0, oAttributes = oNode.attributes, nLength = oAttributes.length, oNode2, oAttribute; nIndex < nLength; nIndex++) {
+			oNode2	= oAttributes[nIndex];
+			if (oNode2.specified) {
+				oAttribute	= new cAttr;
+				oAttribute.nodeType		= 2;
+				oAttribute.ownerElement	= oNode;
+				oAttribute.ownerDocument= oNode.ownerDocument;
+				oAttribute.specified	= true;
+				oAttribute.value		=
+				oAttribute.nodeValue	= oNode2.nodeValue;
+				oAttribute.name			=
+				oAttribute.nodeName		= oNode2.nodeName;
+								oAttribute.localName	= oNode2.baseName;
+				oAttribute.prefix		= oNode2.prefix || null;
+				oAttribute.namespaceURI	= oNode2.namespaceURI || null;
+								aAttributes[aAttributes.length]	= oAttribute;
+			}
+		}
+		return aAttributes;
+	}
+		return cLXDOMAdapter.prototype.getProperty.call(this, oNode, sName);
+};
+
+oMSXMLDOMAdapter.getElementById	= function(oDocument, sId) {
+	return oDocument.nodeFromID(sId);
+};
+
+function cEvaluator() {
+
+};
+
+cEvaluator.prototype.defaultOL2DOMAdapter		= new cLXDOMAdapter;
+cEvaluator.prototype.defaultOL2HTMLDOMAdapter	= new cLXDOMAdapter;
+
+cEvaluator.prototype.defaultHTMLStaticContext	= new cStaticContext;
+cEvaluator.prototype.defaultHTMLStaticContext.baseURI	= window.document.location.href;
+cEvaluator.prototype.defaultHTMLStaticContext.defaultFunctionNamespace	= "http://www.w3.org/2005/xpath-functions";
+cEvaluator.prototype.defaultHTMLStaticContext.defaultElementNamespace	= "http://www.w3.org/1999/xhtml";
+
+cEvaluator.prototype.defaultXMLStaticContext	= new cStaticContext;
+cEvaluator.prototype.defaultXMLStaticContext.defaultFunctionNamespace	= "http://www.w3.org/2005/xpath-functions";
+
+cEvaluator.prototype.bOldMS		= !!window.document.namespaces && !window.document.createElementNS;
+cEvaluator.prototype.bOldW3		= !cEvaluator.prototype.bOldMS && window.document.documentElement.namespaceURI != "http://www.w3.org/1999/xhtml";
+
+cEvaluator.prototype.defaultDOMAdapter		= new cDOMAdapter;
+
+cEvaluator.prototype.compile	= function(sExpression, oStaticContext) {
+    return new cExpression(sExpression, oStaticContext);
+};
+
+cEvaluator.prototype.evaluate	= function(oQuery, sExpression, fNSResolver) {
+	if (! (oQuery instanceof window.jQuery))
+        oQuery = new window.jQuery(oQuery)
+
+    if (typeof sExpression == "undefined" || sExpression === null)
+        sExpression	= '';
+
+    var oNode	= oQuery[0];
+    if (typeof oNode == "undefined")
+        oNode	= null;
+
+    var oStaticContext	= oNode && (oNode.nodeType == 9 ? oNode : oNode.ownerDocument).createElement("div").tagName == "DIV" ? this.defaultHTMLStaticContext : this.defaultXMLStaticContext;
+
+    oStaticContext.namespaceResolver	= fNSResolver;
+
+    var oExpression	= new cExpression(cString(sExpression), oStaticContext);
+
+    oStaticContext.namespaceResolver	= null;
+
+    var aSequence,
+        oSequence	= new window.jQuery,
+        oAdapter	= this.defaultOL2DOMAdapter;
+
+    if (this.bOldMS)
+        oAdapter	= oStaticContext == this.defaultHTMLStaticContext ? oMSHTMLDOMAdapter : oMSXMLDOMAdapter;
+    else
+    if (this.bOldW3 && oStaticContext == this.defaultHTMLStaticContext)
+        oAdapter	= this.defaultOL2HTMLDOMAdapter;
+
+    aSequence	= oExpression.evaluate(new cDynamicContext(oStaticContext, oNode, null, oAdapter));
+    for (var nIndex = 0, nLength = aSequence.length, oItem; nIndex < nLength; nIndex++)
+        oSequence.push(oAdapter.isNode(oItem = aSequence[nIndex]) ? oItem : cStaticContext.xs2js(oItem));
+
+    return oSequence;
+};
+
+/*
+ * XPath.js - Pure JavaScript implementation of XPath 2.0 parser and evaluator
+ *
+ * Copyright (c) 2012 Sergey Ilinsky
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ *
+ */
+
+var oXPathEvaluator	= new cEvaluator,
+    oXPathClasses	= oXPathEvaluator.classes = {};
+
+//
+oXPathClasses.Exception		= cException;
+oXPathClasses.Expression	= cExpression;
+oXPathClasses.DOMAdapter	= cDOMAdapter;
+oXPathClasses.StaticContext	= cStaticContext;
+oXPathClasses.DynamicContext= cDynamicContext;
+oXPathClasses.StringCollator= cStringCollator;
+
+// Publish object
+window.xpath	= oXPathEvaluator;
+
+})()

src/js/operations/Cipher.js

@@ -475,6 +475,43 @@ var Cipher = {
         return output;
     },
 
+
+    /**
+     * @constant
+     * @default
+     */
+    SUBS_PLAINTEXT: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+    /**
+     * @constant
+     * @default
+     */
+    SUBS_CIPHERTEXT: "XYZABCDEFGHIJKLMNOPQRSTUVW",
+
+    /**
+     * Substitute operation.
+     *
+     * @param {byte_array} input
+     * @param {Object[]} args
+     * @returns {byte_array}
+     */
+    run_substitute: function (input, args) {
+        var plaintext = Utils.str_to_byte_array(Utils.expand_alph_range(args[0]).join()),
+            ciphertext = Utils.str_to_byte_array(Utils.expand_alph_range(args[1]).join()),
+            output = [],
+            index = -1;
+
+        if (plaintext.length !== ciphertext.length) {
+            output = Utils.str_to_byte_array("Warning: Plaintext and Ciphertext lengths differ\n\n");
+        }
+
+        for (var i = 0; i < input.length; i++) {
+            index = plaintext.indexOf(input[i]);
+            output.push(index > -1 && index < ciphertext.length ? ciphertext[index] : input[i]);
+        }
+
+        return output;
+    },
+
 };
 
 

src/js/operations/Code.js

@@ -1,4 +1,4 @@
-/* globals prettyPrintOne, vkbeautify */
+/* globals prettyPrintOne, vkbeautify, xpath */
 
 /**
  * Code operations.
@@ -304,4 +304,119 @@ var Code = {
         }
     },
 
+
+    /**
+     * @constant
+     * @default
+     */
+    XPATH_INITIAL: "",
+
+    /**
+     * @constant
+     * @default
+     */
+    XPATH_DELIMITER: "\\n",
+
+    /**
+     * XPath expression operation.
+     *
+     * @author Mikescher (https://github.com/Mikescher | https://mikescher.com)
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run_xpath:function(input, args) {
+        const query = args[0],
+            delimiter = args[1];
+
+        var xml;
+        try {
+            xml = $.parseXML(input);
+        } catch (err) {
+            return "Invalid input XML.";
+        }
+
+        var result;
+        try {
+            result = xpath.evaluate(xml, query);
+        } catch (err) {
+            return "Invalid XPath. Details:\n" + err.message;
+        }
+
+        const serializer = new XMLSerializer();
+        const node_to_string = function(node) {
+            switch (node.nodeType) {
+                case Node.ELEMENT_NODE: return serializer.serializeToString(node);
+                case Node.ATTRIBUTE_NODE: return node.value;
+                case Node.COMMENT_NODE: return node.data;
+                case Node.DOCUMENT_NODE: return serializer.serializeToString(node);
+                default: throw new Error("Unknown Node Type: " + node.nodeType);
+            }
+        };
+
+        return Object.keys(result).map(function(key) {
+            return result[key];
+        }).slice(0, -1) // all values except last (length)
+        .map(node_to_string)
+        .join(delimiter);
+    },
+
+
+    /**
+     * @constant
+     * @default
+     */
+    CSS_SELECTOR_INITIAL: "",
+
+    /**
+     * @constant
+     * @default
+     */
+    CSS_QUERY_DELIMITER: "\\n",
+
+    /**
+     * CSS selector operation.
+     *
+     * @author Mikescher (https://github.com/Mikescher | https://mikescher.com)
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run_css_query: function(input, args) {
+        const query = args[0],
+            delimiter = args[1];
+
+        var html;
+        try {
+            html = $.parseHTML(input);
+        } catch (err) {
+            return "Invalid input HTML.";
+        }
+
+        var result;
+        try {
+            result = $(html).find(query);
+        } catch (err) {
+            return "Invalid CSS Selector. Details:\n" + err.message;
+        }
+
+        const node_to_string = function(node) {
+            switch (node.nodeType) {
+                case Node.ELEMENT_NODE: return node.outerHTML;
+                case Node.ATTRIBUTE_NODE: return node.value;
+                case Node.COMMENT_NODE: return node.data;
+                case Node.TEXT_NODE: return node.wholeText;
+                case Node.DOCUMENT_NODE: return node.outerHTML;
+                default: throw new Error("Unknown Node Type: " + node.nodeType);
+            }
+        };
+
+        return Array.apply(null, Array(result.length))
+            .map(function(_, i) {
+                return result[i];
+            })
+            .map(node_to_string)
+            .join(delimiter);
+    },
+
 };

src/js/operations/Extract.js

@@ -10,7 +10,7 @@
 var Extract = {
 
     /**
-     * Runs search operations across the input data using refular expressions.
+     * Runs search operations across the input data using regular expressions.
      *
      * @private
      * @param {string} input
@@ -293,5 +293,5 @@ var Extract = {
         output += Extract.run_dates(input, []);
         return output;
     },
-    
+
 };

src/js/views/html/HTMLApp.js

@@ -205,14 +205,17 @@ HTMLApp.prototype.populate_operations_list = function() {
  * Sets up the adjustable splitter to allow the user to resize areas of the page.
  */
 HTMLApp.prototype.initialise_splitter = function() {
-    Split(["#operations", "#recipe", "#IO"], {
+    this.column_splitter = Split(["#operations", "#recipe", "#IO"], {
         sizes: [20, 30, 50],
-        minSize: [240, 325, 500],
+        minSize: [240, 325, 440],
         gutterSize: 4,
-        onDrag: this.manager.controls.adjust_width.bind(this.manager.controls)
+        onDrag: function() {
+            this.manager.controls.adjust_width();
+            this.manager.output.adjust_width();
+        }.bind(this)
     });
 
-    Split(["#input", "#output"], {
+    this.io_splitter = Split(["#input", "#output"], {
         direction: "vertical",
         gutterSize: 4,
     });
@@ -463,13 +466,11 @@ HTMLApp.prototype.set_recipe_config = function(recipe_config) {
  * Resets the splitter positions to default.
  */
 HTMLApp.prototype.reset_layout = function() {
-    document.getElementById("operations").style.width = "calc(20% - 2px)";
-    document.getElementById("recipe").style.width = "calc(30% - 4px)";
-    document.getElementById("IO").style.width = "calc(50% - 2px)";
-    document.getElementById("input").style.height = "calc(50% - 2px)";
-    document.getElementById("output").style.height = "calc(50% - 2px)";
+    this.column_splitter.setSizes([20, 30, 50]);
+    this.io_splitter.setSizes([50, 50]);
 
     this.manager.controls.adjust_width();
+    this.manager.output.adjust_width();
 };
 
 

src/js/views/html/Manager.js

@@ -125,6 +125,7 @@ Manager.prototype.initialise_event_listeners = function() {
     document.getElementById("save-to-file").addEventListener("click", this.output.save_click.bind(this.output));
     document.getElementById("switch").addEventListener("click", this.output.switch_click.bind(this.output));
     document.getElementById("undo-switch").addEventListener("click", this.output.undo_switch_click.bind(this.output));
+    document.getElementById("maximise-output").addEventListener("click", this.output.maximise_output_click.bind(this.output));
     document.getElementById("output-text").addEventListener("scroll", this.highlighter.output_scroll.bind(this.highlighter));
     document.getElementById("output-text").addEventListener("mouseup", this.highlighter.output_mouseup.bind(this.highlighter));
     document.getElementById("output-text").addEventListener("mousemove", this.highlighter.output_mousemove.bind(this.highlighter));

src/js/views/html/OutputWaiter.js

@@ -95,6 +95,32 @@ OutputWaiter.prototype.set_output_info = function(length, lines, duration) {
 };
 
 
+/**
+ * Adjusts the display properties of the output buttons so that they fit within the current width
+ * without wrapping or overflowing.
+ */
+OutputWaiter.prototype.adjust_width = function() {
+    var output          = document.getElementById("output"),
+        save_to_file    = document.getElementById("save-to-file"),
+        switch_io       = document.getElementById("switch"),
+        undo_switch     = document.getElementById("undo-switch"),
+        maximise_output = document.getElementById("maximise-output");
+    
+    if (output.clientWidth < 680) {
+        save_to_file.childNodes[1].nodeValue = "";
+        switch_io.childNodes[1].nodeValue = "";
+        undo_switch.childNodes[1].nodeValue = "";
+        maximise_output.childNodes[1].nodeValue = "";
+    } else {
+        save_to_file.childNodes[1].nodeValue = " Save to file";
+        switch_io.childNodes[1].nodeValue = " Move output to input";
+        undo_switch.childNodes[1].nodeValue = " Undo";
+        maximise_output.childNodes[1].nodeValue =
+            maximise_output.getAttribute("title") === "Maximise" ? " Max" : " Restore";
+    }
+};
+
+
 /**
  * Handler for save click events.
  * Saves the current output to a file, downloaded as a URL octet stream.
@@ -137,3 +163,26 @@ OutputWaiter.prototype.undo_switch_click = function() {
     this.app.set_input(this.switch_orig_data);
     document.getElementById("undo-switch").disabled = true;
 };
+
+
+/**
+ * Handler for maximise output click events.
+ * Resizes the output frame to be as large as possible, or restores it to its original size.
+ */
+OutputWaiter.prototype.maximise_output_click = function(e) {
+    var el = e.target.id === "maximise-output" ? e.target : e.target.parentNode;
+
+    if (el.getAttribute("title") === "Maximise") {
+        this.app.column_splitter.collapse(0);
+        this.app.column_splitter.collapse(1);
+        this.app.io_splitter.collapse(0);
+
+        el.setAttribute("title", "Restore");
+        el.innerHTML = "<img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAlUlEQVQ4y93RwQpBQRQG4C9ba1fxBteGPIj38BTejFJKLFnwCJIiCsW1mcV0k9yx82/OzGK+OXMGOpiiLTFjFNiilQI0sQ7IJiAjLKsgGVYB2YdaVO0kwy46/BVQi9ZDNPyQWen2ub/KufS8y7shfkq9tF9U7SC+/YluKvAI9YZeFeCECXJcA3JHP2WgMXJM/ZUcBwxeM+YuSWTgMtUAAAAASUVORK5CYII='> Restore";
+        this.adjust_width();
+    } else {
+        el.setAttribute("title", "Maximise");
+        el.innerHTML = "<img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAi0lEQVQ4y83TMQrCQBCF4S+5g4rJEdJ7KE+RQ1lrIQQCllroEULuoM0Ww3a7aXwwLAzMPzDvLcz4hnooUItT1rsoVNy+4lgLWNL7RlcCmDBij2eCfNCrUITc0dRCrhj8m5otw0O6SV8LuAV3uhrAAa8sJ2Np7KPFawhgscVLjH9bCDhjt8WNKft88w/HjCvuVqu53QAAAABJRU5ErkJggg=='> Max";
+        this.app.reset_layout();
+    }
+};

src/static/stats.txt

@@ -1,21 +1,21 @@
-203	source files
-104466	lines
-4.0M	size
+206	source files
+113411	lines
+4.2M	size
 
-136	JavaScript source files
-95316	lines
-3.4M	size
+137	JavaScript source files
+104253	lines
+3.7M	size
 
-78	third party JavaScript source files
-76377	lines
-2.7M	size
+79	third party JavaScript source files
+85052	lines
+3.0M	size
 
 58	first party JavaScript source files
-18939	lines
+19201	lines
 724K	size
 
-3.2M	uncompressed JavaScript size
-1.7M	compressed JavaScript size
+3.4M	uncompressed JavaScript size
+1.8M	compressed JavaScript size
 
 15	categories
-155	operations
+158	operations