navigator.isIE = function() {
    return (this.appVersion.indexOf("MSIE") > -1);
}

if (!navigator.isIE() && typeof (Element) != 'undefined') {
    Element.prototype.selectNodes = function(sXPath) {
        var oEvaluator = new XPathEvaluator();
        var oResult = oEvaluator.evaluate(sXPath, this, null, XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
        var aNodes = new Array();
        if (oResult != null) {
            var oElement = oResult.iterateNext();
            while (oElement) {
                aNodes.push(oElement);
                oElement = oResult.iterateNext();
            }
        }
        return aNodes;
    }
    Element.prototype.selectSingleNode = function(sXPath) {
        var oEvaluator = new XPathEvaluator();
        // FIRST_ORDERED_NODE_TYPE returns the first match to the xpath.
        var oResult = oEvaluator.evaluate(sXPath, this, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
        if (oResult != null) {
            return oResult.singleNodeValue;
        } else {
            return null;
        }
    }
    Node.prototype.__defineGetter__('xml', function() {
        return (new XMLSerializer()).serializeToString(this);
    });

    Node.prototype.__defineGetter__('text', function() {
        return this.textContent;
    });

    HTMLElement.prototype.__defineGetter__('innerText', function() {
        return this.textContent;
    });
    
    HTMLElement.prototype.insertAdjacentElement = function(where, parsedNode) {
        switch (where) {
            case 'beforeBegin':
                return this.parentNode.insertBefore(parsedNode, this);
                break;
            case 'afterBegin':
                return this.insertBefore(parsedNode, this.firstChild);
                break;
            case 'beforeEnd':
                return this.appendChild(parsedNode);
                break;
            case 'afterEnd':
                if (this.nextSibling)
                    return this.parentNode.insertBefore(parsedNode, this.nextSibling);
                else
                    return this.parentNode.appendChild(parsedNode);
                break;
        }
    }

    HTMLElement.prototype.insertAdjacentHTML = function(where, htmlStr) {
        var r = this.ownerDocument.createRange();
        r.setStartBefore(this);
        var parsedHTML = r.createContextualFragment(htmlStr);
        return this.insertAdjacentElement(where, parsedHTML);
    }


    HTMLElement.prototype.insertAdjacentText = function(where, txtStr) {
        var parsedText = document.createTextNode(txtStr);
        return this.insertAdjacentElement(where, parsedText);
    }

    HTMLElement.prototype.__defineGetter__('transparacy', function() {
        return this._tranceparacy;
    });

    HTMLElement.prototype.__defineSetter__('transparacy', function(val) {
        this._tranceparacy = val;
        this.applyEffect(window.ECOEffects.TRANSPARENT_EFFECT, this._tranceparacy);
    });
}

var BrowserDetect = {
    init: function() {
        this.browser = this.searchString(this.dataBrowser) || "unknown";
        this.version = this.searchVersion(navigator.userAgent)
			    || this.searchVersion(navigator.appVersion)
			    || "unknown";
        this.OS = this.searchString(this.dataOS) || "unknown";
    },
    searchString: function(data) {
        for (var i = 0; i < data.length; i++) {
            var dataString = data[i].string;
            var dataProp = data[i].prop;
            this.versionSearchString = data[i].versionSearch || data[i].identity;
            if (dataString) {
                if (dataString.indexOf(data[i].subString) != -1)
                    return data[i].identity;
            }
            else if (dataProp)
                return data[i].identity;
        }
    },
    searchVersion: function(dataString) {
        var index = dataString.indexOf(this.versionSearchString);
        if (index == -1) return;
        return parseFloat(dataString.substring(index + this.versionSearchString.length + 1));
    },
    dataBrowser: [
		    { string: navigator.userAgent,
		        subString: "OmniWeb",
		        versionSearch: "OmniWeb/",
		        identity: "OmniWeb"
		    },
		    {
		        string: navigator.vendor,
		        subString: "Google",
		        identity: "Chrome"
		    },
		    {
		        string: navigator.vendor,
		        subString: "Apple",
		        identity: "Safari"
		    },
		    {
		        prop: window.opera,
		        identity: "Opera"
		    },
		    {
		        string: navigator.vendor,
		        subString: "iCab",
		        identity: "iCab"
		    },
		    {
		        string: navigator.vendor,
		        subString: "KDE",
		        identity: "Konqueror"
		    },
		    {
		        string: navigator.userAgent,
		        subString: "Firefox",
		        identity: "Firefox"
		    },
		    {
		        string: navigator.vendor,
		        subString: "Camino",
		        identity: "Camino"
		    },
		    {		// for newer Netscapes (6+)
		        string: navigator.userAgent,
		        subString: "Netscape",
		        identity: "Netscape"
		    },
		    {
		        string: navigator.userAgent,
		        subString: "MSIE",
		        identity: "Explorer",
		        versionSearch: "MSIE"
		    },
		    {
		        string: navigator.userAgent,
		        subString: "Gecko",
		        identity: "Mozilla",
		        versionSearch: "rv"
		    },
		    { 		// for older Netscapes (4-)
		        string: navigator.userAgent,
		        subString: "Mozilla",
		        identity: "Netscape",
		        versionSearch: "Mozilla"
		    }
	    ],
    dataOS: [
		    {
		        string: navigator.platform,
		        subString: "Win",
		        identity: "Windows"
		    },
		    {
		        string: navigator.platform,
		        subString: "Mac",
		        identity: "Mac"
		    },
		    {
		        string: navigator.platform,
		        subString: "Linux",
		        identity: "Linux"
		    }
	    ]

};
BrowserDetect.init();

function XmlHttpFactory() { }

XmlHttpFactory._pool = new Array();
XmlHttpFactory._get = function() {
    if (XmlHttpFactory._pool.length == 0) {
        var soc = XmlHttpFactory._createInstance();
        return soc;
    }
    var soc = XmlHttpFactory._pool.shift();
    soc.abort();
    return soc;
}
XmlHttpFactory._release = function(transport) {
    delete transport.readyState;
    delete transport.onreadystatechange;
    delete transport.onload;
    delete transport.onprogress;
    delete transport.onerror;

    delete transport.responseText;
    delete transport.status;
    delete transport.responseXML;
    //delete transport._xmlHttpRequest;
}

function XmlHttpTransport(req) {

    this._xmlHttpRequest = req;
    this.readyState = -1;
    this.onreadystatechange = null;
    this.onload = null;
    this.onprogress = null;
    this.onerror = null;

    this.responseText = '';
    this.status = 0;
    this.responseXML = null;

    var instance = this;

    this._updateFields = function(evt) {
        if (!this._xmlHttpRequest)
            return;
        var stateChanged = (this.readyState != this._xmlHttpRequest.readyState);
        this.readyState = this._xmlHttpRequest.readyState;
        switch (this.readyState) {
            case 4:
                this.responseText = this._xmlHttpRequest.responseText;
                this.status = this._xmlHttpRequest.status;
                this.responseXML = this._xmlHttpRequest.responseXML;
                break;
        }
        if ((this.readyState >= 3 || (evt || stateChanged)) && typeof (instance.onreadystatechange) == 'function') instance.onreadystatechange(evt);
    }

    this.open = function(method, url, async) {
        this._xmlHttpRequest.open(method, url, async);
        if (async) {
            this._xmlHttpRequest.onreadystatechange = function(evt) {
                evt = (evt ? evt : event);
                instance._updateFields(evt);
            }
        }
        instance._updateFields();
    }

    this.send = function(data) {
        if (!data)
            data = '';
        this._xmlHttpRequest.send(data);
        instance._updateFields();
    }

    this.abort = function() {
        this._xmlHttpRequest.abort();
    }

    this.setRequestHeader = function(key, value) {
        this._xmlHttpRequest.setRequestHeader(key, value);
    }

    if (XmlHttpFactory._useNamedEvents) {
        this._xmlHttpRequest.onload = function(evt) {
            if (typeof (instance.onload) == 'function') instance.onload(evt);
            instance._updateFields(evt);
        }

        this._xmlHttpRequest.onprogress = function(evt) {
            if (typeof (instance.onprogress) == 'function') instance.onprogress(evt);
            instance._updateFields(evt);
        }

        this._xmlHttpRequest.onerror = function(evt) {
            if (typeof (instance.onerror) == 'function') instance.onerror(evt);
            instance._updateFields(evt);
        }
    }
    if (BrowserDetect.browser == 'Explorer' && BrowserDetect.version == 7) {
        this._xmlHttpRequest.onreadystatechange = function(evt) {
            evt = (evt ? evt : event);
            instance._updateFields(evt);
        }

        this._xmlHttpRequest.onload = function(evt) {
            instance._updateFields(evt);
        };

    }
}

XmlHttpFactory._useNamedEvents = window.XMLHttpRequest;
XmlHttpFactory._createInstance = function() {
    var req = null;
    try {
        if (window.XMLHttpRequest) {
            req = new XMLHttpRequest();
            // some older versions of Moz did not support the readyState property
            // and the onreadystate event so we patch it!
            if ((null == req.readyState) || (typeof (req.readyState) == 'undefined')) {
                req.encodeContent = true;
                req.readyState = 1;
                var fnc = function(evt) {
                    req.readyState = 4;
                    if (typeof (req.onreadystatechange) == 'function') {
                        req.onreadystatechange(evt);
                    }
                    //delete req.onreadystatechange;
                };
                req.addEventListener("load", fnc, false);
            }
            return new XmlHttpTransport(req);
        }
        if (window.ActiveXObject) {
            req = new ActiveXObject(getControlPrefix() + ".XmlHttp");
            return new XmlHttpTransport(req);
        }
    }
    catch (ex) { throw ex; }
    // fell through
    throw new Error("Your browser does not support XmlHttp objects");
};

function getControlPrefix() {
    if (getControlPrefix.prefix)
        return getControlPrefix.prefix;

    var prefixes = ["MSXML2", "Microsoft", "MSXML", "MSXML3"];
    var o, o2;
    for (var i = 0; i < prefixes.length; i++) {
        try {
            // try to create the objects
            o = new ActiveXObject(prefixes[i] + ".XmlHttp");
            o2 = new ActiveXObject(prefixes[i] + ".XmlDom");
            return getControlPrefix.prefix = prefixes[i];
        }
        catch (ex) { };
    }

    throw new Error("Could not find an installed XML parser");
}

// Event object IE emulation
if (typeof (Event) != 'undefined' && Event.prototype.__defineGetter__) {
    Event.prototype.__defineGetter__("srcElement", function() {
        var node = this.target;
        while (node.nodeType != 1) node = node.parentNode;
        return node;
    });

    if (!Event.prototype.cancelBubble) {
        Event.prototype.__defineSetter__("cancelBubble", function(b) {
            if (b) this.stopPropagation();
        });
    }

    //if (!Event.prototype.returnValue) {
    Event.prototype.__defineSetter__("returnValue", function(b) {
        if (!b) this.preventDefault();
    });
    //}

    Event.prototype.__defineGetter__("fromElement", function() {
        var node;
        if (this.type == "mouseover")
            node = this.relatedTarget;
        else if (this.type == "mouseout")
            node = this.target;
        else
            return null;
        var node = this.target;
        while (node.nodeType != 1) node = node.parentNode;
        return node;
    });

    Event.prototype.__defineGetter__("toElement", function() {
        var node;
        if (this.type == "mouseout")
            node = this.relatedTarget;
        else if (this.type == "mouseover")
            node = this.target;
        else
            return null;
        var node = this.target;
        while (node.nodeType != 1) node = node.parentNode;
        return node;
    });

    Event.prototype.__defineGetter__("offsetX", function() {
        return this.layerX;
    });

    Event.prototype.__defineGetter__("offsetY", function() {
        return this.layerY;
    });

}

function getChildTag(element, tag, index) {
    var ix = 0;
    if (tag && element) {
        for (var i = 0; i < element.childNodes.length; i++) {
            if (element.childNodes[i].tagName && tag.toLowerCase() == element.childNodes[i].tagName.toLowerCase()) {
                if (index == ix) {
                    return element.childNodes[i];
                }
                ix++;
            }
        }
    }
    return null;
}

function getNextSibling(element) {
    var ns = element.nextSibling;
    while (ns && ns.nodeType != 1) {
        ns = ns.nextSibling;
    }
    return ns;
}

function getPreviousSibling(element) {
    var ps = element.previousSibling;
    while (ps && ps.nodeType != 1) {
        ps = ps.previousSibling;
    }
    return ps;
}

function getAbsolutePosition(element, doc) {
    doc = (doc ? doc : document);
    var x = 0;
    var y = 0;
    var parent = element;

    if (navigator.userAgent.toLowerCase().indexOf("msie") == -1) {
        while (parent) {
            x += parent.offsetLeft;
            y += parent.offsetTop;
            //parent = (parent.tagName.toLowerCase() == 'iframe' ? null : parent.offsetParent);
            parent = parent.offsetParent;
        }

        parent = element;
        while (parent &&
            parent != doc.body &&
			parent != doc.documentElement) {
            if (parent.scrollLeft)
                x -= parent.scrollLeft;
            if (parent.scrollTop)
                y -= parent.scrollTop;
            //parent = (parent.tagName.toLowerCase() == 'iframe' ? null : parent.offsetParent);
            parent = parent.offsetParent;
        }
    }
    else {

        while (parent) {
            var borderXOffset = 0;
            var borderYOffset = 0;
            if (parent != element) {
                var borderXOffset = parseInt(getElementCurrentStyle(parent, "borderLeftWidth"));
                var borderYOffset = parseInt(getElementCurrentStyle(parent, "borderTopWidth"));
                borderXOffset = isNaN(borderXOffset) ? 0 : borderXOffset;
                borderYOffset = isNaN(borderYOffset) ? 0 : borderYOffset;
            }
            x += parent.offsetLeft - parent.scrollLeft + borderXOffset;
            y += parent.offsetTop - parent.scrollTop + borderYOffset;
            //parent = (parent.tagName.toLowerCase() == 'iframe' ? null : parent.offsetParent);
            parent = parent.offsetParent;
        }
    }
    return new ElementPosition(x, y, element.offsetWidth, element.offsetHeight);
}

function ElementPosition(x, y, width, height) {
    this.x = x;
    this.y = y;
    this.width = width;
    this.height = height;
}

ElementPosition.prototype.toString = function() {
    return 'x:' + this.x + ', y:' + this.y + ', width:' + this.width + ', height:' + this.height;
}

function getElementCurrentStyle(element, style) {
    if (element.currentStyle) {
        return element.currentStyle[style];
    }
    else {
        return document.defaultView.getComputedStyle(element, null).getPropertyValue(style);
    }
}


var currentExpertItemIndex = 0;
function movePrevExpert(evt) {
    var itemsBox = document.getElementById('expertsItemsBox');
    var itemsInner = document.getElementById('expertsItemsInner');
    if (!itemsInner.items || 0 == itemsInner.items.length)
        return;
    currentExpertItemIndex--;
    if (0 > currentExpertItemIndex)
        currentExpertItemIndex = itemsInner.items.length - 1;
    var item = itemsInner.removeChild(itemsInner.items[currentExpertItemIndex]);
    if (!itemsInner.childNodes[0]) {
        itemsInner.appendChild(item);
        return;
    }
    itemsInner.insertBefore(item, itemsInner.childNodes[0]);
    if (evt) {
        evt.cancelBubble = true;
        evt.returnValue = false;
    }
    return;
}

function moveNextExpert(evt) {
    var itemsBox = document.getElementById('expertsItemsBox');
    var itemsInner = document.getElementById('expertsItemsInner');
    if (!itemsInner.items || 1 > itemsInner.items.length)
        return;
    var item = itemsInner.removeChild(itemsInner.items[currentExpertItemIndex]);
    itemsInner.appendChild(item);

    currentExpertItemIndex++;
    if (currentExpertItemIndex >= itemsInner.items.length)
        currentExpertItemIndex = 0;
    if (evt) {
        evt.cancelBubble = true;
        evt.returnValue = false;
    }
    return;
}

var currentItemIndex = 0;
function movePrev(evt) {
    var itemsBox = document.getElementById('itemsBox');
    var itemsInner = document.getElementById('itemsInner');
    if (!itemsInner.items || 0 == itemsInner.items.length)
        return;
    currentItemIndex--;
    if (0 > currentItemIndex)
        currentItemIndex = itemsInner.items.length - 1;
    var item = itemsInner.removeChild(itemsInner.items[currentItemIndex]);
    if (!itemsInner.childNodes[0]) {
        itemsInner.appendChild(item);
        return;
    }
    itemsInner.insertBefore(item, itemsInner.childNodes[0]);
    if (evt) {
        evt.cancelBubble = true;
        evt.returnValue = false;
    }
    return;
}

function moveNext(evt) {
    var itemsBox = document.getElementById('itemsBox');
    var itemsInner = document.getElementById('itemsInner');
    if (!itemsInner.items || 1 > itemsInner.items.length)
        return;
    var item = itemsInner.removeChild(itemsInner.items[currentItemIndex]);
    itemsInner.appendChild(item);
    
    currentItemIndex++;
    if (currentItemIndex >= itemsInner.items.length)
        currentItemIndex = 0;
    if (evt) {
        evt.cancelBubble = true;
        evt.returnValue = false;
    }
    return;
}


function boxMovePrev(evt, boxId, innerId) {
    var itemsBox = document.getElementById(boxId);
    var itemsInner = document.getElementById(innerId);
    if (!itemsInner.items || 0 == itemsInner.items.length)
        return;
    itemsInner.currentItemIndex--;
    if (0 > itemsInner.currentItemIndex)
        itemsInner.currentItemIndex = itemsInner.items.length - 1;
    var item = itemsInner.removeChild(itemsInner.items[itemsInner.currentItemIndex]);
    if (!itemsInner.childNodes[0]) {
        itemsInner.appendChild(item);
        return;
    }
    itemsInner.insertBefore(item, itemsInner.childNodes[0]);
    return;
}

function boxMoveNext(evt, boxId, innerId) {
    var itemsBox = document.getElementById(boxId);
    var itemsInner = document.getElementById(innerId);
    if (!itemsInner.items || 2 > itemsInner.items.length)
        return;

    var item = itemsInner.removeChild(itemsInner.items[itemsInner.currentItemIndex]);
    itemsInner.appendChild(item);

    itemsInner.currentItemIndex++;
    if (itemsInner.currentItemIndex >= itemsInner.items.length)
        itemsInner.currentItemIndex = 0;
    return;
}

function stopMarquee(marquee, evt) {
    marquee.stop();
    if (evt) {
        evt.cancelBubble = true;
        evt.returnValue = false;
    }
    return;
}

function startMarquee(marquee, evt) {
    marquee.start();
    if (evt) {
        evt.cancelBubble = true;
        evt.returnValue = false;
    }
    return;
}

Encoder = {

    // When encoding do we convert characters into html or numerical entities
    EncodeType: "entity",  // entity OR numerical

    isEmpty: function(val) {
        if (val) {
            return ((val === null) || val.length == 0 || /^\s+$/.test(val));
        } else {
            return true;
        }
    },
    // Convert HTML entities into numerical entities
    HTML2Numerical: function(s) {
        var arr1 = new Array('&nbsp;', '&iexcl;', '&cent;', '&pound;', '&curren;', '&yen;', '&brvbar;', '&sect;', '&uml;', '&copy;', '&ordf;', '&laquo;', '&not;', '&shy;', '&reg;', '&macr;', '&deg;', '&plusmn;', '&sup2;', '&sup3;', '&acute;', '&micro;', '&para;', '&middot;', '&cedil;', '&sup1;', '&ordm;', '&raquo;', '&frac14;', '&frac12;', '&frac34;', '&iquest;', '&agrave;', '&aacute;', '&acirc;', '&atilde;', '&Auml;', '&aring;', '&aelig;', '&ccedil;', '&egrave;', '&eacute;', '&ecirc;', '&euml;', '&igrave;', '&iacute;', '&icirc;', '&iuml;', '&eth;', '&ntilde;', '&ograve;', '&oacute;', '&ocirc;', '&otilde;', '&Ouml;', '&times;', '&oslash;', '&ugrave;', '&uacute;', '&ucirc;', '&Uuml;', '&yacute;', '&thorn;', '&szlig;', '&agrave;', '&aacute;', '&acirc;', '&atilde;', '&auml;', '&aring;', '&aelig;', '&ccedil;', '&egrave;', '&eacute;', '&ecirc;', '&euml;', '&igrave;', '&iacute;', '&icirc;', '&iuml;', '&eth;', '&ntilde;', '&ograve;', '&oacute;', '&ocirc;', '&otilde;', '&ouml;', '&divide;', '&Oslash;', '&ugrave;', '&uacute;', '&ucirc;', '&uuml;', '&yacute;', '&thorn;', '&yuml;', '&quot;', '&amp;', '&lt;', '&gt;', '&oelig;', '&oelig;', '&scaron;', '&scaron;', '&yuml;', '&circ;', '&tilde;', '&ensp;', '&emsp;', '&thinsp;', '&zwnj;', '&zwj;', '&lrm;', '&rlm;', '&ndash;', '&mdash;', '&lsquo;', '&rsquo;', '&sbquo;', '&ldquo;', '&rdquo;', '&bdquo;', '&dagger;', '&dagger;', '&permil;', '&lsaquo;', '&rsaquo;', '&euro;', '&fnof;', '&alpha;', '&beta;', '&gamma;', '&delta;', '&epsilon;', '&zeta;', '&eta;', '&theta;', '&iota;', '&kappa;', '&lambda;', '&mu;', '&nu;', '&xi;', '&omicron;', '&pi;', '&rho;', '&sigma;', '&tau;', '&upsilon;', '&phi;', '&chi;', '&psi;', '&omega;', '&alpha;', '&beta;', '&gamma;', '&delta;', '&epsilon;', '&zeta;', '&eta;', '&theta;', '&iota;', '&kappa;', '&lambda;', '&mu;', '&nu;', '&xi;', '&omicron;', '&pi;', '&rho;', '&sigmaf;', '&sigma;', '&tau;', '&upsilon;', '&phi;', '&chi;', '&psi;', '&omega;', '&thetasym;', '&upsih;', '&piv;', '&bull;', '&hellip;', '&prime;', '&prime;', '&oline;', '&frasl;', '&weierp;', '&image;', '&real;', '&trade;', '&alefsym;', '&larr;', '&uarr;', '&rarr;', '&darr;', '&harr;', '&crarr;', '&larr;', '&uarr;', '&rarr;', '&darr;', '&harr;', '&forall;', '&part;', '&exist;', '&empty;', '&nabla;', '&isin;', '&notin;', '&ni;', '&prod;', '&sum;', '&minus;', '&lowast;', '&radic;', '&prop;', '&infin;', '&ang;', '&and;', '&or;', '&cap;', '&cup;', '&int;', '&there4;', '&sim;', '&cong;', '&asymp;', '&ne;', '&equiv;', '&le;', '&ge;', '&sub;', '&sup;', '&nsub;', '&sube;', '&supe;', '&oplus;', '&otimes;', '&perp;', '&sdot;', '&lceil;', '&rceil;', '&lfloor;', '&rfloor;', '&lang;', '&rang;', '&loz;', '&spades;', '&clubs;', '&hearts;', '&diams;');
        var arr2 = new Array('&#160;', '&#161;', '&#162;', '&#163;', '&#164;', '&#165;', '&#166;', '&#167;', '&#168;', '&#169;', '&#170;', '&#171;', '&#172;', '&#173;', '&#174;', '&#175;', '&#176;', '&#177;', '&#178;', '&#179;', '&#180;', '&#181;', '&#182;', '&#183;', '&#184;', '&#185;', '&#186;', '&#187;', '&#188;', '&#189;', '&#190;', '&#191;', '&#192;', '&#193;', '&#194;', '&#195;', '&#196;', '&#197;', '&#198;', '&#199;', '&#200;', '&#201;', '&#202;', '&#203;', '&#204;', '&#205;', '&#206;', '&#207;', '&#208;', '&#209;', '&#210;', '&#211;', '&#212;', '&#213;', '&#214;', '&#215;', '&#216;', '&#217;', '&#218;', '&#219;', '&#220;', '&#221;', '&#222;', '&#223;', '&#224;', '&#225;', '&#226;', '&#227;', '&#228;', '&#229;', '&#230;', '&#231;', '&#232;', '&#233;', '&#234;', '&#235;', '&#236;', '&#237;', '&#238;', '&#239;', '&#240;', '&#241;', '&#242;', '&#243;', '&#244;', '&#245;', '&#246;', '&#247;', '&#248;', '&#249;', '&#250;', '&#251;', '&#252;', '&#253;', '&#254;', '&#255;', '&#34;', '&#38;', '&#60;', '&#62;', '&#338;', '&#339;', '&#352;', '&#353;', '&#376;', '&#710;', '&#732;', '&#8194;', '&#8195;', '&#8201;', '&#8204;', '&#8205;', '&#8206;', '&#8207;', '&#8211;', '&#8212;', '&#8216;', '&#8217;', '&#8218;', '&#8220;', '&#8221;', '&#8222;', '&#8224;', '&#8225;', '&#8240;', '&#8249;', '&#8250;', '&#8364;', '&#402;', '&#913;', '&#914;', '&#915;', '&#916;', '&#917;', '&#918;', '&#919;', '&#920;', '&#921;', '&#922;', '&#923;', '&#924;', '&#925;', '&#926;', '&#927;', '&#928;', '&#929;', '&#931;', '&#932;', '&#933;', '&#934;', '&#935;', '&#936;', '&#937;', '&#945;', '&#946;', '&#947;', '&#948;', '&#949;', '&#950;', '&#951;', '&#952;', '&#953;', '&#954;', '&#955;', '&#956;', '&#957;', '&#958;', '&#959;', '&#960;', '&#961;', '&#962;', '&#963;', '&#964;', '&#965;', '&#966;', '&#967;', '&#968;', '&#969;', '&#977;', '&#978;', '&#982;', '&#8226;', '&#8230;', '&#8242;', '&#8243;', '&#8254;', '&#8260;', '&#8472;', '&#8465;', '&#8476;', '&#8482;', '&#8501;', '&#8592;', '&#8593;', '&#8594;', '&#8595;', '&#8596;', '&#8629;', '&#8656;', '&#8657;', '&#8658;', '&#8659;', '&#8660;', '&#8704;', '&#8706;', '&#8707;', '&#8709;', '&#8711;', '&#8712;', '&#8713;', '&#8715;', '&#8719;', '&#8721;', '&#8722;', '&#8727;', '&#8730;', '&#8733;', '&#8734;', '&#8736;', '&#8743;', '&#8744;', '&#8745;', '&#8746;', '&#8747;', '&#8756;', '&#8764;', '&#8773;', '&#8776;', '&#8800;', '&#8801;', '&#8804;', '&#8805;', '&#8834;', '&#8835;', '&#8836;', '&#8838;', '&#8839;', '&#8853;', '&#8855;', '&#8869;', '&#8901;', '&#8968;', '&#8969;', '&#8970;', '&#8971;', '&#9001;', '&#9002;', '&#9674;', '&#9824;', '&#9827;', '&#9829;', '&#9830;');
        return this.swapArrayVals(s, arr1, arr2);
    },

    // Convert Numerical entities into HTML entities
    NumericalToHTML: function(s) {
        var arr1 = new Array('&#160;', '&#161;', '&#162;', '&#163;', '&#164;', '&#165;', '&#166;', '&#167;', '&#168;', '&#169;', '&#170;', '&#171;', '&#172;', '&#173;', '&#174;', '&#175;', '&#176;', '&#177;', '&#178;', '&#179;', '&#180;', '&#181;', '&#182;', '&#183;', '&#184;', '&#185;', '&#186;', '&#187;', '&#188;', '&#189;', '&#190;', '&#191;', '&#192;', '&#193;', '&#194;', '&#195;', '&#196;', '&#197;', '&#198;', '&#199;', '&#200;', '&#201;', '&#202;', '&#203;', '&#204;', '&#205;', '&#206;', '&#207;', '&#208;', '&#209;', '&#210;', '&#211;', '&#212;', '&#213;', '&#214;', '&#215;', '&#216;', '&#217;', '&#218;', '&#219;', '&#220;', '&#221;', '&#222;', '&#223;', '&#224;', '&#225;', '&#226;', '&#227;', '&#228;', '&#229;', '&#230;', '&#231;', '&#232;', '&#233;', '&#234;', '&#235;', '&#236;', '&#237;', '&#238;', '&#239;', '&#240;', '&#241;', '&#242;', '&#243;', '&#244;', '&#245;', '&#246;', '&#247;', '&#248;', '&#249;', '&#250;', '&#251;', '&#252;', '&#253;', '&#254;', '&#255;', '&#34;', '&#38;', '&#60;', '&#62;', '&#338;', '&#339;', '&#352;', '&#353;', '&#376;', '&#710;', '&#732;', '&#8194;', '&#8195;', '&#8201;', '&#8204;', '&#8205;', '&#8206;', '&#8207;', '&#8211;', '&#8212;', '&#8216;', '&#8217;', '&#8218;', '&#8220;', '&#8221;', '&#8222;', '&#8224;', '&#8225;', '&#8240;', '&#8249;', '&#8250;', '&#8364;', '&#402;', '&#913;', '&#914;', '&#915;', '&#916;', '&#917;', '&#918;', '&#919;', '&#920;', '&#921;', '&#922;', '&#923;', '&#924;', '&#925;', '&#926;', '&#927;', '&#928;', '&#929;', '&#931;', '&#932;', '&#933;', '&#934;', '&#935;', '&#936;', '&#937;', '&#945;', '&#946;', '&#947;', '&#948;', '&#949;', '&#950;', '&#951;', '&#952;', '&#953;', '&#954;', '&#955;', '&#956;', '&#957;', '&#958;', '&#959;', '&#960;', '&#961;', '&#962;', '&#963;', '&#964;', '&#965;', '&#966;', '&#967;', '&#968;', '&#969;', '&#977;', '&#978;', '&#982;', '&#8226;', '&#8230;', '&#8242;', '&#8243;', '&#8254;', '&#8260;', '&#8472;', '&#8465;', '&#8476;', '&#8482;', '&#8501;', '&#8592;', '&#8593;', '&#8594;', '&#8595;', '&#8596;', '&#8629;', '&#8656;', '&#8657;', '&#8658;', '&#8659;', '&#8660;', '&#8704;', '&#8706;', '&#8707;', '&#8709;', '&#8711;', '&#8712;', '&#8713;', '&#8715;', '&#8719;', '&#8721;', '&#8722;', '&#8727;', '&#8730;', '&#8733;', '&#8734;', '&#8736;', '&#8743;', '&#8744;', '&#8745;', '&#8746;', '&#8747;', '&#8756;', '&#8764;', '&#8773;', '&#8776;', '&#8800;', '&#8801;', '&#8804;', '&#8805;', '&#8834;', '&#8835;', '&#8836;', '&#8838;', '&#8839;', '&#8853;', '&#8855;', '&#8869;', '&#8901;', '&#8968;', '&#8969;', '&#8970;', '&#8971;', '&#9001;', '&#9002;', '&#9674;', '&#9824;', '&#9827;', '&#9829;', '&#9830;');
        var arr2 = new Array('&nbsp;', '&iexcl;', '&cent;', '&pound;', '&curren;', '&yen;', '&brvbar;', '&sect;', '&uml;', '&copy;', '&ordf;', '&laquo;', '&not;', '&shy;', '&reg;', '&macr;', '&deg;', '&plusmn;', '&sup2;', '&sup3;', '&acute;', '&micro;', '&para;', '&middot;', '&cedil;', '&sup1;', '&ordm;', '&raquo;', '&frac14;', '&frac12;', '&frac34;', '&iquest;', '&agrave;', '&aacute;', '&acirc;', '&atilde;', '&Auml;', '&aring;', '&aelig;', '&ccedil;', '&egrave;', '&eacute;', '&ecirc;', '&euml;', '&igrave;', '&iacute;', '&icirc;', '&iuml;', '&eth;', '&ntilde;', '&ograve;', '&oacute;', '&ocirc;', '&otilde;', '&Ouml;', '&times;', '&oslash;', '&ugrave;', '&uacute;', '&ucirc;', '&Uuml;', '&yacute;', '&thorn;', '&szlig;', '&agrave;', '&aacute;', '&acirc;', '&atilde;', '&auml;', '&aring;', '&aelig;', '&ccedil;', '&egrave;', '&eacute;', '&ecirc;', '&euml;', '&igrave;', '&iacute;', '&icirc;', '&iuml;', '&eth;', '&ntilde;', '&ograve;', '&oacute;', '&ocirc;', '&otilde;', '&ouml;', '&divide;', '&Oslash;', '&ugrave;', '&uacute;', '&ucirc;', '&uuml;', '&yacute;', '&thorn;', '&yuml;', '&quot;', '&amp;', '&lt;', '&gt;', '&oelig;', '&oelig;', '&scaron;', '&scaron;', '&yuml;', '&circ;', '&tilde;', '&ensp;', '&emsp;', '&thinsp;', '&zwnj;', '&zwj;', '&lrm;', '&rlm;', '&ndash;', '&mdash;', '&lsquo;', '&rsquo;', '&sbquo;', '&ldquo;', '&rdquo;', '&bdquo;', '&dagger;', '&dagger;', '&permil;', '&lsaquo;', '&rsaquo;', '&euro;', '&fnof;', '&alpha;', '&beta;', '&gamma;', '&delta;', '&epsilon;', '&zeta;', '&eta;', '&theta;', '&iota;', '&kappa;', '&lambda;', '&mu;', '&nu;', '&xi;', '&omicron;', '&pi;', '&rho;', '&sigma;', '&tau;', '&upsilon;', '&phi;', '&chi;', '&psi;', '&omega;', '&alpha;', '&beta;', '&gamma;', '&delta;', '&epsilon;', '&zeta;', '&eta;', '&theta;', '&iota;', '&kappa;', '&lambda;', '&mu;', '&nu;', '&xi;', '&omicron;', '&pi;', '&rho;', '&sigmaf;', '&sigma;', '&tau;', '&upsilon;', '&phi;', '&chi;', '&psi;', '&omega;', '&thetasym;', '&upsih;', '&piv;', '&bull;', '&hellip;', '&prime;', '&prime;', '&oline;', '&frasl;', '&weierp;', '&image;', '&real;', '&trade;', '&alefsym;', '&larr;', '&uarr;', '&rarr;', '&darr;', '&harr;', '&crarr;', '&larr;', '&uarr;', '&rarr;', '&darr;', '&harr;', '&forall;', '&part;', '&exist;', '&empty;', '&nabla;', '&isin;', '&notin;', '&ni;', '&prod;', '&sum;', '&minus;', '&lowast;', '&radic;', '&prop;', '&infin;', '&ang;', '&and;', '&or;', '&cap;', '&cup;', '&int;', '&there4;', '&sim;', '&cong;', '&asymp;', '&ne;', '&equiv;', '&le;', '&ge;', '&sub;', '&sup;', '&nsub;', '&sube;', '&supe;', '&oplus;', '&otimes;', '&perp;', '&sdot;', '&lceil;', '&rceil;', '&lfloor;', '&rfloor;', '&lang;', '&rang;', '&loz;', '&spades;', '&clubs;', '&hearts;', '&diams;');
        return this.swapArrayVals(s, arr1, arr2);
    },


    // Numerically encodes all unicode characters
    numEncode: function(s) {

        if (this.isEmpty(s)) return "";

        var e = "";
        for (var i = 0; i < s.length; i++) {
            var c = s.charAt(i);
            if (c < " " || c > "~") {
                c = "&#" + c.charCodeAt() + ";";
            }
            e += c;
        }
        return e;
    },

    // HTML Decode numerical and HTML entities back to original values
    htmlDecode: function(s) {

        var c, m, d = s;

        if (this.isEmpty(d)) return "";

        // convert HTML entites back to numerical entites first
        d = this.HTML2Numerical(d);

        // look for numerical entities &#34;
        arr = d.match(/&#[0-9]{1,5};/g);

        // if no matches found in string then skip
        if (arr != null) {
            for (var x = 0; x < arr.length; x++) {
                m = arr[x];
                c = m.substring(2, m.length - 1); //get numeric part which is refernce to unicode character
                // if its a valid number we can decode
                if (c >= -32768 && c <= 65535) {
                    // decode every single match within string
                    d = d.replace(m, String.fromCharCode(c));
                } else {
                    d = d.replace(m, ""); //invalid so replace with nada
                }
            }
        }

        return d;
    },

    // encode an input string into either numerical or HTML entities
    htmlEncode: function(s, dbl) {

        if (this.isEmpty(s)) return "";

        // do we allow double encoding? E.g will &amp; be turned into &amp;amp;
        dbl = dbl | false; //default to prevent double encoding

        // if allowing double encoding we do ampersands first
        if (dbl) {
            if (this.EncodeType == "numerical") {
                s = s.replace(/&/g, "&#38;");
            } else {
                s = s.replace(/&/g, "&amp;");
            }
        }

        // convert the xss chars to numerical entities ' " < >
        s = this.XSSEncode(s, false);

        if (this.EncodeType == "numerical" || !dbl) {
            // Now call function that will convert any HTML entities to numerical codes
            s = this.HTML2Numerical(s);
        }

        // Now encode all chars above 127 e.g unicode
        s = this.numEncode(s);

        // now we know anything that needs to be encoded has been converted to numerical entities we
        // can encode any ampersands & that are not part of encoded entities
        // to handle the fact that I need to do a negative check and handle multiple ampersands &&&
        // I am going to use a placeholder

        // if we don't want double encoded entities we ignore the & in existing entities
        if (!dbl) {
            s = s.replace(/&#/g, "##AMPHASH##");

            if (this.EncodeType == "numerical") {
                s = s.replace(/&/g, "&#38;");
            } else {
                s = s.replace(/&/g, "&amp;");
            }

            s = s.replace(/##AMPHASH##/g, "&#");
        }

        // replace any malformed entities
        s = s.replace(/&#\d*([^\d;]|$)/g, "$1");

        if (!dbl) {
            // safety check to correct any double encoded &amp;
            s = this.correctEncoding(s);
        }

        // now do we need to convert our numerical encoded string into entities
        if (this.EncodeType == "entity") {
            s = this.NumericalToHTML(s);
        }

        return s;
    },

    // Encodes the basic 4 characters used to malform HTML in XSS hacks
    XSSEncode: function(s, en) {
        if (!this.isEmpty(s)) {
            en = en || true;
            // do we convert to numerical or html entity?
            if (en) {
                s = s.replace(/\'/g, "&#39;"); //no HTML equivalent as &apos is not cross browser supported
                s = s.replace(/\"/g, "&quot;");
                s = s.replace(/</g, "&lt;");
                s = s.replace(/>/g, "&gt;");
            } else {
                s = s.replace(/\'/g, "&#39;"); //no HTML equivalent as &apos is not cross browser supported
                s = s.replace(/\"/g, "&#34;");
                s = s.replace(/</g, "&#60;");
                s = s.replace(/>/g, "&#62;");
            }
            return s;
        } else {
            return "";
        }
    },

    // returns true if a string contains html or numerical encoded entities
    hasEncoded: function(s) {
        if (/&#[0-9]{1,5};/g.test(s)) {
            return true;
        } else if (/&[A-Z]{2,6};/gi.test(s)) {
            return true;
        } else {
            return false;
        }
    },

    // will remove any unicode characters
    stripUnicode: function(s) {
        return s.replace(/[^\x20-\x7E]/g, "");

    },

    // corrects any double encoded &amp; entities e.g &amp;amp;
    correctEncoding: function(s) {
        return s.replace(/(&amp;)(amp;)+/, "$1");
    },


    // Function to loop through an array swaping each item with the value from another array e.g swap HTML entities with Numericals
    swapArrayVals: function(s, arr1, arr2) {
        if (this.isEmpty(s)) return "";
        var re;
        if (arr1 && arr2) {
            //ShowDebug("in swapArrayVals arr1.length = " + arr1.length + " arr2.length = " + arr2.length)
            // array lengths must match
            if (arr1.length == arr2.length) {
                for (var x = 0, i = arr1.length; x < i; x++) {
                    re = new RegExp(arr1[x], 'g');
                    s = s.replace(re, arr2[x]); //swap arr1 item with matching item from arr2	
                }
            }
        }
        return s;
    },

    inArray: function(item, arr) {
        for (var i = 0, x = arr.length; i < x; i++) {
            if (arr[i] === item) {
                return i;
            }
        }
        return -1;
    }

}

function navigateElement(elm) {
    if (!elm) return;
    var el = elm.getAttribute('location');
    if (el) {
        location.href = el;
    }
}

function checkSetLeftFrame() {
    if (typeof (window._leftFrameSource) != 'undefined' && typeof (window._leftFrameContainer) != 'undefined') {
        if (typeof (window._leftFrameSet) == 'undefined') {
            window._leftFrameContainer.innerHTML = Encoder.htmlDecode(window._leftFrameSource);
            window._leftFrameSet = true;
        }
    }
}

checkSetLeftFrame();