IE7Pro Forum

// FremyCompany Script
// version 0.1.3 BUILD 1
//
// --------------------------------------------------------------------
//
// This is a Greasemonkey user script.  To install it, you need
// IE Pro 9.12 or later (see at : http://www.iepro.com)
// Then restart Internet Explorer and revisit this script.
//
// --------------------------------------------------------------------
//
// ==UserScript==
// @name          .FremyCompany Script
// @description   Scripts made by FremyCompany to make IE Pro more compatbile with GreaseMonkey
// @include       *
// ==/UserScript==

// GM_ Functions
(function(w,d) {
    w.GM_setValue=function(name, value) {
        if (typeof value != "string") {
            value=uneval(value);
        }
        GM_getValue.tempData[name]=value;
        return PRO_setValue(name, value);
    };
    w.GM_getValue=function(name, defaultValue) {
        var result = PRO_getValue(name);
        if (name == "YESTERDAY") alert(result)
        if (typeof(result) == "undefined" || result == "") { result=GM_getValue.tempData[name]; }
        if (name == "YESTERDAY") alert(result)
        if (typeof(result) == "undefined" || result == "") { result=defaultValue; }
        if (name == "YESTERDAY") alert(result)
        return result;
    };
    w.GM_getValue.tempData=new Object();
    w.GM_log=function(text) {
        return PRO_log(text);
    };
    w.GM_openInTab=function(url) {
        return PRO_openInTab(url);
    };
    w.GM_addStyle=function(css) {
        return PRO_addStyle(css);
    };
    w.GM_xmlhttpRequest=function (d) {
        // url, method, headers, data, onload, onerror, onreadystatechange;
        if (!d.url) { GM_log("URL is missing in xhr-call"); return false; }
        if (!d.method) { d.method="POST"; } else { d.method=d.method.toUpperCase(); }
        if (!d.headers) { d.headers=new Array(); }
        var xhr={"readyState":-1,"status":0,"statusText":"not loaded"};
        var xhr_value=xhr;
        try {
            xhr=GM_xmlhttpRequest._createRequest();
            
            // OPENING of the xhr
            xhr.open(d.method, d.url, true);
            for (h in d.headers) {
                try { xhr.setRequestHeader(h, d.headers[h]); } catch (ex) {}
            }
            
            // CallBack gesture
            xhr.onreadystatechange=function() {
                GM_xmlhttpRequest._createValue(xhr,xhr_value);
                try { d.onreadystatechange(xhr_value); } catch (ex) {}
                if (xhr.readyState==4) {
                    if (xhr.status<400) {
                        try { d.onload(xhr_value); } catch (ex) {}
                    } else {
                        try { d.onerror(xhr_value); } catch (ex) {}
                    }
                }
            }
            
            // SENDING the data
            xhr.send(d.data?d.data:null)
        } catch (ex) {
            try { d.onerror(xhr_value, ex); } catch (ex2) {}
        }
    };
    w.GM_xmlhttpRequest._createRequest=PRO_xmlhttpRequest;
    w.GM_xmlhttpRequest._createValue=function(x,v) {
        v.abort=function() { x.abort(); }
        v.getResponseHeader=function(n) { return x.getResponseHeader(n);  }
        v.getAllResponseHeaders=function() { return x.getAllResponseHeaders(); }
        v.responseText=x.responseText;
        v.responseHeaders=x.getAllResponseHeaders();
        v.responseText=x.responseText;
        v.responseBody=x.responseBody;
        v.readyState=x.readyState;
        v.status=x.status;
        v.statusText=x.statusText;
    };
})(window,document);

// uneval function
/*
json.js
2006-12-06

This file adds these methods to JavaScript:

    array.toJSONString()
    boolean.toJSONString()
    date.toJSONString()
    number.toJSONString()
    object.toJSONString()
    string.toJSONString()
        These methods produce a JSON text from a JavaScript value.
        It must not contain any cyclical references. Illegal values
        will be excluded.

        The default conversion for dates is to an ISO string. You can
        add a toJSONString method to any date object to get a different
        representation.

    string.parseJSON(hook)
        This method parses a JSON text to produce an object or
        array. It can throw a SyntaxError exception.

        The optional hook parameter is a function which can filter and
        transform the results. It receives each of the values, and its
        return value is used instead. If it returns what it received, then
        structure is not modified.

        Example:

        // Parse the text. If it contains any "NaN" strings, replace them
        // with the NaN value. All other values are left alone.

        myData = text.parseJSON(function (value) {
            if (value === 'NaN') {
                return NaN;
            }
            return value;
        });

It is expected that these methods will formally become part of the
JavaScript Programming Language in the Fourth Edition of the
ECMAScript standard in 2007.
*/
if (!Object.prototype.toJSONString) {
    Array.prototype.toJSONString = function () {
        var a = ['['], b, i, l = this.length, v;

        function p(s) {
            if (b) {
                a.push(',');
            }
            a.push(s);
            b = true;
        }

        for (i = 0; i < l; i += 1) {
            v = this[i];
            switch (typeof v) {
            case 'undefined':
            case 'function':
            case 'unknown':
                break;
            case 'object':
                if (v) {
                    if (typeof v.toJSONString === 'function') {
                        p(v.toJSONString());
                    }
                } else {
                    p("null");
                }
                break;
            default:
                p(v.toJSONString());
            }
        }
        a.push(']');
        return a.join('');
    };

    Boolean.prototype.toJSONString = function () {
        return String(this);
    };

    Date.prototype.toJSONString = function () {

        function f(n) {
            return n < 10 ? '0' + n : n;
        }

        return '"' + this.getFullYear() + '-' +
                f(this.getMonth() + 1) + '-' +
                f(this.getDate()) + 'T' +
                f(this.getHours()) + ':' +
                f(this.getMinutes()) + ':' +
                f(this.getSeconds()) + '"';
    };

    Number.prototype.toJSONString = function () {
        return isFinite(this) ? String(this) : "null";
    };

    Function.prototype.toJSONString = function() {
        return (""+this+"");
    }
}

RegExp.prototype.toJSONString=function() {
    return (""+this+"");    
}

Object.prototype.toJSONString = function () {
    var a = ['{'], b, i, v;

    function p(s) {
        if (b) {
            a.push(',');
        }
        a.push(i.toJSONString(), ':', s);
        b = true;
    }

    for (i in this) {
        if (true) {
            v = this[i];
            switch (typeof v) {
            case 'undefined':
            case 'function':
            case 'unknown':
                break;
            case 'object':
                if (v && v.getType) {
                    if (typeof v.toJSONString === 'function') {
                        p(v.toJSONString());
                    }
                } else {
                    p("null");
                }
                break;
            default:
                p(v.toJSONString());
            }
        }
    }
    a.push('}');
    return a.join('');
};


(function (s) {
    var m = {
        '\b': '\\b',
        '\t': '\\t',
        '\n': '\\n',
        '\f': '\\f',
        '\r': '\\r',
        '"' : '\\"',
        '\\': '\\\\'
    };

    s.parseJSON = function (hook) {
        try {
            if (/^("(\\.|[^"\\\n\r])*?"|[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t])+?$/.
                    test(this)) {
                var j = eval('(' + this + ')');
                if (typeof hook === 'function') {
                    function walk(v) {
                        if (v && typeof v === 'object') {
                            for (var i in v) {
                                if (v.hasOwnProperty(i)) {
                                    v[i] = walk(v[i]);
                                }
                            }
                        }
                        return hook(v);
                    }
                    return walk(j);
                }
                return j;
            }
        } catch (e) {
        }
        throw new SyntaxError("parseJSON");
    };

    s.toJSONString = function () {
        if (/["\\\x00-\x1f]/.test(this)) {
            return '"' + this.replace(/([\x00-\x1f\\"])/g, function(a, b) {
                var c = m[b];
                if (c) {
                    return c;
                }
                c = b.charCodeAt();
                return '\\u00' +
                    Math.floor(c / 16).toString(16) +
                    (c % 16).toString(16);
            }) + '"';
        }
        return '"' + this + '"';
    };
})(String.prototype);

function uneval(o) {
    return o.toJSONString();
}

Object.prototype.toSource=function() {
    return this.toJSONString();
}

// SARRISSA ==> A better dom implementation for IE
/**
 * ====================================================================
 * About
 * ====================================================================
 * Sarissa is an ECMAScript library acting as a cross-browser wrapper for native XML APIs.
 * The library supports Gecko based browsers like Mozilla and Firefox,
 * Internet Explorer (5.5+ with MSXML3.0+), Konqueror, Safari and a little of Opera
 * @version 0.9.7.6
 * @author: Manos Batsis, mailto: mbatsis at users full stop sourceforge full stop net
 * ====================================================================
 * Licence
 * ====================================================================
 * Sarissa is free software distributed under the GNU GPL version 2 (see <a href="gpl.txt">gpl.txt</a>) or higher, 
 * GNU LGPL version 2.1 (see <a href="lgpl.txt">lgpl.txt</a>) or higher and Apache Software License 2.0 or higher 
 * (see <a href="asl.txt">asl.txt</a>). This means you can choose one of the three and use that if you like. If 
 * you make modifications under the ASL, i would appreciate it if you submitted those.
 * In case your copy of Sarissa does not include the license texts, you may find
 * them online in various formats at <a href="http://www.gnu.org">http://www.gnu.org</a> and 
 * <a href="http://www.apache.org">http://www.apache.org</a>.
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY 
 * KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE 
 * WARRANTIES OF MERCHANTABILITY,FITNESS FOR A PARTICULAR PURPOSE 
 * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
/**
 * <p>Sarissa is a utility class. Provides "static" methods for DOMDocument, 
 * DOM Node serialization to XML strings and other utility goodies.</p>
 * @constructor
 */
function Sarissa(){};
Sarissa.PARSED_OK = "Document contains no parsing errors";
Sarissa.PARSED_EMPTY = "Document is empty";
Sarissa.PARSED_UNKNOWN_ERROR = "Not well-formed or other error";
var _sarissa_iNsCounter = 0;
var _SARISSA_IEPREFIX4XSLPARAM = "";
var _SARISSA_HAS_DOM_IMPLEMENTATION = document.implementation && true;
var _SARISSA_HAS_DOM_CREATE_DOCUMENT = _SARISSA_HAS_DOM_IMPLEMENTATION && document.implementation.createDocument;
var _SARISSA_HAS_DOM_FEATURE = _SARISSA_HAS_DOM_IMPLEMENTATION && document.implementation.hasFeature;
var _SARISSA_IS_MOZ = _SARISSA_HAS_DOM_CREATE_DOCUMENT && _SARISSA_HAS_DOM_FEATURE;
var _SARISSA_IS_SAFARI = (navigator.userAgent && navigator.vendor && (navigator.userAgent.toLowerCase().indexOf("applewebkit") != -1 || navigator.vendor.indexOf("Apple") != -1));
var _SARISSA_IS_IE = document.all && window.ActiveXObject && navigator.userAgent.toLowerCase().indexOf("msie") > -1  && navigator.userAgent.toLowerCase().indexOf("opera") == -1;
if(!window.Node || !Node.ELEMENT_NODE){
    Node = {ELEMENT_NODE: 1, ATTRIBUTE_NODE: 2, TEXT_NODE: 3, CDATA_SECTION_NODE: 4, ENTITY_REFERENCE_NODE: 5,  ENTITY_NODE: 6, PROCESSING_INSTRUCTION_NODE: 7, COMMENT_NODE: 8, DOCUMENT_NODE: 9, DOCUMENT_TYPE_NODE: 10, DOCUMENT_FRAGMENT_NODE: 11, NOTATION_NODE: 12};
};

if(typeof XMLDocument == "undefined" && typeof Document !="undefined"){ XMLDocument = Document; } 

// IE initialization
if(_SARISSA_IS_IE){
    // for XSLT parameter names, prefix needed by IE
    _SARISSA_IEPREFIX4XSLPARAM = "xsl:";
    // used to store the most recent ProgID available out of the above
    var _SARISSA_DOM_PROGID = "";
    var _SARISSA_XMLHTTP_PROGID = "";
    var _SARISSA_DOM_XMLWRITER = "";
    /**
     * Called when the Sarissa_xx.js file is parsed, to pick most recent
     * ProgIDs for IE, then gets destroyed.
     * @private
     * @param idList an array of MSXML PROGIDs from which the most recent will be picked for a given object
     * @param enabledList an array of arrays where each array has two items; the index of the PROGID for which a certain feature is enabled
     */
    Sarissa.pickRecentProgID = function (idList){
        // found progID flag
        var bFound = false;
        for(var i=0; i < idList.length && !bFound; i++){
            try{
                var oDoc = new ActiveXObject(idList[i]);
                o2Store = idList[i];
                bFound = true;
            }catch (objException){
                // trap; try next progID
            };
        };
        if (!bFound) {
            throw "Could not retreive a valid progID of Class: " + idList[idList.length-1]+". (original exception: "+e+")";
        };
        idList = null;
        return o2Store;
    };
    // pick best available MSXML progIDs
    _SARISSA_DOM_PROGID = null;
    _SARISSA_THREADEDDOM_PROGID = null;
    _SARISSA_XSLTEMPLATE_PROGID = null;
    _SARISSA_XMLHTTP_PROGID = null;
    if(!window.XMLHttpRequest){
        /**
         * Emulate XMLHttpRequest
         * @constructor
         */
        XMLHttpRequest = function() {
            if(!_SARISSA_XMLHTTP_PROGID){
                _SARISSA_XMLHTTP_PROGID = Sarissa.pickRecentProgID(["Msxml2.XMLHTTP.6.0", "MSXML2.XMLHTTP.3.0", "MSXML2.XMLHTTP", "Microsoft.XMLHTTP"]);
            };
            return new ActiveXObject(_SARISSA_XMLHTTP_PROGID);
        };
    };
    // we dont need this anymore
    //============================================
    // Factory methods (IE)
    //============================================
    // see non-IE version
    Sarissa.getDomDocument = function(sUri, sName){
        if(!_SARISSA_DOM_PROGID){
            _SARISSA_DOM_PROGID = Sarissa.pickRecentProgID(["Msxml2.DOMDocument.6.0", "Msxml2.DOMDocument.3.0", "MSXML2.DOMDocument", "MSXML.DOMDocument", "Microsoft.XMLDOM"]);
        };
        var oDoc = new ActiveXObject(_SARISSA_DOM_PROGID);
        // if a root tag name was provided, we need to load it in the DOM object
        if (sName){
            // create an artifical namespace prefix 
            // or reuse existing prefix if applicable
            var prefix = "";
            if(sUri){
                if(sName.indexOf(":") > 1){
                    prefix = sName.substring(0, sName.indexOf(":"));
                    sName = sName.substring(sName.indexOf(":")+1); 
                }else{
                    prefix = "a" + (_sarissa_iNsCounter++);
                };
            };
            // use namespaces if a namespace URI exists
            if(sUri){
                oDoc.loadXML('<' + prefix+':'+sName + " xmlns:" + prefix + "=\"" + sUri + "\"" + " />");
            } else {
                oDoc.loadXML('<' + sName + " />");
            };
        };
        return oDoc;
    };
    // see non-IE version   
    Sarissa.getParseErrorText = function (oDoc) {
        var parseErrorText = Sarissa.PARSED_OK;
        if(oDoc.parseError.errorCode != 0){
            parseErrorText = "XML Parsing Error: " + oDoc.parseError.reason + 
                "\nLocation: " + oDoc.parseError.url + 
                "\nLine Number " + oDoc.parseError.line + ", Column " + 
                oDoc.parseError.linepos + 
                ":\n" + oDoc.parseError.srcText +
                "\n";
            for(var i = 0;  i < oDoc.parseError.linepos;i++){
                parseErrorText += "-";
            };
            parseErrorText +=  "^\n";
        }
        else if(oDoc.documentElement == null){
            parseErrorText = Sarissa.PARSED_EMPTY;
        };
        return parseErrorText;
    };
    // see non-IE version
    Sarissa.setXpathNamespaces = function(oDoc, sNsSet) {
        oDoc.setProperty("SelectionLanguage", "XPath");
        oDoc.setProperty("SelectionNamespaces", sNsSet);
    };   
    /**
     * Basic implementation of Mozilla's XSLTProcessor for IE. 
     * Reuses the same XSLT stylesheet for multiple transforms
     * @constructor
     */
    XSLTProcessor = function(){
        if(!_SARISSA_XSLTEMPLATE_PROGID){
            _SARISSA_XSLTEMPLATE_PROGID = Sarissa.pickRecentProgID(["Msxml2.XSLTemplate.6.0", "MSXML2.XSLTemplate.3.0"]);
        };
        this.template = new ActiveXObject(_SARISSA_XSLTEMPLATE_PROGID);
        this.processor = null;
    };
    /**
     * Imports the given XSLT DOM and compiles it to a reusable transform
     * <b>Note:</b> If the stylesheet was loaded from a URL and contains xsl:import or xsl:include elements,it will be reloaded to resolve those
     * @argument xslDoc The XSLT DOMDocument to import
     */
    XSLTProcessor.prototype.importStylesheet = function(xslDoc){
        if(!_SARISSA_THREADEDDOM_PROGID){
            _SARISSA_THREADEDDOM_PROGID = Sarissa.pickRecentProgID(["MSXML2.FreeThreadedDOMDocument.6.0", "MSXML2.FreeThreadedDOMDocument.3.0"]);
        };
        xslDoc.setProperty("SelectionLanguage", "XPath");
        xslDoc.setProperty("SelectionNamespaces", "xmlns:xsl='http://www.w3.org/1999/XSL/Transform'");
        // convert stylesheet to free threaded
        var converted = new ActiveXObject(_SARISSA_THREADEDDOM_PROGID);
        // make included/imported stylesheets work if exist and xsl was originally loaded from url
        if(xslDoc.url && xslDoc.selectSingleNode("//xsl:*[local-name() = 'import' or local-name() = 'include']") != null){
            converted.async = false;
            if (_SARISSA_THREADEDDOM_PROGID == "MSXML2.FreeThreadedDOMDocument.6.0") { 
                converted.setProperty("AllowDocumentFunction", true); 
                converted.resolveExternals = true; 
            }
            converted.load(xslDoc.url);
        } else {
            converted.loadXML(xslDoc.xml);
        };
        converted.setProperty("SelectionNamespaces", "xmlns:xsl='http://www.w3.org/1999/XSL/Transform'");
        var output = converted.selectSingleNode("//xsl:output");
        this.outputMethod = output ? output.getAttribute("method") : "html";
        this.template.stylesheet = converted;
        this.processor = this.template.createProcessor();
        // for getParameter and clearParameters
        this.paramsSet = new Array();
    };

    /**
     * Transform the given XML DOM and return the transformation result as a new DOM document
     * @argument sourceDoc The XML DOMDocument to transform
     * @return The transformation result as a DOM Document
     */
    XSLTProcessor.prototype.transformToDocument = function(sourceDoc){
        // fix for bug 1549749
        if(_SARISSA_THREADEDDOM_PROGID){
            this.processor.input=sourceDoc;
            var outDoc=new ActiveXObject(_SARISSA_DOM_PROGID);
            this.processor.output=outDoc;
            this.processor.transform();
            return outDoc;
        }
        else{
            if(!_SARISSA_DOM_XMLWRITER){
                _SARISSA_DOM_XMLWRITER = Sarissa.pickRecentProgID(["Msxml2.MXXMLWriter.6.0", "Msxml2.MXXMLWriter.3.0", "MSXML2.MXXMLWriter", "MSXML.MXXMLWriter", "Microsoft.XMLDOM"]);
            };
            this.processor.input = sourceDoc;
            var outDoc = new ActiveXObject(_SARISSA_DOM_XMLWRITER);
            this.processor.output = outDoc; 
            this.processor.transform();
            var oDoc = new ActiveXObject(_SARISSA_DOM_PROGID);
            oDoc.loadXML(outDoc.output+"");
            return oDoc;
        };
    };
    
    /**
     * Transform the given XML DOM and return the transformation result as a new DOM fragment.
     * <b>Note</b>: The xsl:output method must match the nature of the owner document (XML/HTML).
     * @argument sourceDoc The XML DOMDocument to transform
     * @argument ownerDoc The owner of the result fragment
     * @return The transformation result as a DOM Document
     */
    XSLTProcessor.prototype.transformToFragment = function (sourceDoc, ownerDoc) {
        this.processor.input = sourceDoc;
        this.processor.transform();
        var s = this.processor.output;
        var f = ownerDoc.createDocumentFragment();
        if (this.outputMethod == 'text') {
            f.appendChild(ownerDoc.createTextNode(s));
        } else if (ownerDoc.body && ownerDoc.body.innerHTML) {
            var container = ownerDoc.createElement('div');
            container.innerHTML = s;
            while (container.hasChildNodes()) {
                f.appendChild(container.firstChild);
            }
        }
        else {
            var oDoc = new ActiveXObject(_SARISSA_DOM_PROGID);
            if (s.substring(0, 5) == '<?xml') {
                s = s.substring(s.indexOf('?>') + 2);
            }
            var xml = ''.concat('<my>', s, '</my>');
            oDoc.loadXML(xml);
            var container = oDoc.documentElement;
            while (container.hasChildNodes()) {
                f.appendChild(container.firstChild);
            }
        }
        return f;
    };
    
    /**
     * Set global XSLT parameter of the imported stylesheet
     * @argument nsURI The parameter namespace URI
     * @argument name The parameter base name
     * @argument value The new parameter value
     */
    XSLTProcessor.prototype.setParameter = function(nsURI, name, value){
        // nsURI is optional but cannot be null 
        if(nsURI){
            this.processor.addParameter(name, value, nsURI);
        }else{
            this.processor.addParameter(name, value);
        };
        // update updated params for getParameter 
        if(!this.paramsSet[""+nsURI]){
            this.paramsSet[""+nsURI] = new Array();
        };
        this.paramsSet[""+nsURI][name] = value;
    };
    /**
     * Gets a parameter if previously set by setParameter. Returns null
     * otherwise
     * @argument name The parameter base name
     * @argument value The new parameter value
     * @return The parameter value if reviously set by setParameter, null otherwise
     */
    XSLTProcessor.prototype.getParameter = function(nsURI, name){
        nsURI = nsURI || "";
        if(this.paramsSet[nsURI] && this.paramsSet[nsURI][name]){
            return this.paramsSet[nsURI][name];
        }else{
            return null;
        };
    };
    /**
     * Clear parameters (set them to default values as defined in the stylesheet itself)
     */
    XSLTProcessor.prototype.clearParameters = function(){
        for(var nsURI in this.paramsSet){
            for(var name in this.paramsSet[nsURI]){
                if(nsURI){
                    this.processor.addParameter(name, null, nsURI);
                }else{
                    this.processor.addParameter(name, null);
                };
            };
        };
        this.paramsSet = new Array();
    };
}else{ /* end IE initialization, try to deal with real browsers now ;-) */
    if(_SARISSA_HAS_DOM_CREATE_DOCUMENT){
        /**
         * <p>Ensures the document was loaded correctly, otherwise sets the
         * parseError to -1 to indicate something went wrong. Internal use</p>
         * @private
         */
        Sarissa.__handleLoad__ = function(oDoc){
            Sarissa.__setReadyState__(oDoc, 4);
        };
        /**
        * <p>Attached by an event handler to the load event. Internal use.</p>
        * @private
        */
        _sarissa_XMLDocument_onload = function(){
            Sarissa.__handleLoad__(this);
        };
        /**
         * <p>Sets the readyState property of the given DOM Document object.
         * Internal use.</p>
         * @private
         * @argument oDoc the DOM Document object to fire the
         *          readystatechange event
         * @argument iReadyState the number to change the readystate property to
         */
        Sarissa.__setReadyState__ = function(oDoc, iReadyState){
            oDoc.readyState = iReadyState;
            oDoc.readystate = iReadyState;
            if (oDoc.onreadystatechange != null && typeof oDoc.onreadystatechange == "function")
                oDoc.onreadystatechange();
        };
        Sarissa.getDomDocument = function(sUri, sName){
            var oDoc = document.implementation.createDocument(sUri?sUri:null, sName?sName:null, null);
            if(!oDoc.onreadystatechange){
            
                /**
                * <p>Emulate IE's onreadystatechange attribute</p>
                */
                oDoc.onreadystatechange = null;
            };
            if(!oDoc.readyState){
                /**
                * <p>Emulates IE's readyState property, which always gives an integer from 0 to 4:</p>
                * <ul><li>1 == LOADING,</li>
                * <li>2 == LOADED,</li>
                * <li>3 == INTERACTIVE,</li>
                * <li>4 == COMPLETED</li></ul>
                */
                oDoc.readyState = 0;
            };
            oDoc.addEventListener("load", _sarissa_XMLDocument_onload, false);
            return oDoc;
        };
        if(window.XMLDocument){
            // do nothing
        }// TODO: check if the new document has content before trying to copynodes, check  for error handling in DOM 3 LS
        else if(_SARISSA_HAS_DOM_FEATURE && window.Document && !Document.prototype.load && document.implementation.hasFeature('LS', '3.0')){
            //Opera 9 may get the XPath branch which gives creates XMLDocument, therefore it doesn't reach here which is good
            /**
            * <p>Factory method to obtain a new DOM Document object</p>
            * @argument sUri the namespace of the root node (if any)
            * @argument sUri the local name of the root node (if any)
            * @returns a new DOM Document
            */
            Sarissa.getDomDocument = function(sUri, sName){
                var oDoc = document.implementation.createDocument(sUri?sUri:null, sName?sName:null, null);
                return oDoc;
            };
        }
        else {
            Sarissa.getDomDocument = function(sUri, sName){
                var oDoc = document.implementation.createDocument(sUri?sUri:null, sName?sName:null, null);
                // looks like safari does not create the root element for some unknown reason
                if(oDoc && (sUri || sName) && !oDoc.documentElement){
                    oDoc.appendChild(oDoc.createElementNS(sUri, sName));
                };
                return oDoc;
            };
        };
    };//if(_SARISSA_HAS_DOM_CREATE_DOCUMENT)
};
//==========================================
// Common stuff
//==========================================
if(!window.DOMParser){
    if(_SARISSA_IS_SAFARI){
        /*
         * DOMParser is a utility class, used to construct DOMDocuments from XML strings
         * @constructor
         */
        DOMParser = function() { };
        /** 
        * Construct a new DOM Document from the given XMLstring
        * @param sXml the given XML string
        * @param contentType the content type of the document the given string represents (one of text/xml, application/xml, application/xhtml+xml). 
        * @return a new DOM Document from the given XML string
        */
        DOMParser.prototype.parseFromString = function(sXml, contentType){
            var xmlhttp = new XMLHttpRequest();
            xmlhttp.open("GET", "data:text/xml;charset=utf-8," + encodeURIComponent(sXml), false);
            xmlhttp.send(null);
            return xmlhttp.responseXML;
        };
    }else if(Sarissa.getDomDocument && Sarissa.getDomDocument() && Sarissa.getDomDocument(null, "bar").xml){
        DOMParser = function() { };
        DOMParser.prototype.parseFromString = function(sXml, contentType){
            var doc = Sarissa.getDomDocument();
            doc.loadXML(sXml);
            return doc;
        };
    };
};

if((typeof(document.importNode) == "undefined") && _SARISSA_IS_IE){
    try{
        /**
        * Implementation of importNode for the context window document in IE
        * @param oNode the Node to import
        * @param bChildren whether to include the children of oNode
        * @returns the imported node for further use
        */
        document.importNode = function(oNode, bChildren){
            var tmp;
            if(oNode.nodeName == "tbody" || oNode.nodeName == "tr"){
                tmp = document.createElement("table");
            }
            else if(oNode.nodeName == "td"){
                tmp = document.createElement("tr");
            }
            else if(oNode.nodeName == "option"){
                tmp = document.createElement("select");
            }
            else{
                tmp = document.createElement("div");
            };
            if(bChildren){
                tmp.innerHTML = oNode.xml ? oNode.xml : oNode.outerHTML;
            }else{
                tmp.innerHTML = oNode.xml ? oNode.cloneNode(false).xml : oNode.cloneNode(false).outerHTML;
            };
            return tmp.getElementsByTagName("*")[0];
        };
    }catch(e){ };
};
if(!Sarissa.getParseErrorText){
    /**
     * <p>Returns a human readable description of the parsing error. Usefull
     * for debugging. Tip: append the returned error string in a &lt;pre&gt;
     * element if you want to render it.</p>
     * <p>Many thanks to Christian Stocker for the initial patch.</p>
     * @argument oDoc The target DOM document
     * @returns The parsing error description of the target Document in
     *          human readable form (preformated text)
     */
    Sarissa.getParseErrorText = function (oDoc){
        var parseErrorText = Sarissa.PARSED_OK;
        if(!oDoc.documentElement){
            parseErrorText = Sarissa.PARSED_EMPTY;
        } else if(oDoc.documentElement.tagName == "parsererror"){
            parseErrorText = oDoc.documentElement.firstChild.data;
            parseErrorText += "\n" +  oDoc.documentElement.firstChild.nextSibling.firstChild.data;
        } else if(oDoc.getElementsByTagName("parsererror").length > 0){
            var parsererror = oDoc.getElementsByTagName("parsererror")[0];
            parseErrorText = Sarissa.getText(parsererror, true)+"\n";
        } else if(oDoc.parseError && oDoc.parseError.errorCode != 0){
            parseErrorText = Sarissa.PARSED_UNKNOWN_ERROR;
        };
        return parseErrorText;
    };
};
Sarissa.getText = function(oNode, deep){
    var s = "";
    var nodes = oNode.childNodes;
    for(var i=0; i < nodes.length; i++){
        var node = nodes[i];
        var nodeType = node.nodeType;
        if(nodeType == Node.TEXT_NODE || nodeType == Node.CDATA_SECTION_NODE){
            s += node.data;
        } else if(deep == true
                    && (nodeType == Node.ELEMENT_NODE
                        || nodeType == Node.DOCUMENT_NODE
                        || nodeType == Node.DOCUMENT_FRAGMENT_NODE)){
            s += Sarissa.getText(node, true);
        };
    };
    return s;
};
if(!window.XMLSerializer 
    && Sarissa.getDomDocument 
    && Sarissa.getDomDocument("","foo", null).xml){
    /**
     * Utility class to serialize DOM Node objects to XML strings
     * @constructor
     */
    XMLSerializer = function(){};
    /**
     * Serialize the given DOM Node to an XML string
     * @param oNode the DOM Node to serialize
     */
    XMLSerializer.prototype.serializeToString = function(oNode) {
        return oNode.xml;
    };
};

/**
 * strips tags from a markup string
 */
Sarissa.stripTags = function (s) {
    return s.replace(/<[^>]+>/g,"");
};
/**
 * <p>Deletes all child nodes of the given node</p>
 * @argument oNode the Node to empty
 */
Sarissa.clearChildNodes = function(oNode) {
    // need to check for firstChild due to opera 8 bug with hasChildNodes
    while(oNode.firstChild) {
        oNode.removeChild(oNode.firstChild);
    };
};
/**
 * <p> Copies the childNodes of nodeFrom to nodeTo</p>
 * <p> <b>Note:</b> The second object's original content is deleted before 
 * the copy operation, unless you supply a true third parameter</p>
 * @argument nodeFrom the Node to copy the childNodes from
 * @argument nodeTo the Node to copy the childNodes to
 * @argument bPreserveExisting whether to preserve the original content of nodeTo, default is false
 */
Sarissa.copyChildNodes = function(nodeFrom, nodeTo, bPreserveExisting) {
    if((!nodeFrom) || (!nodeTo)){
        throw "Both source and destination nodes must be provided";
    };
    if(!bPreserveExisting){
        Sarissa.clearChildNodes(nodeTo);
    };
    var ownerDoc = nodeTo.nodeType == Node.DOCUMENT_NODE ? nodeTo : nodeTo.ownerDocument;
    var nodes = nodeFrom.childNodes;
    if(typeof(ownerDoc.importNode) != "undefined")  {
        for(var i=0;i < nodes.length;i++) {
            nodeTo.appendChild(ownerDoc.importNode(nodes[i], true));
        };
    } else {
        for(var i=0;i < nodes.length;i++) {
            nodeTo.appendChild(nodes[i].cloneNode(true));
        };
    };
};

/**
 * <p> Moves the childNodes of nodeFrom to nodeTo</p>
 * <p> <b>Note:</b> The second object's original content is deleted before 
 * the move operation, unless you supply a true third parameter</p>
 * @argument nodeFrom the Node to copy the childNodes from
 * @argument nodeTo the Node to copy the childNodes to
 * @argument bPreserveExisting whether to preserve the original content of nodeTo, default is
 */ 
Sarissa.moveChildNodes = function(nodeFrom, nodeTo, bPreserveExisting) {
    if((!nodeFrom) || (!nodeTo)){
        throw "Both source and destination nodes must be provided";
    };
    if(!bPreserveExisting){
        Sarissa.clearChildNodes(nodeTo);
    };
    var nodes = nodeFrom.childNodes;
    // if within the same doc, just move, else copy and delete
    if(nodeFrom.ownerDocument == nodeTo.ownerDocument){
        while(nodeFrom.firstChild){
            nodeTo.appendChild(nodeFrom.firstChild);
        };
    } else {
        var ownerDoc = nodeTo.nodeType == Node.DOCUMENT_NODE ? nodeTo : nodeTo.ownerDocument;
        if(typeof(ownerDoc.importNode) != "undefined") {
           for(var i=0;i < nodes.length;i++) {
               nodeTo.appendChild(ownerDoc.importNode(nodes[i], true));
           };
        }else{
           for(var i=0;i < nodes.length;i++) {
               nodeTo.appendChild(nodes[i].cloneNode(true));
           };
        };
        Sarissa.clearChildNodes(nodeFrom);
    };
};

/** 
 * <p>Serialize any object to an XML string. All properties are serialized using the property name
 * as the XML element name. Array elements are rendered as <code>array-item</code> elements, 
 * using their index/key as the value of the <code>key</code> attribute.</p>
 * @argument anyObject the object to serialize
 * @argument objectName a name for that object
 * @return the XML serializationj of the given object as a string
 */
Sarissa.xmlize = function(anyObject, objectName, indentSpace){
    indentSpace = indentSpace?indentSpace:'';
    var s = indentSpace  + '<' + objectName + '>';
    var isLeaf = false;
    if(!(anyObject instanceof Object) || anyObject instanceof Number || anyObject instanceof String 
        || anyObject instanceof Boolean || anyObject instanceof Date){
        s += Sarissa.escape(""+anyObject);
        isLeaf = true;
    }else{
        s += "\n";
        var itemKey = '';
        var isArrayItem = anyObject instanceof Array;
        for(var name in anyObject){
            s += Sarissa.xmlize(anyObject[name], (isArrayItem?"array-item key=\""+name+"\"":name), indentSpace + "   ");
        };
        s += indentSpace;
    };
    return s += (objectName.indexOf(' ')!=-1?"</array-item>\n":"</" + objectName + ">\n");
};

/** 
 * Escape the given string chacters that correspond to the five predefined XML entities
 * @param sXml the string to escape
 */
Sarissa.escape = function(sXml){
    return sXml.replace(/&/g, "&amp;")
        .replace(/</g, "&lt;")
        .replace(/>/g, "&gt;")
        .replace(/"/g, "&quot;")
        .replace(/'/g, "&apos;");
};

/** 
 * Unescape the given string. This turns the occurences of the predefined XML 
 * entities to become the characters they represent correspond to the five predefined XML entities
 * @param sXml the string to unescape
 */
Sarissa.unescape = function(sXml){
    return sXml.replace(/&apos;/g,"'")
        .replace(/&quot;/g,"\"")
        .replace(/&gt;/g,">")
        .replace(/&lt;/g,"<")
        .replace(/&amp;/g,"&");
};

if (!document.implementation) {
    document.implementation={
        "createDocument":function(sUri, sName, sNS) {
            return Sarissa.getDomDocument(sUri, sName, sNS);
        }
    }
} else {
    try {
        document.implementation.createDocument=function(sUri, sName, sNS) {
            return Sarissa.getDomDocument(sUri, sName, sNS);
        }
    } catch (ex) {}
}

// Implementation of XPATH in IE
var isIe = /MSIE [56789]/.test(navigator.userAgent) && (navigator.platform == "Win32");

// Mozilla has support by default, we don't have an implementation for the rest
if (isIe)
{
    // release number
    document.DomL3XPathRelease = "0.0.3.0";
    
    // XPathException
    // An Error object will be thrown, this is just a handler to instantiate that object
    var XPathException = new _XPathExceptionHandler();
    function _XPathExceptionHandler()
    {
        this.INVALID_EXPRESSION_ERR = 51;
        this.TYPE_ERR = 52;
        this.NOT_IMPLEMENTED_ERR = -1;
        this.RUNTIME_ERR = -2;
        
        this.ThrowNotImplemented = function(message)
        {
            ThrowError(this.NOT_IMPLEMENTED_ERR, "This functionality is not implemented.", message);
        }
        
        this.ThrowInvalidExpression = function(message)
        {
            ThrowError(this.INVALID_EXPRESSION_ERR, "Invalid expression", message);
        }
        
        this.ThrowType = function(message)
        {
            ThrowError(this.TYPE_ERR, "Type error", message);
        }
        
        this.Throw = function(message)
        {
            ThrowError(this.RUNTIME_ERR, "Run-time error", message);
        }
        
        function ThrowError(code, description, message)
        {
            var error = new Error(code, "DOM-L3-XPath " + document.DomL3XPathRelease + ": " + description + (message ? ", \"" + message  + "\"": ""));
            error.code = code;
            error.name = "XPathException";
            throw error;
        }
    }
    
    // DOMException
    // An Error object will be thrown, this is just a handler to instantiate that object
    var DOMException = new _DOMExceptionHandler();
    function _DOMExceptionHandler()
    {
        this.ThrowInvalidState = function(message)
        {
            ThrowError(13, "The state of the object is no longer valid", message);
        }

        function ThrowError(code, description, message)
        {
            var error = new Error(code, "DOM : " + description + (message ? ", \"" + message  + "\"": ""));
            error.code = code;
            error.name = "DOMException";
            throw error;
        }
    }

    // XPathEvaluator 
    // implemented as document object methods
    
    // XPathExpression createExpression(String expression, XPathNSResolver resolver)
    document.createExpression = function
        (
        expression,        // String
        resolver        // XPathNSResolver
        )
    {
        // returns XPathExpression object
        return new XPathExpression(expression, resolver);
    }

    // XPathNSResolver createNSResolver(nodeResolver)
    document.createNSResolver = function
        (
        nodeResolver    // Node
        )
    {
        // returns XPathNSResolver
        return new XPathNSResolver(nodeResolver);
    }

    // XPathResult evaluate(String expresison, Node contextNode, XPathNSResolver resolver, Number type, XPathResult result)
    document.evaluate = function
        (
        expression,        // String
        contextNode,    // Node
        resolver,        // XPathNSResolver
        type,            // Number
        result            // XPathResult
        )
        // can raise XPathException, DOMException
    {
        // return XPathResult
        return document.createExpression(expression, resolver).evaluate(contextNode, type, result);
    }

    // XPathExpression
    function XPathExpression
    (
        expression, // String
        resolver // XPathNSResolver
    )
    {
        this.expressionString = expression;
        this.resolver = resolver;

        // XPathResult evaluate(Node contextNode, Number type, XPathResult result)
        this.evaluate = function
        (
            contextNode, // Node
            type, // Number
            result // XPathResult        
        )
            // raises XPathException, DOMException
        {
            // return XPathResult
            return (result && result.constructor == XPathResult ? result.initialize(this, contextNode, resolver, type) : new XPathResult(this, contextNode, resolver, type));
        }
        
        this.toString = function()
        {
            return "[XPathExpression]";
        }
    }

    // XPathNSResolver
    function XPathNSResolver(node)
    {
        this.node = node;
    
        // String lookupNamespaceURI(String prefix)
        this.lookupNamespaceURI = function
            (
            prefix            // String
            )
        {
            XPathException.ThrowNotImplemented();
            // return String
            return null;
        }

        this.toString = function()
        {
            return "[XPathNSResolver]";
        }
    }

    // XPathResult
    XPathResult.ANY_TYPE = 0;
    XPathResult.NUMBER_TYPE = 1;
    XPathResult.STRING_TYPE = 2;
    XPathResult.BOOLEAN_TYPE = 3;
    XPathResult.UNORDERED_NODE_ITERATOR_TYPE = 4;
    XPathResult.ORDERED_NODE_ITERATOR_TYPE = 5;
    XPathResult.UNORDERED_SNAPSHOT_TYPE = 6;
    XPathResult.ORDERED_SNAPSHOT_TYPE = 7;
    XPathResult.ANY_UNORDERED_NODE_TYPE = 8;
    XPathResult.FIRST_ORDERED_NODE_TYPE = 9;
    
    function XPathResult
            (
            expression,        // XPathExpression
            contextNode,    // Node
            resolver,        // XPathNSResolver
            type            // Number
            )
    {
        this.initialize = function(expression, contextNode, resolver, type)
        {
            this._domResult = null;
            this._expression = expression;
            this._contextNode = contextNode;
            this._resolver = resolver;
            if (type)
            {
                this.resultType = type;
                this._isIterator = (type == XPathResult.UNORDERED_NODE_ITERATOR_TYPE || 
                    type == XPathResult.ORDERED_NODE_ITERATOR_TYPE || 
                    type == XPathResult.ANY_TYPE);
                this._isSnapshot = (type == XPathResult.UNORDERED_SNAPSHOT_TYPE || type == XPathResult.ORDERED_SNAPSHOT_TYPE);
                this._isNodeSet = type > XPathResult.BOOLEAN_TYPE;
            }
            else
            {
                this.resultType = XPathResult.ANY_TYPE;
                this._isIterator = true;
                this._isSnapshot = false;
                this._isNodeSet = true;
            }
            return this;
        }
        
        this.initialize(expression, contextNode, resolver, type);
        
        this.getInvalidIteratorState = function()
        {
            return documentChangeDetected() || !this._isIterator;            
        }
        
        this.getSnapshotLength = function()
            // raises XPathException
        {
            if (!this._isSnapshot)
            {
                XPathException.ThrowType("Snapshot is not an expected result type");
            }
            activateResult(this);
            // return Number
            return this._domResult.length;
        }
        
        // Node iterateNext()
        this.iterateNext = function()
            // raises XPathException, DOMException
        {
            if (!this._isIterator)
            {
                XPathException.ThrowType("Iterator is not an expected result type");
            }
            activateResult(this);
            if (documentChangeDetected())
            {
                DOMException.ThrowInvalidState("iterateNext");
            }
            // return Node
            return getNextNode(this);
        }
        
        // Node snapshotItem(Number index)
        this.snapshotItem = function(index)
            // raises XPathException
        {
            if (!this._isSnapshot)
            {
                XPathException.ThrowType("Snapshot is not an expected result type");
            }
            // return Node
            return getItemNode(this, index); 
        }
        
        this.toString = function()
        {
            return "[XPathResult]";
        }
        
        // returns string value of the result, if result type is STRING_TYPE
        // otherwise throws an XPathException
        this.getStringValue = function()
        {
            if (this.resultType != XPathResult.STRING_TYPE)
            {
                XPathException.ThrowType("The expression can not be converted to return String");
            }
            return getNodeText(this);
        }
        
        // returns number value of the result, if the result is NUMBER_TYPE
        // otherwise throws an XPathException
        this.getNumberValue = function()
        {
            if (this.resultType != XPathResult.NUMBER_TYPE)
            {
                XPathException.ThrowType("The expression can not be converted to return Number");
            }
            var number = parseInt(getNodeText(this));
            if (isNaN(number))
            {
                XPathException.ThrowType("The result can not be converted to Number");
            }
            return number;
        }
        
        // returns boolean value of the result, if the result is BOOLEAN_TYPE
        // otherwise throws an XPathException
        this.getBooleanValue = function()
        {
            if (this.resultType != XPathResult.BOOLEAN_TYPE)
            {
                XPathException.ThrowType("The expression can not be converted to return Boolean");
            }
            
            var    
                text = getNodeText(this);
                bool = (text ? text.toLowerCase() : null);
            if (bool == "false" || bool == "true")
            {
                return bool;
            }
            XPathException.ThrowType("The result can not be converted to Boolean");
        }
        
        // returns single node, if the result is ANY_UNORDERED_NODE_TYPE or FIRST_ORDERED_NODE_TYPE
        // otherwise throws an XPathException
        this.getSingleNodeValue = function()
        {
            if (this.resultType != XPathResult.ANY_UNORDERED_NODE_TYPE && 
                this.resultType != XPathResult.FIRST_ORDERED_NODE_TYPE)
            {
                XPathException.ThrowType("The expression can not be converted to return single Node value");
            }
            return getSingleNode(this);
        }
        
        function documentChangeDetected()
        {
            return document._XPathMsxmlDocumentHelper.documentChangeDetected();
        }
        
        function getNodeText(result)
        {
            activateResult(result);
            return result._textResult;
//            return ((node = getSingleNode(result)) ? (node.nodeType == 1 ? node.innerText : node.nodeValue) : null);
        }
        
        function findNode(result, current)
        {
            switch(current.nodeType)
            {
                case 1: // NODE_ELEMENT
                    var id = current.attributes.getNamedItem("id");
                    if (id)
                    {
                        return document.getElementById(id.value);
                    }
                    XPathException.Throw("unable to locate element in XML tree");
                case 2: // NODE_ATTRIBUTE
                    var id = current.selectSingleNode("..").attributes.getNamedItem("id");
                    if (id)
                    {
                        var node = document.getElementById(id.text);
                        if (node)
                        {
                            return node.attributes.getNamedItem(current.nodeName);
                        }
                    }
                    XPathException.Throw("unable to locate attribute in XML tree");
                case 3: // NODE_TEXT
                    var id = current.selectSingleNode("..").attributes.getNamedItem("id");
                    if (id)
                    {
                        var node = document.getElementById(id.value);
                        if (node)
                        {
                            for(child in node.childNodes)
                            {
                                if (child.nodeType == 3 && child.nodeValue == current.nodeValue)
                                {
                                    return child;
                                }
                            }
                        }
                    }
                    XPathException.Throw("unable to locate text in XML tree");
            }
            XPathException.Throw("unknown node type");
        }
        
        function activateResult(result)
        {
            if (!result._domResult)
            {
                try
                {
                    var expression = result._expression.expressionString;
                    
                    // adjust expression if contextNode is not a document
                    if (result._contextNode != document && expression.indexOf("//") != 0)
                    {
                        
                        expression = "//*[@id = '" + result._contextNode.id + "']" + 
                            (expression.indexOf("/") == 0 ? "" : "/") + expression;
                    }
                    
                    if (result._isNodeSet)
                    {
                        result._domResult = document._XPathMsxmlDocumentHelper.getDom().selectNodes(expression);
                    }
                    else
                    {
                        result._domResult = true;
                        result._textResult = document._XPathMsxmlDocumentHelper.getTextResult(expression);
                    }
                    
                }
                catch(error)
                {
                    alert(error.description);
                    XPathException.ThrowInvalidExpression(error.description);
                }
            }
        }

        function getSingleNode(result)
        {
            var node = getItemNode(result, 0);
            result._domResult = null;
            return node;
        }
        
        function getItemNode(result, index)
        {
            activateResult(result);
            var current = result._domResult.item(index);
            return (current ? findNode(result, current) : null);
        }
        
        function getNextNode(result)
        {
            var current = result._domResult.nextNode;
            if (current)
            {
                return findNode(result, current);
            }
            result._domResult = null;
            return null;
        }
    }
    
    document.reloadDom = function()
    {
        document._XPathMsxmlDocumentHelper.reset();
    }

    document._XPathMsxmlDocumentHelper = new _XPathMsxmlDocumentHelper();
    function _XPathMsxmlDocumentHelper()
    {
        this.getDom = function()
        {
            activateDom(this);
            return this.dom;
        }
        
        this.getXml = function()
        {
            activateDom(this);
            return this.dom.xml;
        }
        
        this.getTextResult = function(expression)
        {
            expression = expression.replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "\"");
            var xslText = "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\">" +
                "<xsl:output method=\"text\"/><xsl:template match=\"*\"><xsl:value-of select=\"" + expression + "\"/>" +
                "</xsl:template></xsl:stylesheet>";
            var xsl = new ActiveXObject("Msxml2.DOMDocument");
            xsl.loadXML(xslText);
            try
            {
                var result = this.getDom().transformNode(xsl);
            }
            catch(error)
            {
                alert("Error: " + error.description);
            }
            return result;
        }
        
        this.reset = function()
        {
            this.dom = null;
        }
        
        function onPropertyChangeEventHandler()
        {
            document._propertyChangeDetected = true;
        }
        
        this.documentChangeDetected = function()
        {
            return (document.ignoreDocumentChanges ? false : this._currentElementCount != document.all.length || document._propertyChangeDetected);
        }
        
        function activateDom(helper)
        {
            if (!helper.dom)
            {
                var dom = new ActiveXObject("Msxml2.DOMDocument");
                dom.async = false;
                dom.resolveExternals = false;
                loadDocument(dom, helper);
                helper.dom = dom;
                helper._currentElementCount = document.all.length;
                document._propertyChangeDetected = false;
            }
            else
            {
                if (helper.documentChangeDetected())
                {
                    var dom = helper.dom;
                    dom.load("");
                    loadDocument(dom, helper);
                    helper._currentElementCount = document.all.length;
                    document._propertyChangeDetected = false;
                }
            }
        }
        
        function loadDocument(dom, helper)
        {
            return loadNode(dom, dom, document.body, helper);        
        }
        
        function loadNode(dom, domParentNode, node, helper)
        {
            if (node.nodeType == 3)
            {            
                domParentNode.appendChild(dom.createTextNode(node.nodeValue));
            }
            else
            {
                var domNode = dom.createElement(node.nodeName.toLowerCase());
                if (!node.id)
                {
                    node.id = node.uniqueID;
                }
                domParentNode.appendChild(domNode);
                loadAttributes(dom, domNode, node);
                var length = node.childNodes.length;
                for(var i = 0; i < length; i ++ )
                {
                    loadNode(dom, domNode, node.childNodes[i], helper);
                }
                node.attachEvent("onpropertychange", onPropertyChangeEventHandler);
            }
        }

        function loadAttributes(dom, domParentNode, node)
        {
            for (var i = 0; i < node.attributes.length; i ++ )
            {
                var attribute = node.attributes[i];
                var attributeValue = attribute.nodeValue;
                if (attributeValue && attribute.specified)
                {
                    var domAttribute = dom.createAttribute(attribute.nodeName);
                    domAttribute.value = attributeValue;
                    domParentNode.setAttributeNode(domAttribute);                
                }
            }
        }
    
    }
}
else
{
    document.reloadDom = function() {}
    XPathResult.prototype.getStringValue = function()
    {
        return this.stringValue;
    }
    
    XPathResult.prototype.getNumberValue = function()
    {
        return this.numberValue;
    }
    
    XPathResult.prototype.getBooleanValue = function()
    {
        return this.booleanValue;
    }
    
    XPathResult.prototype.getSingleNodeValue = function()
    {
        return this.singleNodeValue;    
    }
    
    XPathResult.prototype.getInvalidIteratorState = function()
    {
        return this.invalidIteratorState;
    }
    
    XPathResult.prototype.getSnapshotLength = function()
    {
        return this.snapshotLength;
    }
    
    XPathResult.prototype.getResultType = function()
    {
        return this.resultType;
    }
}

//   EOF